C++ Language Core

// Compiler picks which add() to call by argument types
class Calculator {
public:
    int    add(int a, int b)            { return a + b; }
    double add(double a, double b)     { return a + b; }
    int    add(int a, int b, int c)   { return a + b + c; }
};

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

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

// Decided at RUNTIME — which speak()?
Animal* a = new Dog();
a->speak();    // Output: "Bark!" — Dog::speak() called
delete a;

class MyString {
    char* data;
    int len;

public:
    MyString(const char* s) {
        len = strlen(s);
        data = new char[len + 1];
        strcpy(data, s);
    }

    // DEFAULT = SHALLOW COPY (compiler-generated)
    // Just copies the pointer → both point to same memory
    // → double-free crash when both destructors run!

    // DEEP COPY — allocate + copy
    MyString(const MyString& other) {
        len = other.len;
        data = new char[len + 1];     // new memory!
        strcpy(data, other.data);      // copy content
    }

    ~MyString() { delete[] data; }
};

class Buffer {
    int* data;
    size_t size;

public:
    Buffer(size_t n) : size(n), data(new int[n]) {}

    // ─── COPY CONSTRUCTOR (expensive) ───
    Buffer(const Buffer& other) : size(other.size) {
        data = new int[size];               // allocate
        memcpy(data, other.data, size * sizeof(int));  // copy
    }

    // ─── MOVE CONSTRUCTOR (cheap) ───
    Buffer(Buffer&& other) noexcept
        : data(other.data), size(other.size) {
        other.data = nullptr;              // steal + nullify
        other.size = 0;
    }

    ~Buffer() { delete[] data; }
};

Buffer a(1000000);
Buffer b = a;                // COPY — allocates + copies 1M ints
Buffer c = std::move(a);    // MOVE — just steals pointer. O(1)

#include <memory>

// ─── unique_ptr: SOLE owner, zero overhead ───
{
    auto ptr = std::make_unique<int>(42);
    // Can't copy: auto ptr2 = ptr;  ← ERROR
    auto ptr2 = std::move(ptr);     // transfer ownership
}   // auto-deleted here

// ─── shared_ptr: SHARED ownership, ref counted ───
{
    auto sp1 = std::make_shared<int>(100);   // refcount = 1
    {
        auto sp2 = sp1;                       // refcount = 2
    }                                          // refcount = 1
}   // refcount = 0 → deleted

// ─── weak_ptr: observer, breaks circular references ───
auto shared = std::make_shared<int>(99);
std::weak_ptr<int> weak = shared;    // doesn't increase refcount

if (auto locked = weak.lock()) {
    // safe to use — object still alive
}

// ─── MEMORY LEAK: forgot to delete ───
void leaky() {
    int* p = new int[1000];
    // ... use p ...
    return;         // LEAK! p is lost, memory never freed
}

// ─── FIX: use smart pointer ───
void safe() {
    auto p = std::make_unique<int[]>(1000);
    // auto-freed when scope exits, even on exception
}

// ─── NULL dereference ───
int* p = nullptr;
*p = 42;           // SEGFAULT!

// ─── Dangling pointer ───
int* q = new int(10);
delete q;
*q = 20;           // SEGFAULT! memory already freed

// ─── Stack overflow ───
void infinite() {
    infinite();      // never-ending recursion → stack overflow
}

// ─── malloc: raw bytes, no constructor ───
int* arr = (int*)malloc(5 * sizeof(int));  // just raw memory
if (arr == NULL) { /* handle error */ }
free(arr);

// ─── new: allocate + construct ───
int* arr2 = new int[5];               // allocated + initialized
delete[] arr2;                         // delete[] for arrays!

// ─── For objects — new CALLS constructor ───
MyClass* obj1 = (MyClass*)malloc(sizeof(MyClass));
// obj1 is GARBAGE — constructor never ran!
free(obj1);

MyClass* obj2 = new MyClass();          // constructor runs ✓
delete obj2;                           // destructor runs ✓

// ─── BEST: use smart pointers ───
auto obj3 = std::make_unique<MyClass>();  // auto-managed ✓✓