C++ coding interview questions for beginners

C++ is a general purpose programming language that was developed in 1979 by Bjarne Stroustrup. C++ was born as an object-oriented superset of C. According to the Stack Overflow Developer Survey, C++ is one of the top six most popular programming languages. It is primarily used as an object-oriented programming (OOP) language.

Some C++ characteristics:

Platform dependent: If a program is written and compiled on a particular operating system, it may not run on any other operating system.
Compiled: A compiler is required for all code written in C++ to be executed.
Multi-paradigm: While C++ is capable of object-oriented programming, it isn’t solely an OOP language. C++ still incorporates traditional “C style” programming.
Structured: Like all modern programming languages, C++ can be divided into sections using control flow statements, loops, and functions.
Rich library: There are plenty of built-in functions through the Standard Template Library (STL).
Highly optimizable: C++ memory management and low-level syntax allow a programmer to write highly optimized code that may have a significantly smaller memory footprint and run faster as compared to almost all other programming languages.

What is object-oriented programming (OOP)?#

Object-oriented programming is a programming paradigm that organizes programs around objects, where each object may contain data and relevant functions. The person responsible for coining the term “object-oriented programming,” Alan Kay, stresses the importance of messaging for communication between objects.

That said, the relationship between objects is the foundation of object-oriented programming.

The four pillars of OOP are:

Abstraction: Abstraction refers to the ability of a class to hide its internal implementation details and expose only its essential features to the outside world. This allows users of an object of that class to interact with it without needing to know its internal workings.
Encapsulation: Encapsulation refers to the idea of keeping the internal state (i.e. current values of attributes) and behavior of an object hidden from the outside world while providing a public interface for interacting with it. This allows the class or object to control access to its internal data and behavior, and protect it from being modified or accessed in an unintended way.
Inheritance: Two classes (say Car, and Toyota) have the inheritance relationship between them when one class, say Toyota, is extending the other class (Car). In this example, Car will be referred to as a base-class or a superclass whereas Toyota will be referred to as a derived-class or subclass. Inheritance allows a derived class to take some of the attributes and methods of the base class. Moreover, the derived class may enhance the base class by introducing additional attributes and methods. Inheritance promotes code reusability and extensibility.
Polymorphism: Polymorphism allows objects of different classes to be treated as objects of one of their common superclasses. This enables methods to be defined on the superclass to be overridden by subclasses to provide their own implementation. Thus a single method call can be executed on objects of multiple classes, with the appropriate implementation being called based on the actual class of the object.

Abstraction vs. Encapsulation: The difference between abstraction and encapsulation is commonly misunderstood. Abstraction is about hiding complexity and only showing the essential features, while encapsulation is about protecting the internal state and behavior of an object and controlling access to it.

How to prepare for a coding interview#

It’s no secret you have to practice, but five out of six interviewers will fail a coding interview. So, how do you practice effectively? There are two main schools of thought when it comes to coding interview prep:

The Leetcode approach: Drill as many problems as possible in the hopes that one you’re familiar with is asked in an interview.

Pattern-based approach: Learn a total of 24 patterns that teach how to recognize, diagnose, and solve any interview question you may be presented with.

Get hands-on with C++ today

Grokking the Coding Interview Patterns in C++

With thousands of potential questions to account for, preparing for the coding interview can feel like an impossible challenge. Yet with a strategic approach, coding interview prep doesn’t have to take more than a few weeks. Stop drilling endless sets of practice problems, and prepare more efficiently by learning coding interview patterns. This course teaches you the underlying patterns behind common coding interview questions. By learning these essential patterns, you will be able to unpack and answer any problem the right way — just by assessing the problem statement. This approach was created by FAANG hiring managers to help you prepare for the typical rounds of interviews at major tech companies like Apple, Google, Meta, Microsoft, and Amazon. Before long, you will have the skills you need to unlock even the most challenging questions, grok the coding interview, and level up your career with confidence. This course is also available in JavaScript, Java, Python, C# and Go — with more coming soon!

85hrs

Intermediate

442 Challenges

443 Quizzes

Modern C++ essentials interviewers expect#

Many C++ coding interviews now assume familiarity with modern C++ (C++11 and beyond).
Expect quick conceptual probes such as:

“Why prefer auto?” or “When would you pass by value and move vs pass by const reference?”

