C++ doesn’t have garbage collection. Use smart pointers to manage memory automatically.

Copy Codestd::unique_ptr<int> ptr = std::make_unique<int>(10);  // Automatically managed memory
// No need to call delete, memory is freed when ptr goes out of scope

Use header files for declarations and source files for definitions. Use include guards to prevent multiple inclusions.

Copy Code#ifndef MY_HEADER_H
#define MY_HEADER_H
// Declarations go here
#endif

C++ is strongly typed. Use explicit casting for type conversions.

Copy Codedouble x = 5.5;
int y = static_cast<int>(x);  // Explicit cast to int

Use `virtual` for methods you want to override in derived classes. Use `override` to make intentions clear.

Copy Codeclass Base {
public:
    virtual void foo() { /*...*/ }
};

class Derived : public Base {
public:
    void foo() override { /*...*/ }
};

Use STL containers and algorithms for common tasks.

Copy Codestd::vector<int> vec = {1, 2, 3};
std::sort(vec.begin(), vec.end());  // Sorts the vector

Use `std::move` to transfer ownership of resources.

Copy Codestd::string str1 = "Hello";
std::string str2 = std::move(str1);  // str1 is now in a valid but unspecified state

Use templates for generic functions and classes.

Copy Codetemplate <typename T>
T add(T a, T b) {
    return a + b;
}

int result = add(3, 4);  // result is 7

Copy Code// 📜 Basic syntax
int main() {
    int x = 10;          // Variable declaration
    std::cout << x;      // Output: 10
    return 0;            // Return statement
}

Copy Code// 🏷️ Primitive types
int integer = 42;                // Integer
double floating = 3.14;          // Double-precision floating point
char character = 'A';            // Single character
bool boolean = true;             // Boolean (true/false)

Copy Code// 📦 Variable declarations
int x = 10;                      // Mutable variable
const int y = 20;                // Immutable constant
constexpr int z = 30;            // Compile-time constant

Copy Code// ➕ Arithmetic operators
int sum = x + y;                 // Addition
int diff = x - y;                // Subtraction

// 🔀 Logical operators
bool result = (x > 5) && (y < 30); // Logical AND

// 🔄 Ternary operator
int max = (x > y) ? x : y;       // Conditional assignment

Copy Code// 🏗️ Stack allocation
int stackVar = 10;               // Allocated on the stack

// 🏗️ Heap allocation
int* heapVar = new int(20);      // Allocated on the heap
delete heapVar;                  // Manual deallocation required

Copy Code// 🧠 Smart pointers
std::unique_ptr<int> uPtr = std::make_unique<int>(10); // Unique ownership
std::shared_ptr<int> sPtr = std::make_shared<int>(20); // Shared ownership
std::weak_ptr<int> wPtr = sPtr;                        // Weak reference

Copy Code// 🛡️ RAII (Resource Acquisition Is Initialization)
class Resource {
public:
    Resource() { /* Acquire resource */ }
    ~Resource() { /* Release resource */ }
};

Copy Code// ⚠️ Memory leaks
int* leak = new int(10);        // Never deleted

// ⚠️ Dangling pointers
int* ptr = new int(10);
delete ptr;
*ptr = 20;                      // Undefined behavior

Copy Code// 🏛️ Class (default access: private)
class MyClass {
    int privateVar;             // Private by default
public:
    int publicVar;              // Explicitly public
};

// 🏛️ Struct (default access: public)
struct MyStruct {
    int publicVar;              // Public by default
private:
    int privateVar;             // Explicitly private
};

Use classes for encapsulation and structs for data grouping.

Copy Code// 🏗️ Default/Parameterized/Copy/Move Constructors
class Example {
public:
    Example() {}                              // Default
    Example(int x) : val(x) {}                // Parameterized
    Example(const Example& other) {           // Copy
        val = other.val;
    }
    Example(Example&& other) noexcept {       // Move
        val = std::exchange(other.val, 0);
    }
private:
    int val;
};

Constructors initialize objects. Use initializer lists for efficiency.

Copy Code// 🧹 Destructor (RAII cleanup)
class FileHandler {
public:
    ~FileHandler() {
        if (file) fclose(file);   // Release resource
    }
private:
    FILE* file;
};

Destructors automatically release resources when objects go out of scope.

Copy Code// 🧬 Single inheritance
class Derived : public Base { /*...*/ };

