Memory & Smart Pointers

#include <iostream>
#include <vector>

int main() {
    int count = 3;                           // on the stack
    std::vector<int> data(1'000'000, 7);     // handle on the stack, a million ints on the heap

    std::cout << "sizeof(count) = " << sizeof(count) << '\n';
    std::cout << "sizeof(data)  = " << sizeof(data) << " (just the handle)\n";
    std::cout << "elements      = " << data.size() << '\n';

    {
        std::vector<int> temp(10, 1);        // inner scope
        std::cout << "temp sum = " << temp[0] * 10 << '\n';
    }                                        // temp and its heap block are freed here
    std::cout << "count still " << count << '\n';
}

#include <iostream>
#include <string>

int main() {
    int* answer = new int(42);                    // one int on the heap
    std::string* name = new std::string("Asha");  // one string on the heap
    std::cout << *answer << ' ' << *name << " (" << name->size() << " chars)\n";
    delete answer;                                // one new, one delete
    delete name;

    int n = 5;                                    // size known only at runtime
    double* prices = new double[n]{9.5, 4.0, 12.25, 3.0, 7.5};
    double total = 0;
    for (int i = 0; i < n; ++i) total += prices[i];
    std::cout << "total " << total << '\n';
    delete[] prices;                              // new[] pairs with delete[]
    prices = nullptr;                             // no dangling address left behind
}

#include <iostream>
#include <stdexcept>
#include <vector>

// With a raw new[] here, the throw below would leak the buffer.
// With a vector, the buffer is freed while the exception passes through.
int parseAll(int count, bool failHalfway) {
    std::vector<int> buffer(count);
    for (int i = 0; i < count; ++i) {
        if (failHalfway && i == count / 2) throw std::runtime_error("bad record");
        buffer[i] = i * i;
    }
    return buffer[count - 1];
}

int main() {
    std::cout << parseAll(5, false) << '\n';
    try {
        parseAll(5, true);
    } catch (const std::exception& e) {
        std::cout << "caught: " << e.what() << " (and nothing leaked)\n";
    }
}

#include <iostream>
#include <string>

class Tracer {
public:
    explicit Tracer(std::string name) : name_(std::move(name)) {
        std::cout << "  acquire " << name_ << '\n';
    }
    ~Tracer() { std::cout << "  release " << name_ << '\n'; }
private:
    std::string name_;
};

int work(bool leaveEarly) {
    Tracer db("db");
    Tracer tx("tx");
    if (leaveEarly) return 1;       // both destructors still run
    Tracer log("log");
    return 0;
}

int main() {
    std::cout << "normal:\n";
    work(false);
    std::cout << "early return:\n";
    work(true);
}

#include <iostream>
#include <memory>
#include <string>
#include <vector>

struct Document {
    std::string title;
    explicit Document(std::string t) : title(std::move(t)) {}
    ~Document() { std::cout << "closing " << title << '\n'; }
};

void archive(std::unique_ptr<Document> doc) {     // takes ownership
    std::cout << "archiving " << doc->title << '\n';
}                                                 // doc destroyed here

int main() {
    auto draft = std::make_unique<Document>("draft.txt");
    std::cout << "editing " << draft->title << '\n';

    archive(std::move(draft));                    // ownership moves into archive
    std::cout << std::boolalpha << "draft is empty: " << (draft == nullptr) << '\n';

    std::vector<std::unique_ptr<Document>> open;
    open.push_back(std::make_unique<Document>("a.txt"));
    open.push_back(std::make_unique<Document>("b.txt"));
    std::cout << "open files: " << open.size() << '\n';
    open.pop_back();                              // destroys b.txt right now
    std::cout << "open files: " << open.size() << '\n';
}                                                 // the vector destroys a.txt

#include <iostream>
#include <memory>
#include <string>
#include <vector>

struct Config {
    std::string region;
    explicit Config(std::string r) : region(std::move(r)) {}
    ~Config() { std::cout << "config freed\n"; }
};

struct Worker {
    int id;
    std::shared_ptr<Config> config;       // each worker co-owns the config
};

int main() {
    auto cfg = std::make_shared<Config>("ap-south-1");
    std::cout << "count " << cfg.use_count() << '\n';

    std::vector<Worker> workers;
    workers.push_back({1, cfg});
    workers.push_back({2, cfg});
    std::cout << "count " << cfg.use_count() << '\n';

    cfg.reset();                          // main lets go of its copy
    std::cout << "worker 2 still sees " << workers[1].config->region << '\n';
    std::cout << "count " << workers[0].config.use_count() << '\n';

    workers.clear();                      // last owners gone: object deleted now
    std::cout << "end of main\n";
}

#include <iostream>
#include <memory>
#include <string>

struct Person {
    std::string name;
    std::weak_ptr<Person> partner;            // does not own
    explicit Person(std::string n) : name(std::move(n)) {}
    ~Person() { std::cout << "bye " << name << '\n'; }
};

void greetPartner(const Person& p) {
    if (auto other = p.partner.lock()) {      // shared_ptr, or empty if gone
        std::cout << p.name << " says hi to " << other->name << '\n';
    } else {
        std::cout << p.name << " has no partner any more\n";
    }
}

int main() {
    auto a = std::make_shared<Person>("Asha");
    {
        auto b = std::make_shared<Person>("Ravi");
        a->partner = b;
        b->partner = a;
        std::cout << "use_count: " << a.use_count() << '\n';   // weak refs do not count
        greetPartner(*a);
    }                                         // b's count hits 0: Ravi is deleted
    greetPartner(*a);
    std::cout << std::boolalpha << "expired: " << a->partner.expired() << '\n';
}

#include <iostream>
#include <memory>

// Pretend C library: you must call closeConnection on everything openConnection returns.
struct Connection { int id; };
Connection* openConnection(int id) {
    std::cout << "open #" << id << '\n';
    return new Connection{id};
}
void closeConnection(Connection* c) {
    std::cout << "close #" << c->id << '\n';
    delete c;
}

// A deleter type that calls the library's cleanup function.
struct ConnectionCloser {
    void operator()(Connection* c) const { closeConnection(c); }
};
using ConnectionPtr = std::unique_ptr<Connection, ConnectionCloser>;

int main() {
    ConnectionPtr primary(openConnection(1));
    {
        ConnectionPtr replica(openConnection(2));
        std::cout << "querying #" << replica->id << '\n';
    }                                   // closeConnection(replica) runs here
    std::cout << "still using #" << primary->id << '\n';
}                                       // and closeConnection(primary) here

#include <iostream>
#include <memory>
#include <string>
#include <vector>

// Rule of zero: no destructor, no copy/move functions written by hand.
class Playlist {
public:
    explicit Playlist(std::string name) : name_(std::move(name)) {}
    void add(std::string song) { songs_.push_back(std::move(song)); }
    std::size_t size() const { return songs_.size(); }
    const std::string& name() const { return name_; }
private:
    std::string name_;                 // manages its own memory
    std::vector<std::string> songs_;   // manages its own memory
};

int main() {
    Playlist road("road trip");
    road.add("song A");
    road.add("song B");

    Playlist copy = road;              // compiler-generated copy: a deep copy
    copy.add("song C");
    std::cout << road.name() << ": " << road.size() << '\n';
    std::cout << copy.name() << ": " << copy.size() << '\n';

    auto owned = std::make_unique<Playlist>(road);   // heap copy, freed automatically
    std::cout << "owned: " << owned->size() << '\n';
}