Interviewers look for concise, practical answers that reflect real-world fluency.
Here’s a sharp baseline to cover key modern features:

Type deduction & auto#

Reduces verbosity and prevents narrowing conversions.
Prefer auto when the type is obvious from context (e.g., iterators, lambdas), but still aim for readability.

2. What are classes and objects in C++?#

Classes and objects are not a feature of C++ in particular. They are integral to all object-oriented programming languages. A class is like a blueprint which does not exist during a program execution. However, based on a class design, at runtime, we can create its object(s). An object has the same attributes and methods which were defined in its class. Let’s see a simple example of creating a class and making its objects in C++:

Attribute vs. Variable: An attribute is a variable defined in a class.

C++

#include <iostream>
class Car {
   public:
   /**
    * The attributes of class Car.
   */
   int number;
   int year;
  
   /*
    * The methods of class Car.
    */
  
   int getNumber() {
       return number;
   }
   int getYear() {
       return year;
   }
   void setNumber(int number) {
       this->number = number;
   }
   void setYear(int year) {
       this->year = year;
   }
};
int main() {
   /**
    * Creating object of the class Car
    */
   Car myCar;
  
   // Using the car object
   myCar.setNumber(777);
   myCar.setYear(2018);
  
   //Printing its attributes
   std::cout << "My car number and manufacturing year are: " << myCar.number << ", " << myCar.year << "\n";
   return 0;
}

3. What is a constructor in C++?#

A constructor is a special function of a class which is called automatically upon creation of an object. Thus, a constructor usually outline the steps that occur when one instance of a class is created.

A constructor’s name must be the same as it’s class name.

Put simply, constructors can create and initialize objects of their class type. They cannot be classified as volatile or static nor can the body of a constructor contain a return statement.

The following code playground demonstrates the creation and use of a class’s constructors:

C++

#include <iostream>
class Car {
   public:
   /**
    * The attributes of class Car.
   */
   int number;
   int year;
  
   /**
    * An empty constructor of the class Car
    */
    Car() {
        std::cout << "Constructor-A is called\n";
    }
  
   /**
    * Another constructor of the class Car
    */
    Car(int number, int year) {
        std::cout << "Constructor-B is called\n";
        this->number = number;
        this->year = year;
    }
   
   /*
    * The methods of the class Car.
    */
  
   int getNumber() {
       return number;
   }
  
   int getYear() {
       return year;
   }
  
   void setNumber(int number) {
       this->number = number;
   }
  
   void setYear(int year) {
       this->year = year;
   }
};
int main() {
   /**
    * Creating object of the class Car and using its constructor
    */
   Car myCar(777, 2018);
  
   //Printing its attributes
   std::cout << "My car number and manufacturing year are: " << myCar.number << ", " << myCar.year << "\n";
   return 0;
}

4. Explain the difference between struct and class#

Also called structs, structures serve as a way to group related variables together. Each variable is known as a member of the structure.

Structures are created with the struct keyword and members are declared within curly braces.

C++ structure is very similar to class. However, a key difference is that class attributes are by default ‘private’ whereas struct attributes are by default ‘public’. Thus, by default ‘struct’ attributes can be directly accessed and modified.

5. What does the this pointer do?#

A pointer is a variable that stores the address of another variable. The this pointer is only accessible in non-static member functions of classes, structs, or unions. It refers to the object on which the member function is called.

There are several use cases for the this pointer.

Current object: the this pointer can be used to return the reference of the calling object.
Same name: If a parameter and private function both have the same name, the this pointer can be used to distinguish between the two when assigning values.

The this pointer is always passed to the constructor as it holds the address to the object being constructed. If you’re interested, we have some example code on Educative Answers.

7. What is a friend class? Why is this useful?#

A class can declare other classes as a friend, and as a result, a friend class can then access the private and protected members of that class. This is important as it facilitates encapsulation of the non-relevant elements of a data structure to the user, but extends the storage and access to component parts.

Friend functions are primarily important in expanding the functionality of data structures like linked lists. A linked list class may be declared as a friend to access private members of a node.

8. Describe the four pillars of object-oriented programming#

The four pillars of OOP, as discussed earlier in this article, are: abstraction, encapsulation, inheritance, and polymorphism.

Here we’ll cover the very basics of each pillar, but we recommend looking over the above section dedicated to OOP if you need a more thorough explanation.

