C++ Cheat Sheet Table: Syntax, Pointers, STL, and More

C++ is a high-level, general-purpose programming language that supports object-oriented, procedural, and generic programming paradigms. It is widely used for system programming, game development, and competitive coding.

– Object-Oriented Programming (OOP)
– Strongly Typed Language
– Standard Template Library (STL)
– Memory Management with Pointers
– Exception Handling
– Multi-threading Support

C is a procedural programming language, while C++ supports both procedural and object-oriented programming. C++ also has additional features like classes, inheritance, polymorphism, and STL.

A class is a user-defined blueprint for creating objects. It encapsulates data members (variables) and methods (functions) within a single unit.
Example:
class Car {
public:
string brand;
int year;
};

An object is an instance of a class. It holds actual values for the class properties.
Example:
Car myCar;
myCar.brand = "Toyota";
myCar.year = 2020;

Inheritance allows one class (child class) to derive properties and behaviors from another class (parent class).
Example:
class Vehicle {
public:
int speed;
};
class Car : public Vehicle {
public:
string brand;
};

Polymorphism allows the same function to have different behaviors. It can be achieved using function overloading and function overriding.
Example:
class Animal {
public:
virtual void sound() {
cout << "Animal makes a sound";
}
};
class Dog : public Animal {
public:
void sound() override {
cout << "Dog barks";
}
};

Encapsulation is the bundling of data and functions into a single unit (class) and restricting direct access to data using access specifiers (private, public, protected).

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

A constructor is a special function that initializes objects of a class. It has the same name as the class and does not return a value.
Example:
class Car {
public:
Car() { cout << "Car is created"; }
};

A destructor is a special function that is automatically called when an object goes out of scope. It is used to free resources.
Example:
class Car {
public:
~Car() { cout << "Car is destroyed"; }
};

A pointer is a variable that stores the memory address of another variable.
Example:
int x = 10;
int* ptr = &x;

A reference is an alias for an existing variable.
Example:
int x = 10;
int& ref = x;

Function overloading allows multiple functions with the same name but different parameters.
Example:
int add(int a, int b) { return a + b; }
double add(double a, double b) { return a + b; }

Operator overloading allows defining custom behaviors for operators.
Example:
class Complex {
public:
int real, imag;
Complex operator + (const Complex& obj) {
Complex res;
res.real = real + obj.real;
res.imag = imag + obj.imag;
return res;
}
};

STL is a collection of reusable data structures and algorithms in C++. It includes:
– Containers (vector, list, map, set)
– Algorithms (sort, search)
– Iterators
Example:

new is a C++ operator, while malloc() is a C function.
new calls the constructor, malloc() does not.
new returns a typed pointer, malloc() returns void*.

Exception handling allows handling runtime errors using try, catch, and throw.
Example:
try {
throw "An error occurred";
} catch (const char* msg) {
cout << msg;
}

A virtual function allows function overriding in derived classes, ensuring dynamic (runtime) polymorphism.
Example:

class Base {
public:
virtual void show() { cout << "Base class"; }
};
class Derived : public Base {
public:
void show() override { cout << "Derived class"; }
};

A smart pointer (std::unique_ptr, std::shared_ptr) manages dynamic memory automatically.
Example: