C++ Programming Language: Features, Advantages, and Differences from C

This comprehensive guide explores the C++ programming language, highlighting its key features, advantages (performance, versatility), and comparing it to C. Learn why C++ remains a powerful choice for various applications, from systems programming to game development.

Top C++ Interview Questions and Answers

What is C++?

Question 1: What is C++?

C++ is an object-oriented programming language developed by Bjarne Stroustrup. It's an extension of the C programming language, adding features like classes and objects. It's known for its performance and versatility.

Advantages of C++

Question 2: Advantages of C++

C++ offers several advantages:

• High Performance: Generally faster than many other high-level languages.
• Portability: Code can run on different platforms with minimal changes.
• Object-Oriented Programming (OOP): Supports OOP principles like encapsulation, inheritance, and polymorphism.
• Memory Management: Provides fine-grained control over memory allocation and deallocation.
• Large Standard Library: A rich set of functions for various tasks.

C vs. C++

Question 3: C vs. C++

Key differences between C and C++:

References vs. Pointers

Question 4: Reference vs. Pointer

Both references and pointers are used to work with memory addresses, but they differ in several ways:

Classes in C++

Question 5: What is a Class?

A class in C++ is a blueprint for creating objects. It defines the data (member variables) and the functions (member functions) that operate on that data. Access to members is controlled using access specifiers (public, private, protected).

Object-Oriented Programming (OOP) Concepts in C++

Question 6: OOP Concepts in C++

C++ supports key OOP concepts:

• Classes: Blueprints for objects.
• Objects: Instances of classes.
• Inheritance: Creating new classes based on existing ones.
• Encapsulation: Bundling data and methods within a class.
• Abstraction: Hiding implementation details and showing only essential information.
• Polymorphism: Objects of different classes responding to the same method call in their own specific way.

Polymorphism in C++

Question 7: Types of Polymorphism

C++ supports two main types of polymorphism:

• Compile-time polymorphism (Static Polymorphism): Achieved through function overloading (multiple functions with the same name but different parameter lists).
• Runtime polymorphism (Dynamic Polymorphism): Achieved through function overriding (a derived class provides a specific implementation for a virtual function defined in its base class). This means that the correct function to call is determined at runtime, not compile time.

#include <iostream>
using namespace std;

class Animal {
public:
  virtual void speak() {
    cout << "Generic animal sound" << endl;
  }
};

class Dog : public Animal {
public:
  void speak() override {
    cout << "Woof!" << endl;
  }
};

int main() {
  Animal* animal = new Dog();
  animal->speak(); // Calls Dog's speak() method - runtime polymorphism
  delete animal;
  return 0;
}

Woof!

#include <iostream>

void print(int x) { std::cout << x << std::endl; }
void print(double x) { std::cout << x << std::endl; }

int main() {
    print(5);      // Calls print(int)
    print(5.5);    // Calls print(double)
    return 0;
}

5
5.5

Function Overloading

Question 7: Method Overloading

Function overloading allows you to have multiple functions with the same name but different parameter lists (different types, number of parameters, or both). The compiler determines which function to call based on the arguments provided.

Example:

#include <iostream>

class Multiply {
public:
  int mul(int a, int b) { return a * b; }
  int mul(int a, int b, int c) { return a * b * c; }
};

int main() {
  Multiply m;
  std::cout << m.mul(2, 3) << std::endl; // Output: 6
  std::cout << m.mul(2, 3, 4) << std::endl; // Output: 24
  return 0;
}

Namespaces in C++

Question 8: Namespaces in C++

Namespaces help organize code and avoid naming conflicts. They define a scope for identifiers (variables, functions, classes). The standard C++ library is contained within the std namespace.

Example:

#include <iostream>

namespace MyNamespace {
  int add(int a, int b) { return a + b; }
}

int main() {
  std::cout << MyNamespace::add(5, 3) << std::endl; // Output: 8
  return 0;
}

Tokens in C++

Question 9: Tokens in C++

Tokens in C++ are the basic building blocks of the language. They include keywords, identifiers, literals, operators, and punctuators.

Creator of C++

Question 10: Creator of C++

Bjarne Stroustrup created C++.

Pointer Operations

Question 11: Pointer Operations

Operations on pointers include:

• Increment/Decrement: Moves the pointer to the next or previous element (by the size of the data type).
• Pointer Arithmetic: Performing arithmetic operations (addition, subtraction) on pointers.
• Pointer Subtraction: Subtracting two pointers (pointing to elements within the same array) yields the number of elements between them.
• Dereferencing: Accessing the value stored at the memory location pointed to by a pointer (using the * operator).

