Practice Questions — Smart Pointers and Modern Memory Management

auto p = make_unique<int>(42);
cout << *p;

auto p = make_shared<int>(99);
cout << p.use_count();

auto p1 = make_shared<int>(10);
auto p2 = p1;
auto p3 = p1;
cout << p1.use_count();

unique_ptr<int> p1 = make_unique<int>(5);
unique_ptr<int> p2 = move(p1);
cout << (p1 == nullptr) << " " << *p2;

auto p = make_unique<int>(7);
cout << (p ? "valid" : "null");
p.reset();
cout << " " << (p ? "valid" : "null");

auto p1 = make_shared<int>(50);
{
    auto p2 = p1;
    cout << p1.use_count() << " ";
}
cout << p1.use_count() << " " << *p1;

auto sp = make_shared<int>(100);
weak_ptr<int> wp = sp;
cout << wp.use_count() << " " << wp.expired() << " ";
sp.reset();
cout << wp.use_count() << " " << wp.expired();

auto sp = make_shared<int>(77);
weak_ptr<int> wp = sp;
auto locked = wp.lock();
cout << (locked ? to_string(*locked) : "null") << " ";
cout << sp.use_count();

struct X {
    int val;
    X(int v) : val(v) { cout << "X(" << val << ") ";
    }
    ~X() { cout << "~X(" << val << ") "; }
};

{
    auto p = make_unique<X>(1);
    auto q = make_unique<X>(2);
}
cout << "done";

auto p = make_unique<int>(10);
int* raw = p.get();
cout << *raw << " ";
p.reset();
cout << (p == nullptr);

auto p = make_shared<int>(55);
auto q = move(p);
cout << (p == nullptr) << " " << q.use_count() << " " << *q;

class A {
public:
    A() { cout << "A "; }
    ~A() { cout << "~A "; }
};

vector<unique_ptr<A>> v;
v.push_back(make_unique<A>());
v.push_back(make_unique<A>());
cout << "clear ";
v.clear();

auto p = make_shared<int>(25);
auto q = p;
auto r = p;
r.reset();
cout << p.use_count() << " " << *p;

auto p = make_unique<int>(100);
auto q = make_unique<int>(200);
p.swap(q);
cout << *p << " " << *q;

weak_ptr<int> wp;
{
    auto sp = make_shared<int>(42);
    wp = sp;
    cout << wp.expired() << " ";
}
cout << wp.expired();

struct Obj {
    int val;
    Obj(int v) : val(v) { cout << "C" << v << " "; }
    ~Obj() { cout << "D" << val << " "; }
};
auto p = make_unique<Obj>(1);
p = make_unique<Obj>(2);
cout << "end ";

auto p = make_shared<int>(10);
auto q = make_shared<int>(20);
cout << (p == q) << " ";
q = p;
cout << (p == q) << " " << *q;

auto p = make_unique<int>(50);
int* raw = p.release();
cout << (p == nullptr) << " " << *raw;
delete raw;  // Must manually delete after release!

auto p = make_unique<string>("Hello");
cout << p->size() << " " << (*p)[0];

shared_ptr<int> p1 = make_shared<int>(10);
shared_ptr<int> p2 = p1;
*p2 = 20;
cout << *p1;

auto p1 = make_unique<int>(100);
auto p2 = make_unique<int>(200);
swap(p1, p2);
cout << *p1 << " " << *p2;

unique_ptr<int[]> arr = make_unique<int[]>(4);
for (int i = 0; i < 4; i++) arr[i] = (i + 1) * 10;
cout << arr[0] << " " << arr[3];

auto sp = make_shared<int>(30);
weak_ptr<int> wp = sp;
sp = make_shared<int>(60);
auto locked = wp.lock();
cout << (locked ? "alive" : "dead");

struct Node {
    int val;
    unique_ptr<Node> next;
    Node(int v) : val(v), next(nullptr) {}
};

auto head = make_unique<Node>(1);
head->next = make_unique<Node>(2);
head->next->next = make_unique<Node>(3);

auto curr = head.get();
while (curr) {
    cout << curr->val << " ";
    curr = curr->next.get();
}

class B {
public:
    B() { cout << "B "; }
    B(const B&) { cout << "Bc "; }
    B(B&&) noexcept { cout << "Bm "; }
    ~B() { cout << "~B "; }
};

B b1;
B b2 = b1;
B b3 = move(b1);

auto p = make_shared<vector<int>>(vector<int>{10, 20, 30});
cout << p->size() << " " << (*p)[1];

auto sp = make_shared<int>(10);
weak_ptr<int> wp = sp;
auto sp2 = wp.lock();
cout << sp.use_count() << " ";
sp.reset();
sp2.reset();
cout << wp.expired();

unique_ptr<int> p;
cout << (p == nullptr) << " ";
p = make_unique<int>(99);
cout << (p == nullptr) << " " << *p;

struct Widget {
    int id;
    Widget(int i) : id(i) {}
};
auto w = make_unique<Widget>(42);
cout << w->id << " ";
w->id = 100;
cout << w->id;