[Modern C++] unique_ptr 사용법 상세

1. unique_ptr 이란?

 

unique_ptr은 스마트포인터로 creational design pattern에서 많이 사용되는 포인터이다.

unique_ptr을 완벽히 이해하기 위해서는 move에 대한 고찰도 필요하다.

여기서는 복잡한 개념보다는 실제 사용법 위주로 정리하였다.

 

2. 사용예제

 

실제 개발을 진행하면서 명확한 사용법에서 해메는 경우가 종종있다. 이런 측면에서 보통 많이

적용되는 사용법 위주로 정리한 코드 예제들이다.

특히 unique_ptr을 함수의 파라미터로 사용할 때, 값/참조/rvalue의 선택지가 있는데

어떤 것을 사용해야 할지가 가장 햇갈리는 부분이였다.

간단히 사용법 측면에서 정리하면 다음과 같이 정리할 수 있을 것 같다.

 

• 받는쪽(함수)로 완전히 자원을 넘겨야 할 경우
  • 함수파라미터를 값이나 rvalue로 선언한다.
  • rvalue로 선언할 경우, 받는쪽에서 move를 통해서 자원을 가져가야 자원이동이 완료된다.
• 전달한 쪽에서도 계속 자원을 사용해야 할 경우
  • 함수파라미터를 참조로 선언해야 한다.

 

#include <iostream> #include <memory> #include <functional> class A { public: A(int v) : a(v) { std::cout << "A() called .. " << std::endl; } ~A() { std::cout << "~A() called .. " << std::endl; } int getValue() const { return a; } void setValue(int v) { a = v; } private: int a; }; void f1(std::unique_ptr<A> ua) { // 함수 매개변수로 value로 전달 경우 std::cout << "value : " << ua->getValue() << std::endl; } void f2(const std::unique_ptr<A> &ua) { // 함수 매개변수로 value로 전달 경우 std::cout << "in value : " << ua->getValue() << std::endl; } void f3(std::unique_ptr<A> &&ua) { // 함수 매개변수로 value로 전달 경우 std::cout << "in value : " << ua->getValue() << std::endl; } void f4(std::unique_ptr<A> &&ua) { // 함수 매개변수로 value로 전달 경우 std::unique_ptr<A> a = std::move(ua); std::cout << "in value : " << a->getValue() << std::endl; } int main() { // 1. nullptr { std::unique_ptr<A> ua1; // std::unique_ptr<A> ua1(nullptr)과 동일 } // 2. 일반적인 사용법 { std::unique_ptr<A> ua2{new A(10)}; // since c++11 std::unique_ptr<A> ua3 = std::make_unique<A>(10); // since c++14 // user defined deleter 사용 std::unique_ptr<A, std::function<void(A*)>> ua4(new A(10), [](A* ptr) { std::cout << "destroying from a custom deleter...\n"; delete ptr; }); } // 3. 호환성 측면에서 사용 예제 { // 기존에 raw pointer를 unique_ptr을 통해서 자원관리하고자 할 때 적용가능 A* pa1 = new A(20); std::unique_ptr<A> ua5(pa1); // 기존에 raw pointer를 unique_ptr을 통해서 자원관리하고자 할 때 적용가능 A* pa2 = new A(20); std::unique_ptr<A> ua6; ua5.reset(pa2); // get함수를 통한 raw pointer 획득 : raw pointer로 구현된 코드에 호환성을 위해 적용가능 A* pa3 = nullptr; std::unique_ptr<A> ua7(new A(10)); pa3 = ua7.get(); std::cout << "pa3 value : " << pa3->getValue() << std::endl; } // 4. 함수 파라미터와의 정합성 예제 // 4.1. 함수 파라미터가 unique_ptr<A>을 값으로 받을 때 { std::unique_ptr<A> ua8 = std::make_unique<A>(10); //f1(ua8); // error : unique_ptr(const unique_ptr&) = delete; // rvalue로 넘겨야 한다. f1(std::move(ua8)); // 이후부터 ua8 접근 시, 이미 ua8는 자원을 넘겼다. 따라서 segmentation fault; // std::cout << "value : " << ua8->getValue() << std::endl; } // 4.2. 함수 파라미터가 unique_ptr<A>을 참조로 받을 때 { std::unique_ptr<A> ua9 = std::make_unique<A>(10); // 참조로 unique_ptr을 넘길 시에는 자원은 이동되지 않고, 공유된다. f2(ua9); // 따라서 아래 코드는 ok std::cout << "out value : " << ua9->getValue() << std::endl; } // 4.3. 함수 파라미터가 unique_ptr<A>을 rvalue로 받을 때 { std::unique_ptr<A> ua10 = std::make_unique<A>(10); // rvalue function parameter에 넘긴다. // f3(ua10); // error : a6 is lvalue f3(std::move(ua10)); // 원칙적으로 ua10 아래에서 호출하면 segmentation fault가 발생해야 하는데, 발생하지 않는다. // 이 부분을 주의해야 한다. std::cout << "out value : " << ua10->getValue() << std::endl; } // 4.4. 함수 파라미터가 unique_ptr<A>을 rvalue로 받을 때 // f3함수에서 f4로 변경된 부분을 참고. 실제 f4처럼 함수파라미터로 넘어온 rvalue를 함수내에서 가져가야 // 완전한 자원 이동이 된다. { std::unique_ptr<A> ua11 = std::make_unique<A>(10); f4(std::move(ua11)); // f3을 f4로 고치면 이제 이후부터 ua11 접근 시, segmentation fault; //std::cout << "out value : " << ua11->getValue() << std::endl; } return 0; }

 