Abstraction: Some of an object’s properties and methods are hidden from outside observation.
Encapsulation: Related variables and functions are grouped into objects based on a larger blueprint called a class.
Inheritance: Some of the properties and methods of one object may be passed down to another object.
Polymorphism: Literally “many forms,” polymorphism refers to objects that respond in different ways to the same function.

9. What is overloading and overriding in C++?#

Function overloading or function overriding are examples of different kinds of polymorphism in C++ (see the question about compile-time and runtime polymorphism). Both serve as different ways to simplify the interface and make programs more intuitive to use and write. Function overloading and overriding are similar sounding terminologies, having vastly different characteristics. Therefore, this question is frequently being asked in coding interviews and is commonly answered incorrectly. Let’s understand it clearly with examples.

Overloading refers to the functions of the same scope (such as a class scope or the global scope) having the same name but different parameters. For example, in the code below we have two functions defined in global scope where both functions have the same name printMulti but different parameters.

Overriding When a superclass function is rewritten (with exactly the same name, parameters, and return type) in a subclass but having different implementation, we refer to the subclass function overriding the superclass function and this technique is referred to as function overriding. A same function may be overridden multiple times in different subclasses. In the example below we have the Shape superclass and its two subclasses Rectangle and Circle. A function calc_circumference is virtual in the superclass but have different implementations in the subclasses.

C++

#include <iostream>
class Shape {
public:
   virtual double calc_circumference() = 0;
};
class Rectangle : public Shape {
private:
   double width;
   double height;
public:
   Rectangle(double w, double h) {
       width = w;
       height = h;
   }
   //Overriding function of the base class
   virtual double calc_circumference() {
       return 2*width*height;
   }
};
class Circle : public Shape {
private:
   double radius;
  
public:
   Circle(double r) {
       radius = r;
   }
   //Overriding function of the base class
   virtual double calc_circumference() {
       return 2*3.14*radius;
   }
};
int main() {
   int width = 3, height = 4;
   double radius = 3;
  
   //Ah! This is polymorphism where Shape objects could be of either type: Rectangle and Circle.
   // The function being called depends on the object initiation.
   Shape *shape1 = new Rectangle(width, height);
   Shape *shape2 = new Circle(radius);
   std::cout << "Rectangle with width="<<width<<", height= "<< height << " has area="<<shape1->calc_circumference()<<  std::endl;  // calls the Rectangle's implementation
   std::cout << "Circle with radius="<<radius<< " has area="<<shape2->calc_circumference() << std::endl;  // calls the Circle's implementation
  
   //Do not forget to free the memory
   delete shape1;
   delete shape2;
   return 0;
}

10. What is the difference between compile time polymorphism and runtime polymorphism?#

In C++, polymorphism refers to the ability of objects of different classes to respond to the same method call in different ways. There are two main types of polymorphism in C++: compile-time polymorphism and runtime polymorphism.

Compile-time polymorphism, also known as static polymorphism, is implemented through function overloading and operator overloading. Function overloading allows multiple functions with the same name but different parameter lists to be defined in the same scope.

Runtime polymorphism, also known as dynamic polymorphism, is implemented through inheritance and virtual functions. Inheritance allows classes to inherit properties and behaviors from their base classes. Virtual functions allow derived classes to override the implementation of a base class method so that objects of the derived class can respond to the same method call in different ways. The actual implementation of a virtual function is determined at runtime based on the actual type of the object, not just the declared type.

Inheritance pitfalls and polymorphism gotchas#

Virtual destructor: base classes with virtual functions must have a virtual destructor to ensure proper cleanup via base pointers.
Object slicing: assigning a derived object to a base object value slices derived parts; prefer references/pointers for polymorphism.
override/final: use override to catch signature mismatches; use final to prevent further overrides.
Multiple inheritance: diamond shape requires virtual inheritance to avoid duplicate base subobjects; discuss trade-offs briefly.
Interfaces: prefer pure virtual classes to model behavior; avoid storing raw owning pointers in such types.

These points make for crisp follow-ups when the interviewer nudges beyond definitions.

11. What does the new operator do?#

The new operator is used for dynamic memory allocation. The operator denotes a request for allocating memory to the Heap. If the memory is available it is initialized and then the pointer to the newly allocated memory is returned. The code below creates an array dynamically based on the input size which could be taken at runtime from a user.

