[STL] 스마트포인터(std::unique_ptr, std::shared_ptr, std::weak_ptr)

 

 

 

스마트포인터

스마트포인터는 C++에 추가된 기능 중에 매우 중요하다고 할 수 있습니다. C++의 치명적인 단점 중 하나가 메모리 관리를 직접하는 데에 있어서 리스크를 떠안기 때문입니다. 메모리 관리를 자동으로 해주는 스마트포인터로 인해서 모던 C++이 한층 풍부해졌습니다. 스마트 포인터는 메모리 누수와 관련된 문제를 해결하는데 큰 도움을 주며, 자원 관리를 보다 안전하게 하고 코드의 가독성과 유지보수성을 향상시킵니다.

 

 

std::unique_ptr

std::unique_ptr은 독점적으로 소유하는 포인터를 나타내며, 객체에 대해 단일 소유권을 갖습니다. 즉, 오직 하나의 std::unique_ptr만이 특정 객체를 소유하고, 이후에는 해당 객체의 소유권을 다른 std::unique_ptr로 이전하거나, 소유권을 포기하여 객체를 삭제할 수 있습니다.

#include <iostream>
#include <memory>

int main() {
    // std::unique_ptr 생성
    std::unique_ptr<int> uniquePtr = std::make_unique<int>(42);

    // get(): 원본 포인터에 대한 raw pointer를 반환
    int* rawPtr = uniquePtr.get();
    std::cout << "Raw Pointer: " << rawPtr << std::endl;

    // reset(): 포인터를 다른 객체로 재할당하거나, nullptr로 초기화
    uniquePtr.reset(new int(99));
    std::cout << "Reset value: " << *uniquePtr << std::endl;

    // swap(): 두 unique_ptr의 포인터를 교환
    std::unique_ptr<int> anotherUniquePtr = std::make_unique<int>(77);
    std::cout << "Before swap - uniquePtr: " << *uniquePtr << ", anotherUniquePtr: " << *anotherUniquePtr << std::endl;
    uniquePtr.swap(anotherUniquePtr);
    std::cout << "After swap - uniquePtr: " << *uniquePtr << ", anotherUniquePtr: " << *anotherUniquePtr << std::endl;

    // release(): 포인터 소유권을 포기하고 raw pointer를 반환
    int* releasedPtr = uniquePtr.release();
    if (!uniquePtr) {
        std::cout << "uniquePtr is empty after release." << std::endl;
    }
    std::cout << "Released Pointer: " << releasedPtr << std::endl;
    
    // unique_ptr 소멸 시에는 자동으로 동적 할당된 메모리가 해제됨
    // releasedPtr는 이제 raw pointer이므로 메모리를 직접 해제해야 함
    delete releasedPtr;

    return 0;
}


/*
출력결과: 
Raw Pointer: 0x...
Reset value: 99
Before swap - uniquePtr: 99, anotherUniquePtr: 77
After swap - uniquePtr: 77, anotherUniquePtr: 99
uniquePtr is empty after release.
Released Pointer: 0x...

*/

 

 

 

std::shared_ptr

std::shared_ptr은 C++ 스마트 포인터 중 하나로, 여러 개의 std::shared_ptr들이 하나의 객체를 공유 소유하는 형태를 가지고 있습니다. 각 std::shared_ptr들은 객체에 대한 참조 카운트를 유지하고, 객체의 참조 카운트가 0이 되면 자동으로 객체가 메모리에서 해제됩니다. 이러한 공유 소유 방식으로 인해 객체의 수명을 효과적으로 관리할 수 있습니다.

std::shared_ptr에서 사용되는 주요 메서드들은 다음과 같습니다.

 

std::shared_ptr 생성 및 초기화

std::shared_ptr<T>: 기본 생성자로 초기화된 빈 std::shared_ptr 객체를 생성합니다.
std::shared_ptr<T>(args...): args...로 전달된 인자들로 T 타입의 객체를 생성하고 해당 객체를 참조하는 std::shared_ptr 객체를 생성합니다.
std::make_shared<T>(args...): args...로 전달된 인자들로 T 타입의 객체를 생성하고 해당 객체를 참조하는 std::shared_ptr 객체를 생성합니다. std::make_shared는 메모리 할당과 객체 초기화를 하나의 단일 연산으로 수행하여 오버헤드를 줄일 수 있습니다.

소유권 및 참조 카운트

use_count(): 현재 객체의 참조 카운트를 반환합니다.
unique(): 참조 카운트가 1이면 true를 반환하고, 그렇지 않으면 false를 반환합니다.
get(): 원본 포인터에 대한 raw pointer를 반환합니다.

소유권 이전

reset(): std::shared_ptr의 소유권을 포기하고, 참조하던 객체의 참조 카운트를 감소시킵니다. 이로 인해 객체의 참조 카운트가 0이 되면 자동으로 객체가 삭제됩니다.
reset(T* ptr): std::shared_ptr의 소유권을 새로운 포인터 ptr로 이전합니다. 이미 다른 객체를 가리키고 있는 경우에는 해당 객체의 참조 카운트가 감소하고, 새로운 객체를 가리키게 됩니다.

공유 및 비공유 std::shared_ptr의 생성 및 비교