#include <iostream>

int main() {
  int arr[] = {10, 20, 30};
  int* ptr = arr; 
  std::cout << *ptr << std::endl; // Output: 10
  ptr++;
  std::cout << *ptr << std::endl; // Output: 20
  return 0;
}

`std` Namespace

Question 12: What is `std`?

std is the standard namespace in C++. It contains many predefined classes, functions, and constants from the standard library.

Origins of C++

Question 13: Origins of C++

C++ was developed to address limitations in the C programming language, particularly for creating larger and more complex programs.

`delete` vs. `delete[]`

Question 14: `delete` vs. `delete[]`

delete is used to deallocate memory allocated for a single object; delete[] is used to deallocate memory allocated for an array of objects.

Standard Template Library (STL)

Question 15: STL (Standard Template Library)

STL is a powerful library in C++ providing generic programming capabilities, including containers (like vectors, lists, maps), algorithms, and iterators.

Objects in C++

Question 16: Objects in C++

An object is an instance of a class. It's a concrete entity that occupies memory and has the characteristics defined by its class.

Access Specifiers

Question 17: Access Specifiers

Access specifiers (public, private, protected) control the accessibility of class members:

• public: Accessible from anywhere.
• private: Accessible only within the class.
• protected: Accessible within the class and its derived classes.

Object-Oriented Programming (OOP)

Question 18: Object-Oriented Programming (OOP)

OOP is a programming paradigm based on the concepts of classes and objects. Key principles include:

• Encapsulation: Bundling data and methods that operate on that data.
• Abstraction: Showing only essential information and hiding implementation details.
• Inheritance: Creating new classes (derived classes) based on existing classes (base classes).
• Polymorphism: The ability of objects of different classes to respond to the same method call in their own specific way.

Arrays vs. Lists

Question 19: Array vs. List

Key differences:

`new` vs. `malloc()`

Question 20: `new` vs. `malloc()`

Both allocate memory, but:

• new: Allocates memory and calls the constructor for objects. It's type-safe.
• malloc(): Allocates raw memory; you need to cast it to the correct type, and manage memory deallocation explicitly.

Exporting Functions from DLLs

Question 21: Exporting Functions from DLLs

Two common methods for exporting functions from a DLL are using the DLL's type library (for type-safe access) and obtaining a function pointer from the loaded DLL.

Friend Functions

Question 22: Friend Functions

A friend function of a class can access the private and protected members of that class, even though it's not a member of the class itself. Friendship is granted explicitly within the class definition.

Example:

#include <iostream>

class Addition {
private:
  int a = 5;
  int b = 6;
public:
  friend int add(Addition a1) {
    return a1.a + a1.b;
  }
};

int main() {
  Addition a1;
  std::cout << add(a1) << std::endl; // Output: 11
  return 0;
}

Virtual Functions

Question 23: Virtual Functions

Virtual functions allow for runtime polymorphism. When a base class pointer points to a derived class object, calling a virtual function executes the derived class's version of that function, not the base class's.

Rules for Virtual Functions:

• Must be a member of a class.
• Cannot be static.
• Called using a pointer or reference to the base class.
• Can be overridden in derived classes.
• Destructors can be virtual; constructors cannot.

Multiple Inheritance

Question 24: When to Use Multiple Inheritance

Multiple inheritance (inheriting from multiple base classes) should be used cautiously. It's generally recommended to avoid it unless absolutely necessary because it can lead to complexities, such as the "diamond problem". Favor composition or single inheritance with interfaces as alternatives.

Destructors

Question 25: Destructors

A destructor is a special member function of a class called automatically when an object of that class goes out of scope or is explicitly deleted using `delete`. It's used to release resources allocated by the object.

Rules for Destructors:

• Same name as the class, preceded by a tilde (~).
• No arguments or return type.

Overflow Errors

Question 26: Overflow Errors

An overflow error occurs when the result of an arithmetic operation exceeds the maximum value that can be stored in the data type used.

Overloading

Question 27: Overloading

Overloading in C++ means having multiple functions or operators with the same name but different signatures (parameter lists). The compiler selects the appropriate function or operator based on the arguments.

• Function Overloading: Multiple functions with the same name but different parameter lists.
• Operator Overloading: Redefining the behavior of operators for user-defined types.

#include <iostream>

class MyNumber {
private:
  int value;
public:
  MyNumber(int val) : value(val) {}
  MyNumber operator+(const MyNumber& other) const {
    return MyNumber(this->value + other.value);
  }
  void print() const { std::cout << value << std::endl; }
};

