Skip to content
C++
All coursesPlacement Report
‹ Back to previous sectionCourse homeAll page URLs

C++ Telephonic Interview Questions & Answers

30 questions for the telephonic interview stage — 13 easy, 15 medium, 2 hard.

About the telephonic interview round

The telephonic or screening round is a 15-30 minute call with a recruiter or engineer. It checks your basics, your CV and whether you can explain C++ concepts clearly without a screen to point at.

Tips for the telephonic interview round

  • Keep your CV in front of you and be ready to explain every line on it.
  • Answer in short, clear sentences; there is no whiteboard, so structure matters.
  • Take the call somewhere quiet and confirm the time in advance.
  • Prepare one question to ask the interviewer at the end.
Solved — telephonic interviewStart practicing
3 QUESTIONS FREESign up to unlock the full question bank and track your progress.Unlock every question and answer, then continue practising company-wise and package-wise.
3 questions free Unlock the rest in seconds
01

What is a dangling pointer?

Pointers and Memory ManagementEasy
Save to ▾
Show answer
A dangling pointer points to memory that has already been freed or has gone out of scope, for example the address of a local variable returned from a function, or a pointer used after delete. Dereferencing it is undefined behaviour and may crash much later in unrelated code. Prevent it with smart pointers, clear ownership rules and by never returning addresses of local variables.
02

What are lvalues and rvalues?

C++ Basics and SyntaxMedium
Save to ▾
Show answer
An lvalue has identity and a persistent address, such as a named variable x. An rvalue is a temporary without lasting identity, such as 5 or the result of a + b. C++11 splits these further into lvalue, xvalue and prvalue. The distinction matters because rvalue references, written T&&, bind to temporaries and enable move semantics, letting the program steal resources instead of making expensive copies.
03

What are default arguments and what rules apply to them?

C++ Basics and SyntaxEasy
Save to ▾
Show answer
Default arguments supply values when a caller leaves out trailing arguments, for example void log(const std::string& msg, int level = 1);. Defaults must appear at the end of the parameter list and be given only once, usually in the header declaration. They are bound at compile time, so for a virtual function the default value comes from the static type of the pointer, not the dynamic type, which is a common trap.
04

What are race conditions and data races?

Multithreading and ConcurrencyEasy
Save to ▾
Show answer
A data race occurs when two threads access the same memory at the same time, at least one writes, and there is no synchronisation; in C++ this is undefined behaviour. A race condition is a broader logic bug where the result depends on timing, such as check-then-act on a file or a balance, even if each access is atomic. Mutexes, atomics and careful design of shared state prevent both.
05

Sorting a vector of large objects is slow. What can you do?

Standard Template Library (STL)Medium
Save to ▾
Show answer
Sorting moves elements many times, so large objects that copy instead of move are expensive. First ensure the type has a noexcept move constructor. If moves are still heavy, sort a vector of indices or pointers with a comparator on the key, then reorder once if needed. Precomputing the sort key avoids repeated expensive comparisons. Use std::stable_sort only when equal-element order matters.
06

Solve two sum: return indices of two numbers that add up to a target.

Standard Template Library (STL)Easy
Save to ▾
Show answer
#include <unordered_map> #include <vector> std::vector<int> twoSum(const std::vector<int>& nums, int target) { std::unordered_map<int, int> seen; // value -> index for (int i = 0; i < static_cast<int>(nums.size()); ++i) { auto it = seen.find(target - nums[i]); if (it != seen.end()) return {it->second, i}; seen[nums[i]] = i; } return {}; } // O(n) time, O(n) space.
07

Code that erases elements from a vector inside a range-based for loop crashes. Why, and what is the correct way?

Standard Template Library (STL)Medium
Save to ▾
Show answer
erase invalidates the iterator being used by the loop, so the next increment is undefined behaviour. Range-based for loops cannot handle this safely. Use the iterator returned by erase: for (auto it = v.begin(); it != v.end();) { if (bad(*it)) it = v.erase(it); else ++it; }. Better still, use std::erase_if, which is O(n) overall instead of O(n squared) for repeated erases.
08