// 🧬 Multiple inheritance
class Derived : public Base1, public Base2 { /*...*/ };

// 🧬 Virtual inheritance (prevents diamond problem)
class Derived : virtual public Base { /*...*/ };

Use public inheritance for "is-a" relationships. Avoid multiple inheritance unless necessary.

Copy Code// 🎯 Virtual functions and overriding
class Shape {
public:
    virtual double area() const = 0;  // Pure virtual (abstract class)
};

class Circle : public Shape {
public:
    double area() const override {    // Must implement
        return 3.14 * radius * radius;
    }
};

Mark base class methods as virtual. Use override to ensure correct polymorphism.

Copy Code// 🔒 Private members with public getters/setters
class BankAccount {
public:
    double getBalance() const { return balance; }
    void deposit(double amount) { balance += amount; }
private:
    double balance = 0;   // Hidden internal state
};

Expose minimal interfaces. Keep data private to enforce invariants.

Copy Code// 🛑 Manage resources explicitly
class ResourceHolder {
public:
    ResourceHolder() { ptr = new int[100]; }  // Constructor
    ~ResourceHolder() { delete[] ptr; }       // Destructor
    ResourceHolder(const ResourceHolder& other) {  // Copy constructor
        ptr = new int[100];
        std::copy(other.ptr, other.ptr + 100, ptr);
    }
    ResourceHolder& operator=(const ResourceHolder& other) { // Copy assignment
        if (this != &other) {
            delete[] ptr;
            ptr = new int[100];
            std::copy(other.ptr, other.ptr + 100, ptr);
        }
        return *this;
    }
    ResourceHolder(ResourceHolder&& other) noexcept { // Move constructor
        ptr = other.ptr;
        other.ptr = nullptr;
    }
    ResourceHolder& operator=(ResourceHolder&& other) noexcept { // Move assignment
        delete[] ptr;
        ptr = other.ptr;
        other.ptr = nullptr;
        return *this;
    }
private:
    int* ptr;
};

If you define a destructor, copy/move operations, you likely need all five.

Copy Code// 🤝 Granting access to private members
class SecretKeeper {
    friend class TrustedFriend;   // Friend class
    friend void peekSecret(const SecretKeeper&); // Friend function
private:
    int secret = 42;
};

class TrustedFriend {
public:
    static int getSecret(const SecretKeeper& sk) { return sk.secret; }
};

Use friend sparingly to break encapsulation only when necessary.

Copy Code// 🔄 Shared class-level data
class Counter {
public:
    static int count;            // Declaration
    Counter() { count++; }
    ~Counter() { count--; }
};
int Counter::count = 0;          // Definition (required)

Static members belong to the class, not individual objects.

Copy Code// ➕ Custom operator behavior
class Vector {
public:
    Vector operator+(const Vector& other) const {
        return Vector(x + other.x, y + other.y);
    }
private:
    double x, y;
};

Overload operators to enable natural syntax for custom types.

Copy Code// 📦 STL containers
std::vector<int> vec = {1, 2, 3};       // Dynamic array
std::map<std::string, int> map = {{"a", 1}, {"b", 2}}; // Key-value pairs

Copy Code// 🔧 STL algorithms
std::sort(vec.begin(), vec.end());      // Sort a vector
auto it = std::find(vec.begin(), vec.end(), 2); // Find an element

Copy Code// 🔄 Iterators
for (auto it = vec.begin(); it != vec.end(); ++it) {
    std::cout << *it;                   // Access element
}

Copy Code// 🤖 Auto keyword
auto x = 10;                            // x is int
auto y = 3.14;                          // y is double

Copy Code// 🚚 Move semantics
std::string str1 = "Hello";
std::string str2 = std::move(str1);     // str1 is now empty

Copy Code// 🐑 Lambda functions
auto lambda = [](int x) { return x * x; };
int result = lambda(5);                 // result is 25

Copy Code// 🧩 Function template
template <typename T>
T add(T a, T b) {
    return a + b;
}

Copy Code// 🏛️ Class template
template <typename T>
class Box {
public:
    T value;
};

Copy Code// 🚨 Exception handling
try {
    throw std::runtime_error("Error!");
} catch (const std::exception& e) {
    std::cerr << e.what();
}

Copy Code// 🔒 Const correctness
const int x = 10;
int y = x;                              // Allowed
x = 20;                                 // Error: x is const