Pointers

Memory leaks and dangling pointers

• **Leak:** allocate with new and never delete — memory stays reserved until the program ends.
• **Dangling:** pointer still holds an address after delete — using it is undefined behaviour.
• **Double delete:** deleting the same block twice is also undefined behaviour.
• Fix dangling: delete p; p = nullptr; and never use after free.

int* p = new int(5);
delete p;      // OK
// *p = 1;     // BAD — dangling
p = nullptr;   // safer
// delete p;   // OK on nullptr (no-op)

new vs malloc (C++)

• In C++ prefer new/delete: they call constructors/destructors for class types.
• malloc/free are C-style; do not mix new with free or malloc with delete.
• new can throw std::bad_alloc on failure (unless nothrow form).

Pointer to pointer and functions

• int** is a pointer to a pointer — used for 2D dynamic arrays and out-parameters that reseat a pointer.
• Passing int* lets a function modify the pointed-to object; passing int*& or int** can reseat the caller’s pointer.

void setToHeap(int*& p, int value) {
    delete p;
    p = new int(value);
}

Pointer basics — modify via *p

#include <iostream>
using namespace std;

int main() {
    int x = 5;
    int* p = &x;
    *p = *p + 10;
    cout << x << "\n"; // 15
    return 0;
}

Dynamic single int

#include <iostream>
using namespace std;

int main() {
    int* p = new int(100);
    cout << *p << "\n";
    delete p;
    p = nullptr;
    return 0;
}

Dynamic array — sum N numbers

#include <iostream>
using namespace std;

int main() {
    int n = 5;
    int* a = new int[n]{1, 2, 3, 4, 5};
    int sum = 0;
    for (int i = 0; i < n; i++) sum += a[i];
    cout << sum << "\n";
    delete[] a;
    return 0;
}

Static array vs dynamic array

#include <iostream>
using namespace std;

int main() {
    int fixed[3] = {10, 20, 30}; // automatic/static-size
    int n = 3;
    int* dyn = new int[n]{10, 20, 30}; // dynamic
    cout << fixed[1] << " " << dyn[1] << "\n";
    delete[] dyn;
    return 0;
}

Swap using pointers

#include <iostream>
using namespace std;

void swap(int* a, int* b) {
    int t = *a; *a = *b; *b = t;
}

int main() {
    int x = 3, y = 7;
    swap(&x, &y);
    cout << x << " " << y << "\n";
    return 0;
}

unique_ptr demo

#include <iostream>
#include <memory>
using namespace std;

int main() {
    auto p = make_unique<int[]>(5);
    for (int i = 0; i < 5; i++) p[i] = (i + 1) * 10;
    cout << p[2] << "\n"; // 30
    return 0;
}

shared_ptr — shared ownership

#include <iostream>
#include <memory>
#include <string>
using namespace std;

int main() {
    auto a = make_shared<string>("C++");
    auto b = a;
    cout << *b << " owners=" << a.use_count() << "\n";
    return 0;
}

Leak vs correct free (demo comments)

#include <iostream>
using namespace std;

int main() {
    int* leak = new int(1);
    // forgot delete — leak (don't do this)

    int* ok = new int(2);
    cout << *ok << "\n";
    delete ok;
    ok = nullptr;
    delete leak; // free for demo completeness
    return 0;
}