What is CMake and why is it used for C++ projects?

Performance, Debugging and Build ToolsEasy
Save to ▾
Show answer
CMake is a cross-platform build system generator. You describe targets, source files, include paths and dependencies in CMakeLists.txt, and CMake generates Makefiles, Ninja files or Visual Studio projects. Modern CMake is target based, using target_link_libraries and target_include_directories so settings flow to dependents. It integrates with package managers such as vcpkg and Conan and with CTest for running tests.
09

You must find the top 100 most frequent items in a stream of 10 million events. How would you do it?

Standard Template Library (STL)Hard
Save to ▾
Show answer
Count frequencies with an unordered_map reserved to the expected key count. Then keep a min-heap, a priority_queue with greater comparator, of size 100: push each entry and pop when size exceeds 100, which costs O(n log k). Alternatively copy counts into a vector and use std::nth_element for O(n) average. If memory is limited and approximate results are fine, a Count-Min sketch helps.
10

Which unit testing frameworks are common in C++?

Performance, Debugging and Build ToolsEasy
Save to ▾
Show answer
GoogleTest with GoogleMock is the most widely used; it provides TEST and TEST_F macros, assertions such as EXPECT_EQ and ASSERT_TRUE, fixtures and mocking. Catch2 and doctest are lightweight, header-friendly alternatives with natural syntax. Tests are usually registered with CTest in CMake and run in CI on every merge. Good tests are fast, independent and cover edge cases like empty input and overflow.
11

What is pointer arithmetic?

Pointers and Memory ManagementEasy
Save to ▾
Show answer
Adding an integer to a pointer moves it by that many elements, not bytes, so p + 1 on an int* advances by sizeof(int) bytes. Subtracting two pointers into the same array gives the number of elements between them as ptrdiff_t. Arithmetic is only valid inside an array or one past its end; moving beyond that is undefined behaviour. Contiguous iterators work on the same idea.
12

What is a void pointer and when would you use it?

Pointers and Memory ManagementEasy
Save to ▾
Show answer
A void* can hold the address of any object type but cannot be dereferenced or used in arithmetic until it is cast back to a real type. It appears in C APIs such as malloc, memcpy and callback user-data parameters. In C++ code, templates, std::any or std::variant are better because void* removes type safety and mistakes appear only at run time.
13

What does C++20 std::jthread add over std::thread?

Multithreading and ConcurrencyMedium
Save to ▾
Show answer
std::jthread joins automatically in its destructor, so forgetting join no longer calls std::terminate. It also supports cooperative cancellation: the thread function can take a std::stop_token, check stop_requested() in its loop, and the owner calls request_stop(), which the destructor also does before joining. std::stop_callback lets you register cleanup actions. This makes long-running worker threads safer to write.
14

Write a Shape hierarchy with a virtual area function and use it polymorphically.

Object-Oriented Programming in C++Easy
Save to ▾
Show answer
#include <iostream> #include <memory> #include <vector> struct Shape { virtual ~Shape() = default; virtual double area() const = 0; }; struct Circle : Shape { double r; explicit Circle(double r) : r(r) {} double area() const override { return 3.14159 * r * r; } }; struct Rect : Shape { double w, h; Rect(double w, double h) : w(w), h(h) {} double area() const override { return w * h; } }; int main() { std::vector<std::unique_ptr<Shape>> v; v.push_back(std::make_unique<Circle>(2)); v.push_back(std::make_unique<Rect>(3, 4)); for (const auto& s : v) std::cout << s->area() << '\n'; }
15

A program crashes with terminate called without an active exception when a function returns. What is the cause?

Multithreading and ConcurrencyMedium
Save to ▾
Show answer
A std::thread object that is still joinable was destroyed, often because the function returned early or threw before reaching join. The std::thread destructor calls std::terminate in that case. Fix it by making sure every thread is joined on all paths, using an RAII guard, or switching to std::jthread, which joins automatically. Be careful with detach, since detached threads may access destroyed data.
16

