스마트 포인터

#include <iostream>
#include <utility>
#include <memory> // unique_ptr, make_unique
#include <string>

class MyClass {
public:
    std::string name;
    MyClass(const std::string& n) : name(n) {
        std::cout << "MyClass '" << name << "' created.\n";
    }
    ~MyClass() {
        std::cout << "MyClass '" << name << "' destroyed.\n";
    }
    void doSomething() {
        std::cout << "MyClass '" << name << "' doing something.\n";
    }
};

int main() {
    std::cout << "--- Unique Ptr 1 (Simple) ---\n";
    {
        // MyClass 객체를 unique_ptr로 생성
        std::unique_ptr<MyClass> ptr1 = std::make_unique<MyClass>("Object1");
        ptr1->doSomething();
        // 스코프를 벗어나면 ptr1이 자동으로 소멸되고 Object1도 파괴됨
    } // ~MyClass() 호출됨

    std::cout << "\n--- Unique Ptr 2 (Move Semantics) ---\n";
    std::unique_ptr<MyClass> ptrA = std::make_unique<MyClass>("ObjectA");
    ptrA->doSomething();

    std::unique_ptr<MyClass> ptrB;
    // ptrB = ptrA; // 컴파일 오류! 복사 불가능
    ptrB = std::move(ptrA); // 소유권 이전 (ptrA는 nullptr이 됨)

    if (ptrA) { // ptrA가 유효한지 확인
        std::cout << "ptrA is valid.\n";
    } else {
        std::cout << "ptrA is nullptr.\n"; // 출력됨
    }

    if (ptrB) {
        ptrB->doSomething(); // 출력: MyClass 'ObjectA' doing something.
    }
    // main 함수 종료 시 ptrB가 소멸되고 ObjectA 파괴됨
    // (ptrA는 이미 nullptr이므로 아무것도 파괴하지 않음)

    std::cout << "\n--- Unique Ptr 3 (Reset) ---\n";
    std::unique_ptr<MyClass> ptrC = std::make_unique<MyClass>("ObjectC");
    ptrC->doSomething();
    ptrC.reset(); // ptrC가 소유하던 ObjectC가 즉시 파괴됨 (ObjectC destroyed.)
    if (!ptrC) {
        std::cout << "ptrC is now nullptr.\n";
    }

    std::cout << "\n--- Unique Ptr 4 (Release - 원시 포인터 반환) ---\n";
    std::unique_ptr<MyClass> ptrD = std::make_unique<MyClass>("ObjectD");
    MyClass* rawPtr = ptrD.release(); // 소유권 포기 및 원시 포인터 반환. ptrD는 nullptr이 됨.
                                      // ObjectD는 더 이상 자동으로 해제되지 않음!
    rawPtr->doSomething();
    delete rawPtr; // 개발자가 수동으로 해제해야 함! (매우 중요!)
    // ~MyClass() 호출됨

    std::cout << "End of main.\n";
    return 0;
} // 이곳에서 ptrA, ptrB 등 스코프 벗어나는 unique_ptr들이 소멸됨.

#include <iostream>
#include <memory> // shared_ptr, make_shared
#include <string>

class Resource {
public:
    std::string id;
    Resource(const std::string& i) : id(i) {
        std::cout << "Resource '" << id << "' created.\n";
    }
    ~Resource() {
        std::cout << "Resource '" << id << "' destroyed.\n";
    }
    void use() {
        std::cout << "Using Resource '" << id << "'.\n";
    }
};

void process(std::shared_ptr<Resource> res) { // shared_ptr를 값으로 전달 (참조 횟수 증가)
    std::cout << "Inside process function. Resource count: " << res.use_count() << "\n";
    res->use();
} // res가 스코프를 벗어나면 참조 횟수 감소

