C++ weak_ptr로 순환 참조 문제 해결하는 방법

🔗 shared_ptr의 편리함과 위험성

C++의 shared_ptr은 소유권을 공유할 수 있도록 설계된 스마트 포인터입니다.
하나의 객체를 여러 포인터가 참조할 수 있으며, 참조 카운트(reference count)가 0이 될 때 자동으로 메모리를 해제해주기 때문에 메모리 관리를 한결 수월하게 만들어줍니다.

예를 들어, 여러 클래스나 함수가 동일한 리소스를 공유할 때 직접 메모리 해제를 신경 쓰지 않아도 되어 코드가 깔끔해지고 안정성도 높아집니다.
이러한 shared_ptr의 자동 메모리 관리 기능은 복잡한 시스템에서도 널리 사용되는 이유이기도 하죠.

하지만 shared_ptr은 서로가 서로를 참조하는 경우 문제가 발생할 수 있습니다.
이런 구조에서는 참조 카운트가 절대로 0이 되지 않기 때문에, 객체가 소멸되지 않고 메모리 누수(memory leak)가 발생하게 됩니다.

struct B;

struct A {
    std::shared_ptr<B> ptrB;
};

struct B {
    std::shared_ptr<A> ptrA;
};

위 예제처럼 A와 B가 서로를 shared_ptr로 참조하면, 어느 한 쪽도 먼저 파괴될 수 없게 되어 메모리 해제가 이루어지지 않습니다.
이 문제를 해결하기 위해 등장한 것이 바로 weak_ptr입니다.

🛠️ 순환 참조가 발생하는 구조

C++에서 순환 참조는 두 객체가 서로를 shared_ptr로 참조하면서 생기는 구조입니다.
이 구조에서는 두 객체 모두 참조 카운트를 갖고 있어서,
각 객체가 소멸되어야 할 시점에도 참조 카운트가 0이 되지 않아 메모리가 해제되지 않는 문제가 발생합니다.

다시 말해, 객체 A가 객체 B를 shared_ptr로 갖고 있고,
동시에 객체 B도 객체 A를 shared_ptr로 갖고 있다면,
어느 쪽도 소멸되지 않기 때문에 영원히 메모리에 남아 있는 좀비 객체가 생기게 되는 것이죠.

📌 순환 참조의 실제 예시

#include <memory>
#include <iostream>

struct B; // 전방 선언

struct A {
    std::shared_ptr<B> b;
    ~A() { std::cout << "A destroyed\n"; }
};

struct B {
    std::shared_ptr<A> a;
    ~B() { std::cout << "B destroyed\n"; }
};

int main() {
    std::shared_ptr<A> objA = std::make_shared<A>();
    std::shared_ptr<B> objB = std::make_shared<B>();
    objA->b = objB;
    objB->a = objA;
    return 0;
}

이 예제를 실행하면, “A destroyed” 또는 “B destroyed” 메시지가 출력되지 않습니다.
즉, 소멸자가 호출되지 않았다는 것은 메모리가 해제되지 않았다는 뜻이며,
이것이 바로 순환 참조로 인한 메모리 누수입니다.

⚙️ weak_ptr의 역할과 특징

weak_ptr은 C++11부터 도입된 스마트 포인터로, shared_ptr와 다르게 객체의 소유권을 갖지 않습니다.
즉, 참조는 하지만 참조 카운트를 증가시키지 않기 때문에, 순환 참조를 방지할 수 있습니다.

weak_ptr은 단독으로 객체를 관리하거나 접근할 수 없으며,
반드시 lock() 함수를 통해 shared_ptr로 일시적으로 변환한 후 사용해야 합니다.
이러한 구조 덕분에, 객체가 유효하지 않으면 shared_ptr을 얻을 수 없기 때문에 안전하게 사용할 수 있죠.

📌 weak_ptr 사용 방법

#include <memory>
#include <iostream>