Tell me about a time you designed the class structure for a module and how you handled review feedback.

Object-Oriented Programming in C++Medium
Save to ▾
Show answer
Situation: I had to build a report export module supporting PDF, CSV and Excel. Task: design it so new formats were easy to add. Action: I proposed an abstract Exporter interface and a factory, shared a short design note and asked seniors to review before coding. They pointed out duplicated formatting logic, so I extracted a Formatter helper. Result: a fourth format was later added in one day with no changes to existing classes.
17

Explain the stages of compiling and running a C++ program.

C++ Basics and SyntaxMedium
Save to ▾
Show answer
There are four stages. The preprocessor expands #include directives and macros into a translation unit. The compiler turns each translation unit into assembly and then an object file. The linker combines object files and libraries and resolves symbols into an executable. At run time the loader maps it into memory. A missing function body therefore shows up as a linker error, not a compiler error.
18

Is it expensive to return a large std::vector from a function by value?

Modern C++ (C++11 to C++23)Medium
Save to ▾
Show answer
Usually no. Return value optimisation constructs the result directly in the caller's storage, and since C++17 this copy elision is guaranteed when returning a prvalue. For a named local, compilers apply named RVO, and if they cannot, the vector is moved, which only copies three pointers. So return by value is clean and fast. Do not write return std::move(local); because it can block elision.
19

What is a pure virtual function and an abstract class?

Object-Oriented Programming in C++Easy
Save to ▾
Show answer
A pure virtual function is declared with = 0, such as virtual double area() const = 0;, and has no required implementation in the base. A class with at least one pure virtual function is abstract and cannot be instantiated; it only defines an interface. Derived classes must override every pure virtual function to become concrete. This is how C++ expresses interfaces like Shape or PaymentGateway.
20

What is std::string_view and what are its pitfalls?

Modern C++ (C++11 to C++23)Medium
Save to ▾
Show answer
string_view is a non-owning pointer and length pair that refers to existing characters, so passing it avoids copies and accepts both std::string and literals. The main pitfall is lifetime: it must not outlive the data it views, so returning a string_view to a local string or a temporary dangles. It is also not guaranteed to be null-terminated, so do not pass data() to C functions expecting C strings.
21

What is the difference between an inline function and a macro?

C++ Basics and SyntaxMedium
Save to ▾
Show answer
A macro is text substitution done by the preprocessor with no type checking, so #define SQ(x) x*x gives a wrong result for SQ(a+1) and may evaluate arguments twice. An inline function is a real function with type checking, scope and debugger support, and the compiler may expand it at the call site. In modern C++ inline mainly allows a function to be defined in a header without breaking the One Definition Rule.
22

What do auto and decltype do?

Modern C++ (C++11 to C++23)Easy
Save to ▾
Show answer
auto deduces a variable's type from its initialiser, so auto it = m.begin(); avoids long iterator types. It drops top-level const and references unless you write const auto& or auto&. decltype(expr) yields the declared type of an expression without evaluating it, useful in generic code and return types. decltype(auto) keeps reference-ness exactly, which matters when forwarding return values.
23

What is a pointer and how is it different from a reference?

Pointers and Memory ManagementEasy
Save to ▾
Show answer
A pointer is a variable that stores a memory address; it can be null, can be reassigned and supports arithmetic. A reference is an alias for an existing object; it must be initialised, cannot be reseated to another object and cannot be null in valid code. Pointers suit optional values, arrays and dynamic memory, while references give clean syntax for parameters and operator overloading.
24

Memory leaks appear when derived objects stored as Base* are deleted. What is wrong and how do you fix it?

Object-Oriented Programming in C++Medium
Save to ▾
Show answer
The base class almost certainly has a non-virtual destructor, so delete through a Base* runs only the base destructor and the derived members, such as buffers or file handles, are never released. Add virtual ~Base() = default; to the base. Better still, store the objects as std::unique_ptr<Base> so deletion is automatic, and enable -Wdelete-non-virtual-dtor to catch this at compile time.
25