Memory, ownership, and the rule of 0/3/5#

A sizable portion of C++ coding interview questions dig into ownership.

Rule of 0/3/5:
- 0: if a type manages no resources, rely on compiler-generated special members.
- 3: if you define any of destructor, copy constructor, or copy assignment, you probably need all three.
- 5: with move semantics, add move constructor and move assignment too.
Prefer RAII: wrap resources (files, sockets, mutexes) in objects whose destructors release them.
Smart pointers:
- unique_ptr: sole ownership; movable, not copyable. Ideal default.
- shared_ptr: shared ownership via ref count; use sparingly due to overhead and potential cycles (break with weak_ptr).
- Don’t create shared ownership accidentally (shared_from_this requires enable_shared_from_this).

Copy vs move: design APIs to enable cheap moves: void set_name(std::string s) { name_ = std::move(s); } // pass-by-value + move

This lets callers pass lvalues or rvalues efficiently and keeps one assignment in the body.

You’ll often be asked to spot bugs like double deletes, leaks, or dangling references; ground your explanations in these ownership tools.

12. What is a variable’s scope? What does it mean for a variable to be local?#

The scope of a variable relates to the block of code the variable is contained within. Where, the block may refer to a function, program, loop, or any code placed between opening and closing curly braces. There are two main designations when it comes to the scope of a given variable:

Local: These variables are accessible only within the block of code that they are declared.
Global: These variables are declared outside of a program and therefore accessible throughout the program.

The following code playground demonstrates local scope to a function and an if-block. Moreover, it also shows a variable with the global scope.

C++

#include <iostream>
//g_x is a global variable
int g_x = 10;
int foo(int ilocal) {
   //ilocal and jlocal both are local variables to the foo function
   int jlocal = 5;
   if (ilocal < 5) {
       // the scope of flocal is this if-block
       int flocal = 10;
       ilocal = flocal;
   }
   std::cout << "We cannot access flocal outside the above if-block" << '\n';
   return jlocal+ilocal;
}
int main() {
   int llocal = foo(20);
   std::cout << "We cannot access ilocal and jlocal outside the foo function" << '\n';
   // But we can access the global variable g_x here
   std::cout << "Value of global variable is=" << g_x << '\n';
   //We can access llocal here as it scope is the current function
   std::cout << "Value of local variable to main() is=" << llocal;
   return 0;
}

13. If there is a global variable and a local variable with the same name, which one gets precedence?#

If both variables are present in the same function, the local variable takes precedence over a global variable. Outside of the function, the local variable goes out of scope and the global variable remains available to use.

STL containers, iterators, and algorithm complexity#

Interviewers love fast, precise STL talk tracks. Be ready to justify choices:

Vectors vs lists vs deques
- vector: contiguous, great cache locality; amortized O(1) push_back; O(1) random access; inserts/erases in middle are O(n).
- list/forward\_list: stable iterators; O(1) splice/insert/erase given iterator; terrible locality; no random access.
- deque: fast push/pop at both ends; still contiguous in chunks.
Associative vs unordered
- map/set: ordered, typically red-black trees; O(log n) find/insert/erase.
- unordered\_map/unordered\_set: hash-based average O(1) find/insert/erase; worst-case O(n).
Iterators: know categories (input, forward, bidirectional, random-access). Some algorithms require stronger categories (e.g., std::sort needs random-access).

Algorithms > loops: use std::accumulate, std::transform, std::partition, std::stable\_sort, std::lower\_bound and explain complexity. Example: finding first element ≥ x in a sorted vector: auto it = std::lower_bound(v.begin(), v.end(), x); // O(log n)

Whenever you answer data-structure picks in C++ coding interview questions, pair choice with Big-O and memory locality rationale.

14. What is recursion?#

Recursion is a technique in which a function calls itself, either directly or via other functions. A function that employs recursion is called a recursive function. Although every recursive function can always be converted into an iterative (non-recursive) function, recursion is usually preferred as it significantly shortens the length of code and makes it simple to understand.

In contrast, it is recommended not to use recursion on the embedded, resource-constrained devices as each recursive call needs additional call-stack memory. Thus, a recursive function is usually slower and more memory-consuming compared to its iterative counterpart.

Let’s admire the simplicity of a recursive function that returns the nth Fibonacci number:

16. What is the scope resolution operator and what does it do?#

