C++ interview questions and answers

In C++, both structs and classes are used to define user-defined types with data members and member functions. The main difference between the two is the default access level of their members and the default inheritance type.

In a struct, by default, all members are public, and in a class, by default, all members are private. This means that if you define a struct like this:

struct MyStruct {
  int x;
  void printX() {
    std::cout << x << std::endl;
  }
};

Then x and printX() can be accessed from outside the struct without any restrictions:

MyStruct s;
s.x = 10;
s.printX();  // prints 10

If you define a class like this:

class MyClass {
  int x;
  void printX() {
    std::cout << x << std::endl;
  }
};

Then x and printX() are both private, and cannot be accessed from outside the class:

MyClass c;
c.x = 10;    // compile error: 'x' is private
c.printX();  // compile error: 'printX' is private

To access private members of a class, you need to define public member functions or use friend functions.

Another difference is that in a class, the default inheritance type is private, whereas in a struct, it is public. This means that if you derive a class from a struct, the derived class will be a public inheritance, and if you derive a class from a class, the derived class will be a private inheritance. However, it is usually a good practice to explicitly specify the inheritance type in the code.

Sure, here's an example program in C++ that calculates the factorial of a given number using a recursive function:

#include <iostream>
using namespace std;

// Recursive function to calculate the factorial of a given number
int factorial(int n) {
    if (n == 0) {
        return 1;
    } else {
        return n * factorial(n - 1);
    }
}

int main() {
    int n;
    cout << "Enter a number to calculate its factorial: ";
    cin >> n;

    // Call the factorial function and display the result
    int result = factorial(n);
    cout << n << "! = " << result << endl;

    return 0;
}

To use this program, simply compile and run it in a C++ compiler. When prompted, enter the number you want to calculate the factorial of, and the program will output the result.

In C++, a pointer is a variable that holds the memory address of another variable. Pointers are used to manipulate and work with memory locations directly, which can be useful in certain programming scenarios.

Here is an example of how to declare a pointer in C++:

int x = 10;     // Declare and initialize an integer variable 'x'
int* ptr = &x;  // Declare a pointer to an integer variable 'ptr' and initialize it with the address of 'x'

In the example above, the & operator is used to get the memory address of the variable x, which is then assigned to the pointer variable ptr.

Once a pointer is declared, you can use the * operator to access the value at the memory location it points to, or to assign a new value to that memory location. Here is an example:

std::cout << *ptr << std::endl;  // Output: 10

*ptr = 20;  // Assign the value 20 to the memory location pointed to by 'ptr'

std::cout << *ptr << std::endl;  // Output: 20
std::cout << x << std::endl;     // Output: 20 (the value of 'x' has been changed)

In the example above, the * operator is used to access the value stored in the memory location pointed to by ptr. Then, the value of x is changed by assigning a new value to the memory location pointed to by ptr using the * operator.

Pointers can also be used to dynamically allocate memory in C++ using the new operator. For example:

int* arr = new int[10];  // Dynamically allocate an array of 10 integers and assign the pointer to 'arr'

arr[0] = 1;  // Assign the value 1 to the first element of the array
std::cout << arr[0] << std::endl;  // Output: 1

delete[] arr;  // Free the dynamically allocated memory

In the example above, the new operator is used to allocate an array of 10 integers on the heap, and the pointer to the first element of the array is assigned to arr. Then, the first element of the array is assigned a value of 1 using array indexing. Finally, the delete[] operator is used to free the dynamically allocated memory.

In C++, conditional statements such as if-else statements and switch statements are used to control the flow of the program based on certain conditions. Here's how you can implement them:

If-else statements

An if-else statement is used to execute a block of code if a certain condition is true, and a different block of code if the condition is false. Here's an example:

int x = 10;

if (x > 5) {
  std::cout << "x is greater than 5" << std::endl;
} else {
  std::cout << "x is less than or equal to 5" << std::endl;
}

In the example above, the code inside the curly braces after the if keyword will be executed if the condition x > 5 is true. If the condition is false, the code inside the curly braces after the else keyword will be executed.

Switch statements

A switch statement is used to execute a block of code based on the value of a variable. Here's an example:

int x = 2;

switch (x) {
  case 1:
    std::cout << "x is 1" << std::endl;
    break;
  case 2:
    std::cout << "x is 2" << std::endl;
    break;
  case 3:
    std::cout << "x is 3" << std::endl;
    break;
  default:
    std::cout << "x is not 1, 2, or 3" << std::endl;
    break;
}

In the example above, the value of x is evaluated against each case statement. If x matches the value in a case statement, the code inside the corresponding block will be executed. If x does not match any of the case statements, the code inside the default block will be executed.

Note that the break keyword is used after each block of code inside a case statement to exit the switch block and prevent the execution of subsequent blocks.