int main() {
    std::cout << "--- Shared Ptr 1 (Basic) ---\n";
    {
        std::shared_ptr<Resource> r1 = std::make_shared<Resource>("SharedRes1"); // count = 1
        std::cout << "r1 count: " << r1.use_count() << "\n"; // 출력: 1

        std::shared_ptr<Resource> r2 = r1; // 복사! count = 2
        std::cout << "r1 count: " << r1.use_count() << ", r2 count: " << r2.use_count() << "\n"; // 출력: 2, 2

        process(r1); // r1이 값으로 전달되어 임시 shared_ptr이 생성됨. count = 3 (함수 내에서)
        std::cout << "Back in main. r1 count: " << r1.use_count() << "\n"; // 출력: 2
    } // r1, r2 스코프 벗어남. r2 소멸 (count=1), r1 소멸 (count=0). Resource 'SharedRes1' destroyed.

    std::cout << "\n--- Shared Ptr 2 (Custom Deleter) ---\n";
    // 배열이나 특수 해제 로직이 필요할 때 사용
    std::shared_ptr<int[]> arr_ptr(new int[5], std::default_delete<int[]>());
    // 또는 람다를 이용한 커스텀 삭제자
    std::shared_ptr<int> custom_delete_ptr(new int(10), [](int* p){
        std::cout << "Custom deleter called for " << *p << std::endl;
        delete p;
    });

    std::cout << "End of main.\n";
    return 0;
}

#include <iostream>
#include <memory> // shared_ptr, weak_ptr

class B; // 전방 선언

class A {
public:
    std::shared_ptr<B> b_ptr; // B에 대한 shared_ptr
    A() { std::cout << "A created.\n"; }
    ~A() { std::cout << "A destroyed.\n"; }
};

class B {
public:
    std::weak_ptr<A> a_ptr; // A에 대한 weak_ptr (중요!)
    B() { std::cout << "B created.\n"; }
    ~B() { std::cout << "B destroyed.\n"; }
    void checkA() {
        if (auto sharedA = a_ptr.lock()) { // weak_ptr를 shared_ptr로 변환 시도
            std::cout << "A is still alive.\n";
        } else {
            std::cout << "A is no longer alive.\n";
        }
    }
};

int main() {
    std::cout << "--- Circular Reference Problem (No weak_ptr) --- (주석 처리됨)\n";
    /*
    // 만약 B::a_ptr이 shared_ptr<A>였다면:
    {
        std::shared_ptr<A> a = std::make_shared<A>(); // a_count = 1
        std::shared_ptr<B> b = std::make_shared<B>(); // b_count = 1

        a->b_ptr = b; // b_count = 2
        b->a_ptr = a; // a_count = 2 (여기서 문제 발생!)

        // 스코프를 벗어나도 a와 b의 count가 1이 되어 소멸되지 않음!
    } // A destroyed, B destroyed가 출력되지 않음 -> 메모리 누수!
    */

    std::cout << "\n--- Circular Reference Solved with weak_ptr ---\n";
    {
        std::shared_ptr<A> a = std::make_shared<A>(); // A created. a_count = 1
        std::shared_ptr<B> b = std::make_shared<B>(); // B created. b_count = 1

        a->b_ptr = b; // b_count = 2
        b->a_ptr = a; // a_count는 변하지 않음 (weak_ptr이므로)

        std::cout << "a count: " << a.use_count() << ", b count: " << b.use_count() << "\n"; // 출력: a count: 1, b count: 2
        b->checkA(); // A is still alive.

    } // 스코프 벗어남
    // 지역 b가 먼저 소멸: B 강한 참조 수 2 -> 1, B 객체는 아직 살아 있음.
    // 지역 a 소멸: A 강한 참조 수 1 -> 0, A 소멸자 본문이 먼저 실행됨.
    // A의 b_ptr 멤버 소멸: B 강한 참조 수 1 -> 0, B 소멸자 실행.
    // 이 예제의 출력 순서: A destroyed. 다음 B destroyed.
    std::cout << "End of main.\n";
    return 0;
}

#include <iostream>
#include <memory>

int main() {
    auto owner = std::make_shared<int>(7);
    std::weak_ptr<int> observer = owner;
    auto held = observer.lock();
    std::cout << held.use_count() << '\n';
    owner.reset();
    std::cout << std::boolalpha << observer.expired() << ' ' << *held << '\n';
    held.reset();
    std::cout << observer.expired() << ' ' << static_cast<bool>(observer.lock()) << '\n';
}