The scope resolution operator looks like this: ::. In programming we use the word “scope” to refer to the code block in which certain functions and variables can be accessed. The scope resolution operator allows a member variable and a derived class type to have the same name. The :: operator resolves any ambiguity when the code reaches the compiler. According to the operator, whatever comes before it is a typename, namespace, or global namespace.

As opposed to the . operator which communicates whatever comes before it as an object.

17. What is a two-dimensional array? How are they declared?#

Basic arrays are one dimensional lists of data, but any data tables that we are familiar with require two dimensions. An Excel table is an example of a two dimensional array.

The syntax to declare a two dimensional array looks like this:

data_type array_name [dimension1] [dimension2]

data_type: the type of data to be stored in the array

array_name: what the array will be named/stored as

[dimensionN]: The sizes of each dimension of the array

By following the syntax, we can also create an array of higher than two dimensions.

18. Explain the difference between formal and actual parameters#

Formal parameters are the variables that receive values when the function is called. Actual parameters are the values that are passed to the function when it is called.

In the example below variables x and y are the formal parameters of function printSum whereas, 3 and 5 are the actual parameters that are passed to that function.

Templates, type deduction, and perfect forwarding#

Expect at least one generic-programming probe.

Function templates: template <class It, class T> It find_value(It first, It last, const T& value) { return std::find(first, last, value); }'

Forwarding references (T&& with template type T) and std::forward(arg) to preserve lvalue/rvalue category:

template <class T, class... Args> std::unique_ptr<T> make_unique_dispatch(Args&&... args) { return std::unique_ptr<T>(new T(std::forward<Args>(args)...)); }

Constrain templates (C++20 concepts) to improve error messages and intent:

template <std::sortable It> void sort_all(It first, It last) { std::sort(first, last); }

Link these ideas back to writing reusable solutions in C++ coding interview questions without sacrificing performance.

Get hands-on with C++ today

Grokking the Coding Interview Patterns in C++

With thousands of potential questions to account for, preparing for the coding interview can feel like an impossible challenge. Yet with a strategic approach, coding interview prep doesn’t have to take more than a few weeks. Stop drilling endless sets of practice problems, and prepare more efficiently by learning coding interview patterns. This course teaches you the underlying patterns behind common coding interview questions. By learning these essential patterns, you will be able to unpack and answer any problem the right way — just by assessing the problem statement. This approach was created by FAANG hiring managers to help you prepare for the typical rounds of interviews at major tech companies like Apple, Google, Meta, Microsoft, and Amazon. Before long, you will have the skills you need to unlock even the most challenging questions, grok the coding interview, and level up your career with confidence. This course is also available in JavaScript, Java, Python, C# and Go — with more coming soon!

85hrs

Intermediate

442 Challenges

443 Quizzes

Exceptions, noexcept, and UB you should avoid#

Exception safety: aim for basic (no leaks), strong (commit or roll back), or nothrow guarantees; explain how RAII helps.
noexcept: mark functions that won’t throw to enable optimizations (and to keep containers from calling fallback paths). Avoid throwing from destructors; if unavoidable, catch inside the destructor.
Undefined behavior hotspots:
- Dangling references/iterators (to temporaries or after vector reallocation).
- Signed integer overflow.
- Aliasing violations (casting pointers to unrelated types).
- Double-delete or mixed new/delete pairs (new[] with delete or vice versa).
- Data races (concurrent unsynchronized writes or write+read).

A crisp “what could go wrong here?” answer that names the specific UB earns quick points.

Next steps to nail any coding interview#

Hopefully you got some use out of these C++ questions and answers. It’s crucial that you test yourself when preparing for an interview. That said, spending a lot of time studying and attempting practice questions isn’t the most efficient way to prep. Almost every single technical interview asks questions that are built on larger coding interview patterns. Educative offers courses for learning 24 of the most common interview patterns in five top languages. Check out our series on Grokking Coding Interview Patterns and nail your next technical interview.

Happy learning! Good to go…

C++ coding interview questions for beginners

What is object-oriented programming (OOP)?#

How to prepare for a coding interview#

Modern C++ essentials interviewers expect#

Type deduction & auto#

Range-based for#

Initializer lists#

Lambdas#

string_view#

optional and variant#

20 C++ interview questions for freshers#

1. What are the main differences between C and C++?#