In C++, loops are used to repeat a block of code multiple times until a certain condition is met. There are three types of loops in C++: for loops, while loops, and do-while loops.

For loops

A for loop is used to repeat a block of code a specific number of times. Here's an example:

for (int i = 0; i < 10; i++) {
  std::cout << i << std::endl;
}

In the example above, the loop will execute 10 times, with the value of i starting at 0 and incrementing by 1 each time through the loop. The condition i < 10 is checked at the beginning of each iteration, and the loop will terminate when the condition is false.

While loops

A while loop is used to repeat a block of code as long as a certain condition is true. Here's an example:

int i = 0;

while (i < 10) {
  std::cout << i << std::endl;
  i++;
}

In the example above, the loop will execute as long as i is less than 10. The value of i is incremented inside the loop to prevent an infinite loop.

Do-while loops

A do-while loop is similar to a while loop, but the block of code is executed at least once, even if the condition is false. Here's an example:

int i = 0;

do {
  std::cout << i << std::endl;
  i++;
} while (i < 10);

In the example above, the loop will execute at least once, even if i is not less than 10. The value of i is incremented inside the loop to prevent an infinite loop.

In all types of loops, the break keyword can be used to exit the loop prematurely, and the continue keyword can be used to skip the current iteration of the loop and move on to the next iteration.

In C++, arrays and vectors are used to store a collection of values of the same type. Here's how you can implement them:

Arrays

An array is a collection of elements of the same data type, stored in contiguous memory locations. Here's an example of how to declare and initialize an array:

int myArray[5] = {1, 2, 3, 4, 5};

In the example above, an array myArray is declared with a size of 5, and is initialized with the values 1 through 5. You can access individual elements of the array using the index notation, like this:

int x = myArray[2]; // x will be 3

Arrays are often used when you need to store a fixed number of elements of the same type, such as a list of grades for a class of students or a list of temperatures for a given day.

Vectors

A vector is a dynamic array that can grow or shrink in size at runtime. Here's an example of how to declare and initialize a vector:

std::vector<int> myVector = {1, 2, 3, 4, 5};

In the example above, a vector myVector is declared and initialized with the same values as the previous example. You can access individual elements of the vector using the index notation, like this:

int x = myVector[2]; // x will be 3

Vectors are often used when you need to store a variable number of elements of the same type, such as a list of user IDs or a list of items in a shopping cart. Vectors are also useful when you need to add or remove elements from the collection, since they can automatically adjust their size. To add an element to a vector, you can use the push_back method:

myVector.push_back(6); // adds the value 6 to the end of the vector

To remove an element from a vector, you can use the pop_back method:

myVector.pop_back(); // removes the last element from the vector

Here's an example of a C++ console app that allows users to create and manage a to-do list:

#include <iostream>
#include <vector>
#include <string>

using namespace std;

struct Todo {
    string task;
    string dueDate;
    bool completed;
};

vector<Todo> todos;

void addTodo() {
    Todo newTodo;
    cout << "Enter task name: ";
    cin >> newTodo.task;
    cout << "Enter due date (MM/DD/YYYY): ";
    cin >> newTodo.dueDate;
    newTodo.completed = false;
    todos.push_back(newTodo);
    cout << "Task added successfully!" << endl;
}

void displayTodos() {
    if (todos.size() == 0) {
        cout << "No tasks found." << endl;
        return;
    }
    cout << "Todo List:" << endl;
    for (int i = 0; i < todos.size(); i++) {
        Todo currentTodo = todos[i];
        cout << i+1 << ". ";
        if (currentTodo.completed) {
            cout << "[X] ";
        } else {
            cout << "[ ] ";
        }
        cout << currentTodo.task << " - Due on " << currentTodo.dueDate << endl;
    }
}

void markTodoCompleted() {
    int index;
    cout << "Enter index of task to mark as completed: ";
    cin >> index;
    if (index < 1 || index > todos.size()) {
        cout << "Invalid index." << endl;
        return;
    }
    Todo& todoToMark = todos[index-1];
    todoToMark.completed = true;
    cout << "Task marked as completed!" << endl;
}

int main() {
    cout << "Welcome to your to-do list!" << endl;
    while (true) {
        cout << endl;
        cout << "Select an option:" << endl;
        cout << "1. Add task" << endl;
        cout << "2. Display tasks" << endl;
        cout << "3. Mark task as completed" << endl;
        cout << "4. Exit" << endl;
        int choice;
        cin >> choice;
        switch (choice) {
            case 1:
                addTodo();
                break;
            case 2:
                displayTodos();
                break;
            case 3:
                markTodoCompleted();
                break;
            case 4:
                cout << "Exiting..." << endl;
                return 0;
            default:
                cout << "Invalid choice." << endl;
                break;
        }
    }
}