std::shared_ptr<T>(const std::shared_ptr<T>& r): r이 가리키는 객체를 공유 소유하는 std::shared_ptr을 생성합니다.
std::shared_ptr<T>(std::shared_ptr<T>&& r) noexcept: r이 가리키는 객체를 공유 소유하는 std::shared_ptr을 생성합니다. 이동 생성자로, noexcept 속성을 가지고 있습니다.
std::shared_ptr<T>(std::weak_ptr<T> r): r이 가리키는 객체를 공유 소유하는 std::shared_ptr을 생성합니다. 이 때, r이 가리키는 객체가 유효하지 않으면 빈 std::shared_ptr이 생성됩니다.
operator==, operator!=: std::shared_ptr 객체들을 비교합니다.

다른 스마트 포인터와의 상호작용

std::shared_ptr은 std::weak_ptr과 함께 사용되어 루프를 방지하고 dangling pointer를 예방하는 데에 유용합니다.
std::shared_ptr은 std::unique_ptr로부터 생성할 수 있습니다.

 

#include <iostream>
#include <memory>

int main() {
    std::shared_ptr<int> sharedPtr1 = std::make_shared<int>(42);
    std::cout << "sharedPtr1 use_count: " << sharedPtr1.use_count() << std::endl; // 1

    std::shared_ptr<int> sharedPtr2 = sharedPtr1;
    std::cout << "sharedPtr1 use_count: " << sharedPtr1.use_count() << std::endl; // 2
    std::cout << "sharedPtr2 use_count: " << sharedPtr2.use_count() << std::endl; // 2

    sharedPtr1.reset();
    std::cout << "sharedPtr1 use_count: " << sharedPtr1.use_count() << std::endl; // 0 (sharedPtr1은 더 이상 객체를 소유하지 않음)
    std::cout << "sharedPtr2 use_count: " << sharedPtr2.use_count() << std::endl; // 1

    return 0;
}

/*
출력결과:
sharedPtr1 use_count: 1
sharedPtr1 use_count: 2
sharedPtr2 use_count: 2
sharedPtr1 use_count: 0
sharedPtr2 use_count: 1

*/

 

위 예제에서는 std::shared_ptr의 생성, 소유권 이전, 참조 카운트 등의 기능을 보여주었습니다. 두 개의 std::shared_ptr 객체가 하나의 객체를 공유 소유하고 있으며, 해당 객체의 참조 카운트를 확인할 수 있습니다. 소유권을 이전하면서 참조 카운트가 변경되는 것을 확인할 수 있습니다.

 

 

 

std::weak_ptr

std::weak_ptr은 객체를 공유하지만 참조 카운트를 증가시키지 않는 스마트 포인터입니다. std::weak_ptr은 주로 std::shared_ptr와 함께 사용되며, std::weak_ptr를 통해 객체를 참조하는 동안 참조 카운트는 증가하지 않기 때문에 객체의 수명이 std::weak_ptr에 영향을 받지 않습니다.

weak_ptr의 특징은 다음과 같습니다.

 

객체 소유권이 없음

std::weak_ptr은 객체에 대한 소유권을 갖지 않습니다. 즉, std::weak_ptr만으로는 객체가 메모리에서 삭제되지 않습니다. 단지 객체를 참조하고 관찰하는 역할을 합니다.

참조하는 객체의 수명 체크

std::weak_ptr는 std::shared_ptr가 아닌 다른 스마트 포인터의 소유자일 수 있습니다. 때문에 std::weak_ptr가 참조하는 객체가 여전히 유효한지 확인해야 합니다.

std::weak_ptr로부터 std::shared_ptr 생성

std::weak_ptr로부터 std::shared_ptr을 생성하여 객체에 대한 임시 소유권을 얻을 수 있습니다. 이를 통해 객체가 여전히 유효한지 체크한 뒤 유효한 경우에만 객체에 접근할 수 있습니다.

std::weak_ptr의 생성과 소멸

std::weak_ptr은 std::shared_ptr으로부터 생성되거나, std::shared_ptr로부터 생성된 후 std::weak_ptr로부터 생성될 수 있습니다. std::weak_ptr이 더 이상 유효하지 않다면 객체에 대한 소유권이 더 이상 없다는 뜻이며, 객체가 삭제되었다는 것을 의미합니다.

 

#include <iostream>
#include <memory>

int main() {
    std::shared_ptr<int> sharedPtr = std::make_shared<int>(42);
    std::weak_ptr<int> weakPtr = sharedPtr;

    // weakPtr로부터 sharedPtr 생성
    if (auto lockedSharedPtr = weakPtr.lock()) {
        std::cout << "Weak pointer is valid. Value: " << *lockedSharedPtr << std::endl;
    } else {
        std::cout << "Weak pointer is expired." << std::endl;
    }

    // sharedPtr를 reset하고 weakPtr로부터 생성한 sharedPtr 접근 시도
    sharedPtr.reset();
    if (auto lockedSharedPtr = weakPtr.lock()) {
        std::cout << "Weak pointer is valid. Value: " << *lockedSharedPtr << std::endl;
    } else {
        std::cout << "Weak pointer is expired." << std::endl;
    }

    return 0;
}

/*
출력결과:
Weak pointer is valid. Value: 42
Weak pointer is expired.

*/

 

std::weak_ptr을 이용하여 std::shared_ptr를 관찰합니다. lock() 함수를 사용하여 std::weak_ptr가 여전히 유효한지 체크하고, 유효한 경우에만 std::shared_ptr로부터 임시 소유권을 얻어와 객체에 접근합니다. 만약 std::weak_ptr이 더 이상 유효하지 않다면, 즉 해당 객체가 삭제되었다면 lock() 함수는 nullptr를 반환하게 됩니다. 이렇게 lock() 함수를 통해 순환 참조를 방지하면서 객체를 안전하게 관찰할 수 있습니다.