4. Pimpl Idiom with unique_ptr

 

unique_ptr과 함께 숙지해 놓으면 좋은 예가 c++ Idiom 중에서 Pimpl이다.

Pimpl은 컴파일 시간을 줄이기 위한 방법으로 Effective Modern C++ 22장에 정리되어 있다.

그 책을 예제로 정리해 놓는다.

아래 코드는 user define Gadget class가 widget.h에 포함되어 있다. widget.h 파일을 많은 cpp 파일에서

include 시킨다고 가정하면, 사용자가 개발 중에 Gadget을 빈번하게 수정한다면 widget.h를 include하는

모든 파일은 컴파일 대상이되어 빌드 시간이 오래걸린다. (컴파일러는 header 파일만 바라본다)

 

<컴파일 시간이 오래걸리는 코드 원본>

// in header "widget.h" class Widget { public: Widget(); private: std::string name; std::vector<double> data; Gadget g1, g2, g3; // Gadget is user defined type };

 

아래 코드는 위의 컴파일 시간 문제를 C++98 버전으로 Pimpl을 구현한 코드이다.

1. struct Impl에 사용자 변수를 package한다.
2. Impl *pImpl raw pointer로 할당받는다. Gadet의 변경은 이제 컴파일 시간에 영향을 주지 않는다.
3. 실제 코드는 cpp 구현부에 존재한다.
4. raw pointer의 사용으로 사용자 정의 생성자/소멸자를 만들어줘야 한다.

<C++ 98 Pimpl 구현 코드>

// Applying the Pimpl Idiom in C++98 class Widget { public: Widget(); ~Widget(); // raw pointer 사용으로 pImpl을 정리할 destructor 선언은 필수 private: struct Impl; // <-------------------------- 1) Impl *pImpl; // <-------------------------- 2) }; // Pimpl Idiom 개념상 // 즉 constructor와 destructor의 정의는 Widget.cpp 파일로 이동 // in Widget.cpp 파일 내부 #include "widget.h" #include "gadget.h" #include <string> #include <vector> // <-------------------------- 3) struct Widget::Impl { std::string name; std::vector<double> data; Gadget g1, g2, g3; }; // <-------------------------- 4) Widget::Widget() : pImpl(new Impl) { } // <-------------------------- 5) Widget::~Widget() { delete pImpl; }

 

이제 Pimpl에 c++11 unique_ptr 사용한다면 컴파일러가 자동으로 소멸자를 생성할 것으로 기대할 수 있다.

하지만 사용자가 생성자를 생성해야 한다. 그 이유는 책에 잘 설명되어 있다.

결론은 shared_ptr와 다르게 unique_ptr은 불완전 type(Impl)에 대해서 소멸자를 자동생성할 수 없다.