int main() {
  MyNumber num1(10);
  MyNumber num2(5);
  MyNumber sum = num1 + num2;
  sum.print(); // Output: 15
  return 0;
}

Function Overriding

Question 28: Function Overriding

Function overriding occurs in inheritance when a derived class provides its own implementation for a virtual function defined in its base class.

Virtual Inheritance

Question 29: Virtual Inheritance

Virtual inheritance in C++ prevents multiple copies of base class members from being created when using multiple inheritance. This avoids the "diamond problem".

Constructors

Question 30: Constructors

A constructor is a special member function of a class that initializes objects of that class. It has the same name as the class and is automatically called when an object is created.

`delete` Operator

Question 31: `delete` Operator

The delete operator deallocates memory that was previously dynamically allocated using the new operator.

`this` Pointer

Question 32: `this` Pointer

The this pointer is a hidden pointer within a class's member function that points to the current object instance.

Scope Resolution Operator

Question 33: Scope Resolution Operator

The scope resolution operator (::) is used to access members of a class or namespace from outside their scope.

`delete` vs. `delete[]` (Again)

Question 34: `delete` vs. `delete[]`

Use delete to deallocate memory for a single object and `delete[]` to deallocate memory for an array of objects.

Pure Virtual Functions

Question 35: Pure Virtual Functions

A pure virtual function is a virtual function that has no implementation (its declaration ends with = 0). A class with at least one pure virtual function is an abstract class and cannot be instantiated directly; it must be inherited from to create concrete classes.

#include <iostream>

class Shape {
public:
  virtual double getArea() = 0; // Pure virtual function
};

class Circle : public Shape {
private:
  double radius;
public:
  Circle(double r) : radius(r) {}
  double getArea() override { return 3.14159 * radius * radius; }
};

int main() {
  Circle c(5);
  std::cout << c.getArea() << std::endl; // Output: 78.53975
  return 0;
}

`struct` vs. `class`

Question 36: `struct` vs. `class`

The primary difference is the default access specifier: members of a struct are public by default; members of a class are private by default.

Class Templates

Question 37: Class Templates

Class templates allow you to create a generic class that can work with different data types without writing separate code for each type.

Function Overloading vs. Operator Overloading

Question 38: Function Overloading vs. Operator Overloading

Function overloading is having multiple functions with the same name but different parameters. Operator overloading is redefining the behavior of operators for user-defined types.

Virtual Destructors

Question 39: Virtual Destructors

A virtual destructor is essential when dealing with inheritance and dynamic memory allocation. It ensures that the correct destructor is called when deleting a base class pointer that points to a derived class object, preventing memory leaks.

Example (Without Virtual Destructor):

#include <iostream>

class Base {
public:
  Base() { std::cout << "Base constructor called\n"; }
  ~Base() { std::cout << "Base destructor called\n"; }
};

class Derived : public Base {
public:
  Derived() { std::cout << "Derived constructor called\n"; }
  ~Derived() { std::cout << "Derived destructor called\n"; }
};

int main() {
  Base* ptr = new Derived;
  delete ptr; 
  return 0;
}

Base constructor called
Derived constructor called
Base destructor called 

Note: Only the base class destructor is called, leading to a memory leak.

Example (With Virtual Destructor):

#include <iostream>

class Base {
public:
  Base() { std::cout << "Base constructor called\n"; }
  virtual ~Base() { std::cout << "Base destructor called\n"; }
};

class Derived : public Base {
public:
  Derived() { std::cout << "Derived constructor called\n"; }
  ~Derived() { std::cout << "Derived destructor called\n"; }
};

int main() {
  Base* ptr = new Derived;
  delete ptr;
  return 0;
}

Base constructor called
Derived constructor called
Derived destructor called
Base destructor called

Note: Both the derived and base class destructors are called, preventing memory leaks.

`struct` vs. `class` (Continued)

Question 36: `struct` vs. `class` (Continued)

In C++, `struct` and `class` are nearly identical; the only difference is the default access specifier: `public` for `struct` and `private` for `class`.

Class Templates

Question 37: Class Templates

Class templates provide a way to write generic code that can work with different data types without needing to write separate code for each type. This is achieved by using template parameters.

Function Overloading vs. Operator Overloading (Continued)

Question 38: Function Overloading vs. Operator Overloading (Continued)

Both involve having multiple functions or operators with the same name. Function overloading differentiates functions based on their parameter lists, while operator overloading redefines the behavior of operators for user-defined types.