int main() {
    std::shared_ptr<int> sp = std::make_shared<int>(100);
    std::weak_ptr<int> wp = sp;

    if (auto spt = wp.lock()) {
        std::cout << *spt << std::endl;
    } else {
        std::cout << "expired" << std::endl;
    }

    return 0;
}

위 코드에서 wp.lock()은 shared_ptr이 아직 살아 있다면 유효한 포인터를 반환하고,
그렇지 않다면 nullptr을 반환합니다.
이런 방식으로 객체의 생존 여부를 체크하면서 안전하게 사용할 수 있다는 점이 weak_ptr의 큰 장점입니다.

🔌 weak_ptr을 이용한 순환 참조 해결 예제

앞서 shared_ptr만 사용할 경우 순환 참조가 발생할 수 있다는 점을 살펴보았습니다.
이번에는 weak_ptr을 활용하여 이 문제를 어떻게 해결할 수 있는지 예제를 통해 확인해보겠습니다.

shared_ptr는 소유권을 가지므로 참조 카운트를 증가시키고, weak_ptr은 소유권이 없기 때문에 참조 카운트를 증가시키지 않습니다.
따라서 두 객체 중 한 쪽을 weak_ptr로 바꿔주면 메모리 누수 없이 객체가 정상적으로 소멸됩니다.

#include <memory>
#include <iostream>

struct B; // 전방 선언

struct A {
    std::shared_ptr<B> b;
    ~A() { std::cout << "A destroyed\n"; }
};

struct B {
    std::weak_ptr<A> a; // weak_ptr 사용
    ~B() { std::cout << "B destroyed\n"; }
};

int main() {
    std::shared_ptr<A> objA = std::make_shared<A>();
    std::shared_ptr<B> objB = std::make_shared<B>();
    objA->b = objB;
    objB->a = objA;
    return 0;
}

위 코드를 실행하면, “A destroyed” 와 “B destroyed”가 정상적으로 출력됩니다.
즉, 두 객체가 순서에 상관없이 안전하게 메모리에서 해제되며 순환 참조 문제가 말끔히 해결된 것입니다.

실제 프로젝트에서는 관계가 “소유”가 아닌 단순 참조인 경우,
또는 객체 수명에 영향 주지 않아야 하는 경우에도 weak_ptr을 사용하는 것이 바람직합니다.

💡 스마트 포인터 사용 시 주의할 점

shared_ptr과 weak_ptr은 매우 강력하고 편리하지만, 그만큼 올바르게 사용하는 것이 중요합니다.
잘못 사용하면 오히려 의도하지 않은 메모리 누수나 성능 저하를 일으킬 수 있기 때문이죠.

스마트 포인터를 사용할 때는 항상 객체의 소유 관계를 먼저 고려해야 합니다.
shared_ptr은 소유권을 공유하는 상황에서만 사용하고,
그 외에는 unique_ptr이나 weak_ptr을 상황에 맞게 조합하여 사용하는 것이 좋습니다.

• 🛠️shared_ptr은 반드시 소유 관계가 명확할 때만 사용하세요.
• ⚙️weak_ptr은 순환 참조가 우려되거나 참조만 필요할 때 사용하세요.
• 🔍shared_ptr 사용 후 참조 카운트를 디버깅하는 습관을 들이세요.
• 🚫raw pointer와 혼용하지 마세요. 예상치 못한 문제가 발생할 수 있습니다.

또한 불필요한 shared_ptr 복사를 줄이는 것도 좋은 습관입니다.
복사가 일어나면 참조 카운트가 증가하면서, 의도치 않은 객체 수명 연장으로 이어질 수 있기 때문입니다.

마지막으로 스마트 포인터는 어디까지나 메모리 관리를 돕는 도구일 뿐,
모든 상황을 자동으로 해결해주는 만능 도구는 아니라는 점을 기억하세요.
올바른 이해와 사용법이 동반되어야 진정한 효과를 얻을 수 있습니다.

❓ 자주 묻는 질문 (FAQ)