따라서 Pimpl처럼 불완전 타입을 unique_ptr에 적용하려면 사용자가 소멸자를 선언 및 정의해 줘야 한다.

소멸자를 사용자 재정의함에 따라서 move/copy 모든 생성자까지 사용자가 생성해줘야 한다.

special member function(https://chipmaker.tistory.com/entry/Modern-C-Summary-of-special-member-function-generation)을 참조하면 상세하게 정리되어 있다.

1. C++98과 동일하다.
2. raw pointer에서 smart pointer로 바꾸었다.
3. header 파일에는 생성자를 선언해야하고, 구현부(cpp)에는 정의가 필요
4. 생성자와 동일 (unique_ptr을 사용하는 효과가 전혀없다)
5. move 사용자 재정의로 copy operation(constructor, assignment operator)도 사용자 정의해야 한다.
6. 소멸자 사용자 재정의로 move operation(constructor, assignment operator)도 사용자 정의해야 한다.

C++98에서 unique_ptr을 사용하면 사용자가 해주어야 할 일이 줄어야 하는데, 차이가 없다.

raw pointer의 자원 관리 문제를 smart pointer를 통해서 Pimpl에서 확장하려면

결국 모든 생성자와 소멸자를 사용자가 해 주어야 한다점이 핵심이다.

물론 compiler가 생성하는 코드와 동일한 코드라면 모두 예제 코드처럼 default로 처리하면 된다.

 

<C++11 Pimpl 구현 코드>

// Applying the Pimpl Idiom in C++11 class Widget { public: Widget(); // <-------------------------- 3) ~Widget(); // <-------------------------- 4) // <-------------------------- 5) Widget(const Widget& rhs); Widget& operator=(const Widget& rhs); // <-------------------------- 6) Widget(Widget&& rhs); Widget& operator=(Widget&& rhs); private: struct Impl; // <-------------------------- 1) std::unique_ptr<Impl> pImpl; // <-------------------------- 2) }; // widget.cpp 파일 내부 #include "widget.h" #include "gadget.h" #include <string> #include <vector> // <-------------------------- 7) struct Widget::Impl { std::string name; std::vector<double> data; Gadget g1, g2, g3; }; // <-------------------------- 3) Widget::Widget() : pImpl( pImpl(std::make_unique<Impl>()) ) { } // <-------------------------- 4) Widget::~Widget() = default; // <-------------------------- 5) Widget::Widget(const Widget& rhs) // copy constructor : pImpl(std::make_unique<Impl>(*rhs.pImpl)) {} Widget& Widget::operator=(const Widget& rhs) // copy assignment operator { *pImpl = *rhs.pImpl; return *this; } // <-------------------------- 6) Widget::Widget(Widget&& rhs) = default; // move constructor Widget& Widget::operator=(Widget&& rhs) = default; // move assignment operator

 

5. 정리

 

cppreference에도 사용법은 잘 정리되어 있지만, 바로 보기 힘들어서 여기서 사용법만 재 정리하였다.

unique_ptr을 Pimpl Idiom에 적용할 때, 컴파일 에러상황과 고려해야 할 사항을 정리하였다.

물론 책에도 있지만 네가 다음에 보기 편하게 정리하였다.

Pimpl Idiom은 실제 unique_ptr과 연관성이 높으며, shared_ptr에 적용 예는 드물다.

shared resource에 대해서 Pimpl Idiom을 shared_ptr로 구현한다면, unique_ptr처럼 복잡하지 않다.

단순히 아래 코드처럼 생성자만 사용자가 생성해주면 된다.

소멸자를 사용자가 재정의하지 않아서 나머지 special member function은 컴파일러 모두 자동생성하기

때문이다.   

 

class Widget { public: Widget(); // <-------------------------- 3) private: struct Impl; // <-------------------------- 1) std::shared_ptr<Impl> pImpl; // <-------------------------- 2) }; // widget.cpp 파일 내부 #include "widget.h" #include "gadget.h" #include <string> #include <vector> // <-------------------------- 4) struct Widget::Impl { std::string name; std::vector<double> data; Gadget g1, g2, g3; }; // <-------------------------- 3) Widget::Widget() : pImpl( pImpl(std::make_shared<Impl>()) ) { }