This program allows users to add tasks to their to-do list, display all tasks, and mark tasks as completed. The to-do list is stored in a vector of Todo structs, which contain the task name, due date, and completion status. The program uses a simple menu system to allow the user to choose between different options.

In C++, object-oriented programming (OOP) concepts such as inheritance and polymorphism can be implemented using classes and derived classes. Here's how:

Inheritance

Inheritance allows you to create a new class based on an existing class, inheriting its properties and behaviors. The existing class is called the base class, and the new class is called the derived class. Here's an example of how to create a derived class:

class Animal {
  public:
    void eat() {
      std::cout << "The animal is eating." << std::endl;
    }
};

class Dog : public Animal {
  public:
    void bark() {
      std::cout << "The dog is barking." << std::endl;
    }
};

In the example above, the Dog class is derived from the Animal class using the public access specifier. This means that the public members of the Animal class are accessible from the Dog class. The Dog class also has its own method bark.

Polymorphism

Polymorphism allows you to use a derived class object as if it were an object of its base class. This allows you to write generic code that can be used with different derived classes. Polymorphism can be achieved using virtual functions. Here's an example:

class Animal {
  public:
    virtual void makeSound() {
      std::cout << "The animal makes a sound." << std::endl;
    }
};

class Dog : public Animal {
  public:
    void makeSound() {
      std::cout << "The dog barks." << std::endl;
    }
};

void animalSound(Animal *animal) {
  animal->makeSound();
}

int main() {
  Animal *animal = new Animal();
  Dog *dog = new Dog();
  
  animalSound(animal); // The animal makes a sound.
  animalSound(dog); // The dog barks.
  
  delete animal;
  delete dog;
  
  return 0;
}

In the example above, the Animal class has a virtual method makeSound. This allows derived classes to override the method with their own implementation. The Dog class overrides the method with its own implementation. The animalSound function takes a pointer to an Animal object as an argument, and calls its makeSound method. This allows it to be used with any derived class of Animal.

In C++, templates are used to create generic classes and functions that can work with different data types. Templates allow you to write code once and use it with different types, rather than having to write separate code for each type. Here's an example of how to create a template class:

template <class T>
class MyArray {
  private:
    T *array;
    int size;
  
  public:
    MyArray(int n) {
      size = n;
      array = new T[size];
    }
    
    T& operator[](int index) {
      return array[index];
    }
    
    ~MyArray() {
      delete[] array;
    }
};

In the example above, the MyArray class is a template class that takes a type parameter T. The class has a private data member array which is a pointer to an array of type T. The constructor creates an array of size n with type T. The operator[] function overloads the subscript operator to allow you to access elements of the array using the [] operator. The destructor deallocates the memory used by the array.

Here's an example of how to use the MyArray template class:

MyArray<int> intArray(10);
MyArray<double> doubleArray(5);

intArray[0] = 1;
intArray[1] = 2;
doubleArray[0] = 1.1;
doubleArray[1] = 2.2;

In the example above, two instances of the MyArray class are created: intArray with type int and size 10, and doubleArray with type double and size 5. Elements of the arrays can be accessed using the subscript operator [].

Templates can also be used to create generic functions that can work with different types. Here's an example of how to create a template function:

template <class T>
T max(T x, T y) {
  return (x > y) ? x : y;
}

In the example above, the max function is a template function that takes two arguments of type T and returns the maximum value. The function can be called with different types:

int a = 5, b = 10;
double c = 2.5, d = 7.3;

std::cout << max(a, b) << std::endl; // Output: 10
std::cout << max(c, d) << std::endl; // Output: 7.3

In C++, input/output operations can be performed using the iostream library for console input/output and the fstream library for file input/output. Here's an example of how to read and write to a file using the fstream library:

#include <iostream>
#include <fstream>

int main() {
  std::ofstream outfile("example.txt"); // create output file stream
  outfile << "Hello, world!" << std::endl; // write to file
  outfile.close(); // close output file stream
  
  std::ifstream infile("example.txt"); // create input file stream
  std::string line;
  while (std::getline(infile, line)) { // read from file line by line
    std::cout << line << std::endl; // print each line to console
  }
  infile.close(); // close input file stream
  
  return 0;
}

In the example above, the ofstream class is used to create an output file stream to write data to the file "example.txt". The << operator is used to write the string "Hello, world!" to the file, followed by a newline character. The close method is then called to close the output file stream.

The ifstream class is then used to create an input file stream to read data from the file "example.txt". The getline method is used to read data from the file line by line into the line string variable. Each line is then printed to the console using the cout statement. Finally, the close method is called to close the input file stream.

This is a simple example of reading and writing to a file in C++. There are many more operations and features available in the iostream and fstream libraries, such as reading and writing binary data, seeking to specific positions in the file, and more.