What is function overloading and how does the compiler choose an overload?

C++ Basics and SyntaxMedium
Save to ▾
Show answer
Overloading means several functions share a name but differ in the number or types of parameters; return type alone is not enough. The compiler runs overload resolution: exact matches win, then promotions such as char to int, then standard conversions, then user-defined conversions. If two candidates are equally good the call is ambiguous and compilation fails. Name mangling gives every overload a unique linker symbol.
26

Tell me about a time you found a difficult bug in your C++ code.

C++ Basics and SyntaxMedium
Save to ▾
Show answer
Situation: a service crashed randomly about once a day in production. Task: find the root cause without blocking releases. Action: I enabled core dumps, analysed them in gdb and saw a corrupted vector inside a callback. A staging run with AddressSanitizer showed a use-after-free because a lambda captured a raw pointer to a destroyed object. I changed it to capture a weak_ptr. Result: no crashes for months, and sanitizer runs were added to CI.
27

Find the middle node of a linked list in a single pass.

Pointers and Memory ManagementEasy
Save to ▾
Show answer
Node* middle(Node* head) { Node* slow = head; Node* fast = head; while (fast && fast->next) { slow = slow->next; fast = fast->next->next; } return slow; } // fast moves two steps and slow one step, so slow stops at the middle.
28

How does std::condition_variable work and what are spurious wakeups?

Multithreading and ConcurrencyMedium
Save to ▾
Show answer
A condition variable lets a thread sleep until another thread signals that some state changed. The waiter holds a unique_lock and calls cv.wait(lock, predicate), which releases the mutex while sleeping and reacquires it on wake. The notifier changes the state under the mutex and calls notify_one or notify_all. Threads can wake without notification, called spurious wakeups, so always wait with a predicate that rechecks the condition.
29

What are memory alignment and padding?

Pointers and Memory ManagementHard
Save to ▾
Show answer
CPUs access data fastest at addresses that are multiples of its size, so the compiler aligns members and inserts padding bytes. A struct of char, int, char is usually 12 bytes, while ordering it as int, char, char gives 8. alignof reports alignment and alignas raises it, for example to 64 bytes to keep data used by different threads on separate cache lines. Packed structs save space but may be slower.
30

Describe a time you improved code quality by changing how memory was managed.

Pointers and Memory ManagementMedium
Save to ▾
Show answer
Situation: our module used raw new and delete everywhere and QA reported frequent leaks. Task: make it safe without a full rewrite. Action: I proposed a step-by-step migration to unique_ptr and std::vector, wrote a one-page ownership guideline and enabled LeakSanitizer in CI so new leaks failed the build. Result: leak reports dropped to zero within two sprints and reviews became faster because ownership was obvious.

Frequently asked questions

What happens in the C++ telephonic interview round?

The telephonic or screening round is a 15-30 minute call with a recruiter or engineer. It checks your basics, your CV and whether you can explain C++ concepts clearly without a screen to point at.

How do I clear the telephonic interview round?

Keep your CV in front of you and be ready to explain every line on it. Answer in short, clear sentences; there is no whiteboard, so structure matters. Take the call somewhere quiet and confirm the time in advance.

Which round comes next?

A typical order is online assessment, telephonic screening, one or two technical rounds, a managerial round and HR. Use the other round pages to practise each stage.

Practise every interview round

Online Assessment questionsTechnical Round questionsManagerial Round questionsRapid-Fire questionsHR & behavioural questionsFull mock interview

More ways to practise

Company-wise C++ questionsExperience-wise C++ questionsRole-wise C++ questionsCity-wise C++ questionsMost asked C++ questionsScenario-based questionsPractical / hands-on questionsHR & behavioural questionsC++ mock interviewOnline assessment questionsTechnical round questionsManagerial round questionsC++ topic sheets