CHIPMAKER

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>()) ) { }

1. special member function이란?

아래 6가지 member function에 대해서 컴파일러가 자동생성해주는 것을 말함. (by Scott Meyers)

아래 6가지 모든 함수를 사용자가 생성하지 않으면, 컴파일러가 자동으로 모두 생성해준다. 

하지만 경우에 따라서 사용자가 아래 6가지 함수 중에 하나 이상을 선언하는 경우가 발생할 수 있다.

특히 move는 성능과 직결되는 것으로 move관점에서 핵심만 정리한다.

• default constructor (기본생성자)
• copy constructor (복사생성자)
• copy assignment operator (복사대입연산자)
• move constructor (이동생성자)
• move assignment operator (이동대입연산자)
• destructor (소멸자)

2. move 자동생성 조건

move가 자동생성되기 위해서는 아래 세가지 조건이 모두 만족되어야 한다.

• No copy operations are declared in the class
• No move operations are declared in the class
• No destructor is declared in the class.

하지만 위의 세가지 조건을 모두 만족시키기 어려운 상황이 크게 두 가지 존재한다.

• class내에 raw pointer 기반 resource 관리 시
  • raw pointer는 모두 삭제하고, STL container 기반으로 코드 수정해야 한다.
• 클래스가 상속관계에 있을 경우
  • 해당 경우에 대해서 아래에서 상세하게 살펴본다.

3. move 자동생성이 안되는 경우 - class inherit condition

class 상속관계에서는 상위(부모) class의 desctructor는 virtual로 사용자가 선언해야 한다.

이런 제약 사항이 move의 자동생성 조건을 만족시킬 수 없어서 move가 자동생성되지 않는다. 

이로 인해 class 설계자가 고려해야 할 사항들에 대해서 정리하였다.

1. class 설계자는 move operation들을 생성해야한다.
   • 사용자 desctructor의 생성은 move operation이 자동생성되지 않기 때문
2. class 설계자는 copy operation들을 생성해야 한다
   • 사용자가 move operation들을 생성하면, copy operation들은 제거되거나 자동생성되지 않기 때문
   • copy operation 자동생성 조건은 따로 정리하지 않았지만, 이 정도만 기억하면 될 것으로 보인다.
3. class 설계자는 default 생성자를 사용해야 한다면, 생성해야 한다.
   • 사용자가 move operation를 생성하면 모든 생성자가 제거되거나 자동생성되지 않기 때문

결론적으로 class가 상속관계에 있는 경우, 6가지 special member function들에 대해서 잘 설계를 해야한다.

만약 단순히 virtual 때문에 destructor를 사용자가 선언해야하는 조건이라면, 컴파일러가 자동생성한 것과 동일하게 생성해 달라고 명시하면 된다.

만약 사용자가 컴파일러가 자동생성하는 코드와 다르다면 모두 사용자가 생성해줘야 한다.

class CBase { public: // 1. class 상속관계로 destructor를 virtual로 사용자가 생성해야 한다. // 사용자가 필요한 destructor가 컴파일러가 생성하는 코드와 차이가 없다면, // 컴파일러에게 생성해 줄 것을 default를 통해서 명시적으로 지시할 수 있다. virtual ~CBase() = default; // 2. 사용자의 destructor의 생성으로, move가 자동생성 안되니 // 사용자가 move operation들을 생성한다. CBase(CBase &&) = default; // default의 의미는 destrutor와 동일 CBase& operator=(CBase&&) = default; // 3. 사용자의 move 생성으로, copy가 자동생성 안되거나 제거된다. // 사용자가 copy operation들을 생성한다. CBase(const CBase &) = default; CBase& operator=(const CBase&) = default; // 4. move operation을 사용자가 생성하여, copy operation들은 모두 제거되었다. // 따라서 default constructor의 사용이 필요하다면, 아래처럼 생성해야 한다. CBase() = default; }; class CChild : public CBase { // CChild의 destructor는 컴파일러가 virtual destructor를 자동생성한다. // 따라서 나머지 special member function도 사용자가 생성하지 않는한 모두 자동생성된다. };

4. template 사용의 경우

Effective Modern C++ 책에서는 17장 마지막에 애매하게 설명하고 정리하였다.

아래 코드 테스트를 통해서, template라고 해서 특별히 위의 생성 규칙과 다른 점은 없었다.

move에 대해서 위의 규칙을 잘 이해하고 있다면, template에서도 동일하게 적용된다. 

#include <iostream> #include <memory> template<typename T> class A { public: // 4. 사용자가 move operation을 생성하여, default constructor도 // 자동생성되지 않아서, 사용자가 생성해줘야 한다. A() { std::cout << "Car() .. " << std::endl; } // copy operations // 3. 사용자가 move를 생성하여서, copy operation은 자동생성(implicity)되지 않는다. // 2. 사용자가 destructor를 생성하여 move는 자동생성되지 않아서 // 테스트를 위해서 move를 사용자가 default로 생성하였다. A(A &&) = default; A& operator=(A&&) = default; // 1. 사용자가 destructor를 생성하였다. ~A() { std::cout << "~A() .. " << std::endl; } void setCount(T a) { count = a; } T getCount() { return count; } private: T count; }; int main() { A<int> a1; a1.setCount(10); // 아래 코드는 copy constructor가 존재하지 않아서 다음과 같은 error를 발생시킨다. // error: use of deleted function 'constexpr A<int>::A(const A<int>&)' A<int> a2(a1); a2.getCount(); return 0; }

5. 정리

special member function은 컴파일러가 자동생성하는 함수들이다.

자동생성되는 함수들은 클래스의 public 영역에 inline으로 생성된다.

special member function들 중에 사용자 생성으로 자동생성되지 않는 규칙이 존재한다.

다른 규칙은 외우지 않아도 빌드 중에 모두 수정할 수 있다.

하지만 move의 특성상 move는 copy로 대체가 가능하여 move의 자동생성조건을

명확히 이해하지 않는다면, 원하지 않게 copy로 동작하여 성능저하의 문제를 겪을 수 있다.

이런 관점에서 move 관점에서 상세하게 살펴보았다.

1. reference collapsing 이란?

type deduction 과정에서 유도된 reference와 원본 expression이 가지고 있는 reference가 충돌하는 것을 말한다.

위의 문장으로는 어떤 의미인지 마음에 와 닿지 않는다. 예제를 하나 살펴보면

auto& rx = x;

예제가 이상하기는 하지만 x 가 int lvalue reference라고 한다면,

auto -> int&로 유도된다.

auto를 int&로 치환하면, 아래와 같고 결국 reference와 reference가 충돌하는 상황이 발생한다.

int& & rx = x;

2. reference collapsing 세가지 유형

reference collapsing이 발생하는 상황은 크게 아래 세가지 경우에 해당한다.

• template
• auto
• decltype

3. reference collaping 처리 규칙

"lvalue reference 이면 최종 결과는 lvalue reference, rvalue reference이면 최종 결과는 rvalue reference"

4. perfect forwarding

reference collapsing 규칙은 perfect forwarding 이해하는데 핵심 규칙으로 보인다.

perfect forward의 핵심인 forward 기술을 가지고 reference collasping 적용 규칙을 살펴본다.

// c++11 버전 std::forward<T> 개략적인 구현 코드 template<typename T> T&& forward(typename remove_reference<T>::type& param) { return static_cast<T&&>(param); } // c++14 버전 std::forward<T> 개략적인 구현 코드 template<typename T> T&& forward(remove_referenc_t<T>& param) { return static_cast<T&&>(param); } template<typename T> void f(T&& param) { // ... somefunction(std::forward<T>(param)); } class Widget{}; // 아래 결과는 ? int main() { // 1. lvalue Widget w; f(w); // 2. 임시객체 Widget(), rvalue 전달 f(Widget()); }

아래 표에 main함수에서 예시한 예제에 대해서 reference collapsing 과정을 기술하였다.

표를 통해서 reference collapsing 규칙을 이해하는데 어렵지 않을 것이다.

reference collasing설명에서 perfect forwarding이라는 머나먼 주제로 이동한 느낌이지만

reference collasping 주제를 통해서 perfect forwarding 기술이 무엇인지 알 수 있다.

perfect forwarding은 somefunction까지 매개변수가 전달되는 과정에서 원래 f 함수에 전달된

함수의 매개변수 reference 속성이 변경되지 않는 기술로 요약할 수 있다.

5. reference collasing 추가 고려 사항

아래 코드는 책에 존재하는 코드로

RvalueRefToT 변수는 Rvalue Reference로 사용을 위해서 typedef한 경우라고하면,

실제 type deduction 과정에서 reference collasping 과정을 거치고 나면

RvalueRefToT 변수는 lvalue reference로 정의되어진다.

reference collasping에 대한 정확한 이해를 바탕으로 구현이 필요함을 보여주는 예제이다. 

template<typename T> class Widget { public: typedef T&& RvalueRefToT; // ... }; // Case Widget<int&> w; // Case의 실제 type deduction // reference collasing : typedef int& && RvalueRefToT; // final result : typedef int& RvalueRefToT;

5. 정리

reference collasping은 perfect forwarding을 이해하는데 핵심 요소로 보여진다.

c++11을 정리하다보면 각자 다른 주제인 것 같지만, 결국 모두 상호 엮여있어서

다른 것을 이해하는데 각 요소의 정확한 이해가 필요해 보인다. 

1. decltype type deduction

decltype의 사용형식은 다음과 같다.

• decltype(expr) n

expr의 표현식의 따라서 type deduction은 크게 두가지로 분류될 수 있다.

• expr에 연산자가 존재하지 않을 경우의 type deduction
• expr에 연산자가 존재할 경우의 type deduction

2. expr에 연산자가 존재하지 않는 경우

expr에 연산자가 존재하지 않으면, expr과 동일한 type으로 변환된다.

const int i = 0; decltype(i) n; // const int 과 동일 bool f(const Widget& w); decltype(w) n; // const Widget& 과 동일 decltype(f) n; // bool(const Widget&) 과 동일

3. expr에 연산자가 포함되어 있는 경우

expr에 연산자가 존재하면, expr이 lvalue냐 또는 rvalue냐를 식별해야 한다.

lvalue일 경우, reference가 붙지만 rvalue이면 reference는 붙이지 않는다.

int n = 10; int *p = &n; decltype(p) a; // no operation in expr, decltype(p)는 int* decltype(*p) a; // *p : lvalue, decltype(*p)는 int& int x[3] = {1, 2, 3} decltype(x[0]) a; // x[0] : lvalue, lvalue, decltype(x[0])는 int& vector<int> v {1, 2, 3}; decltype(v[0]) a; // v[0] : lvalue, lvalue, decltype(v[0])는 int& // rvalue case decltype(n + n) a; // n + n 는 rvalue, decltype(n + n)는 int decltype(n++) a; // n++ 는 rvalue, decltype(n++)는 int

4. decltype(auto) 정리

c++14부터 지원하는 문법이다. 정확한 의미는 다음과 같다.

• auto
  • type deduction이 필요하다.
• decltype
  • type deduction rule은 decltype의 rule을 따른다.

결론적으로 type deduction을 수행해야 하는데, 이 때 decltype의 rule을 따른다의 의미이다.

이 형식이 어디에 사용되느냐는 함수의 return type과 관련이 있다.

Effective Modern C++의 추가 내용들은 perfact forwarding과 관련된 부분이 대부분이라서

간단히 왜 이런 구문이 나왔는지 측면에서 정리하고 넘어간다.

// c++11 코드 template<typename C, typename I> auto authAndAccess(C& c, I i) -> decltype(c[i]) { return c[i]; } // 위와 동일한 c++14 코드 template<typename C, typename I> auto authAndAccess(C& c, I i) { return c[i]; }

위의 코드에서 함수의 return을 auto로 받고 있다. auto의 type deduction에서 기술하였듯이

함수의 return type의 auto의 경우 template의 type deduction 규칙을 따른다.

이 경우 return되는 c[i]는 C&이지만 auto의 type deduction이 template 규칙을 따르기 때문에

최종적으로 return type은 C가 된다.

이 경우 문제는 다음과 같은 코드에서 문제가 발생할 수 있다.

std::deque<int> d;

authAndAccess(d, 5) = 10;

authAndAccess()의 return type은 rvalue를 return하고 있어서 대입 시 에러가 발생한다.

여기서 해결책은 무엇인가? c++11의 경우에는 perfact forwarding에 대한 지식이 필요하므로

c++14 기준으로 해결책은 decltype(auto)로 return type을 바꾸는 것이다.

decltype(auto)의 의미에 따라서 C&로 return type이 결정된다.

// authAndAccess의 return type을 C&로 받기 위한 해결책 template<typename C, typename I> decltype(auto) authAndAccess(C& c, I i) { return c[i]; }

5. 정리

decltype의 type deduction은 expr의 표현식의 연산자 유무에 따라서 그 동작에 차이가 있다.

이 부분을 주의해서 사용하는 것이 핵심이고, decltype(auto)는 양념정도로 알아두면 좋을 듯 하다.

1. auto type deduction

auto와 template의 type deduction 과정은 braced initalizer에 대한 type deduction을 제외하고는 동일하다.

braced initalizer에 대한 auto와 template의 기본 동작은 아래와 같다.

• auto
  • std::initializer_list로 type deduction 된다.
• template
  • std::initializer_list로 type deduction을 지원하지 않는다.

auto에 대한 위의 braced initalizer 기본 동작이 아래와 같은 경우에 또 예외 동작을 수행한다.

• auto가 함수의 return type으로 사용 시
  • template처럼 동작한다. 즉 std::initializer_list로 type deduction되지 않는다.
• lambda의 매개변수에 사용 시
  • template처럼 동작한다.

다음절에서 위에서 기술한 기본동작과 예외 동작에 대해서 상세하게 알아본다.

2. auto 기본동작 (template와 동일)

3. auto 와 template의 braced intializer와의 기본동작

서두에 기술한 auto와 template의 braced initializer에 대한 동작 차이점을 보여주는 예제이다.

// braced intializer가 아닌 경우, auto와 template type deduction은 동일 auto x1 = 27; // int x1 = 27; auto x2(27); // int x2 = 27; // braced intializer의 경우, auto는 std::initializer_list로 type deduction, template는 지원하지 않음. auto x3 = {27}; // std::initializer_list<int> x3 = {27}; auto x4{x27}; // std::initializer_list<int> x4 = {27}; template<typename T> void f(T param) f({11, 23, 9}); // compile error, template에서는 중괄호 초기화 리스트를 inializer_list로 변환하는 것을 지원하지 않는다 // compile error를 잡기 위해서는 template의 형태가 void f(std::initializer_list<T> param)로 바꿔야 한다. // 아래 경우는 auto의 std::intializer_list로 변환 과정과 관련이 있고, 변환 과정은 다음과 같은 순서로 진행 // 1. { } -> std::intializer_list<T> 로 변환 // 2. T를 결정, T는 { }안의 값을 기반으로 결정 // 아래는 int와 double이 썩어 있는 구조라서 T를 결정할 수 없어서 compile error 발생 auto x5 = {1, 2, 3.0}; // compile error

4. braced intializer와 auto의 기본동작의 예외 케이스

서두에 기술한 auto와 template의 braced initializer에 대한 동작 차이점을 보여주는 예제이다.

// Effective Modern C++ 코드 인용 // 1. auto 가 function return type으로 사용될 때 // auto 는 template type deduction처럼 동작한다. 따라서 std::initializer_list로 type deduction되지 않는다 auto createInitList() { return {1, 2, 3}; // compile error } // 1. auto 가 lambda parameter type으로 사용될 때 // auto 는 template type deduction처럼 동작한다. 따라서 std::initializer_list로 type deduction되지 않는다 std::vector<int> v; auto resetV = [&v](const auto& newValue) { v = newValue;}; resetV({1, 2, 3});

5. 정리

auto의 type deduction 동작은 template와 동일하다. 다만 braced initializer와의 동작에 대해서는

auto와 template간의 차이가 있고, 그 경우에 대해서 정리했다.

1. Type Deduction History

1) C++98

• Template Type Deduction

2) C++11

• Template Type Deduction 변경
• auto와 decltype 추가

3) C++ 14

• decltype(auto)가 가능

C++11에서 Template Type Deduction은 auto와 동일하다. 

2. Template Type Deduction

Effective Modern C++ 기준으로 정리하였으나, 내가 이해한 방식되로 정리하였다. 크게 세가지 관점에서 접근할 수 있다.

2.1. ParamType이 T인 경우 - pass by value

template<typename T> void f(T param); int x = 27; const int cx = x; const int& rx = x; const char* const ptr = "hellow";

f(expr)에서 expr로 전달되는 원본객체의 const, volatile, reference, pointer를 무시한다.

이 상태에서 T의 타입을 결정하고, expr의 pattern-matching 방식으로 최종 type을 결정한다.

2.2. ParamType이 참조 또는 포인터인 경우

아래 크게 세가지의 경우로 나누어서 정리하였지만, type을 최종 결정하는 방식은

동일한 방식으로 진행된다. 따라서 ParamType을 조금 변경하더라도 동일하게 유추가능하다.

1) T&인 경우

template<typename T> void f(T& param); int x = 27; const int cx = x; const int& rx = x;

f(expr)에서 expr로 전달되는 원본 객체의 참조를 무시한다.

이 상태에서 T type과 expr과의 pattern-matching 방식으로 최종 type을 결정한다.

2) const T&인 경우

template<typename T> void f(const T& param); int x = 27; const int cx = x; const int& rx = x;

f(expr)에서 expr로 전달되는 원본 객체의 상수성과 참조는 무시한다.

이 상태에서 T type과 expr과의 pattern-matching 방식으로 최종 type을 결정한다.

3) ParamType이 포인터인 경우

template<typename T> void f(const T*; param); int x = 27; const int *px = &x;

f(expr)에서 expr로 전달되는 원본 객체의 포인터는 무시한다.

이 상태에서 T type과 expr과의 pattern-matching 방식으로 최종 type을 결정한다.

2.3. ParamType이 foward reference 일 경우 (책에서는 universal reference)

template<typename T> void f(T&&; param); int x = 27; const int cx = x; const int& rx = x;

forward reference의 경우에는 expr로 전달되는 객체가 lvalue인지 rvalue인지를 통해서

T type을 결정하고 param type과는 reference collapsing(책, Item28)을 통해서 최종 타입이 결정된다.

3. 추가적인 Type Deduction

추가적으로 살펴보아야 할 type deduction은 배열과 함수이다. 이는 원래의 객체의 type이

type deduction 과정 중에 포인터로 바뀌는 현상이 존재하여 이를 잘 구분애서 사용해야 한다.

3.1.  배열 Type Deduction

배열 type을 갖는 함수 매개변수는 존재하지 않는다.

따라서 T를 통한 type deduction인 f(name)의 경우는 전통적인 C표준에 따라서

const char[13]은 const char*로 변환된다.

다만, 배열 type을 그대로 사용하기 위해서는 T&으로 함수템플릿을 정의해야 한다.

template<typename T> // name type : const char[13] const char name[] = "heesoon.kim"; // 1. T : pass by value template<typename T> void f(T param); f(name); // T : const char * // 2. T& : reference template<typename T> void g(T& param) g(name); // T : const char(&)[13]

3.2.  함수 Type Deduction

위의 배열에서 적용된 타입 변경 방식은 함수에도 동일하게 적용된다.

template<typename T> void function(int, double); // 1. T case template<typename T> void f(T param); f(function); // T : void(*)(int, double) // 2. T& case template<typename T> void g(T& param); g(function); // T : void(&)(int, double)

4. 정리

type deduction에서 pass by value는 expr로 넘겨오는 것은 값으로 복사한다는 측면에서 상수성과 참조성은 무시된다.

reference는 expr로 넘어오는 과정에서 원 객체의 reference를 무시하고 타입 유도를 진행한다.

다만 forward reference는 forward reference 특성을 반영하여 expr로 넘어오는 객체가 lvalue인지 rvalue인지가

타입 유도과정에 적용된다.

일반적인 타입 유도뿐만 아니라 전통적인 C에 뿌리를 두고 있는 타입 유도 과정도 같이 고민을 해야 하며,

expr로 넘겨지는 원 객체의 타입을 유지하려면 참조 정의해야 한다.

1. 목적

Object Generator 정의는 다음과 같다. 함수 탬플릿으로 클래스 탬플릿의 객체를 생성하는 기술. 정의만으로는 이 기술이 얼마나 멋진지 와 닿지 않는다. 아래 소스 코드를 이용해서 설명을 진행하도록 한다.

2. 소스코드

아래 코드의 예제는 make_tuple의 동작을 알아보기 위해서 make_tuple과 유사 동작을 하는 xmake_tuple을 만들어 보았다.

#include <iostream> #include <tuple> // helper function to print a tuple of any size template<class Tuple, std::size_t N> struct TuplePrinter { static void print(const Tuple& t) { TuplePrinter<Tuple, N-1>::print(t); std::cout << ", " << std::get<N-1>(t); } }; template<class Tuple> struct TuplePrinter<Tuple, 1>{ static void print(const Tuple& t) { std::cout << std::get<0>(t); } }; template<class... Args> void print(const std::tuple<Args...>& t) { std::cout << "("; TuplePrinter<decltype(t), sizeof...(Args)>::print(t); std::cout << ")\n"; } // end helper function template<typename T1, typename T2, typename T3> std::tuple<T1, T2, T3> xmake_tuple(T1 a1, T2 a2, T3 a3) { return std::tuple<T1, T2, T3>(a1, a2, a3); } int main() { std::tuple<int, double, char> t1(3, 3.4, 'a'); std::tuple<int, double, char> t2 = xmake_tuple(4, 4.5, 'b'); std::cout << "Value-initialized: "; print(t1); std::cout << "Value-initialized: "; print(t2); return 0; }

tuple을 print하는 help function은 일단 무시한다. 우리가 tuple 객체를 생성하는 방법은 아래와 같이 두가지 방식이 있다. 일반 클래스 객체를 선언하기 위한 방법과 동일하게 tuple template에 type 정보를 주고 각 type에 해당하는 argument를 주는 방식이다. 두 번째 방법은 tuple에서 제공하는 make_tuple() 함수를 이용해서 tuple 객체를 생성하는 것이다.

그럼 첫번째 방식과 두 번째 방식의 차이는 무엇인가? 여러가지 차이가 있지만 여기서는 Object Generator 관점에서 살펴본다.

두 번째 방식은 함수 템플릿은 암시적/명시적 객체 인스턴스화가 가능한 반면, 클래스 탬플릿은 명시적인 객체 인스턴스만 가능하다. C++17부터는 클래스 탬플릿도 암시적 객체 인스턴스화가 가능하지만, 이는 논외로 한다.

make_tuple() 함수를 통해서 명시적 Type을 지정하지 않고 Argument로 전달된 객체의 타입으로 tuple의 객체 인스턴스화가 가능하다. 즉 함수 탬플릿의 암시적인 객체 생성 기법을 이용해서 클래스의 명시적 객체 생성이 가능한 것이다.

std::tuple<int, double, char> t1(3, 3.4, 'a'); std::tuple<int, double, char> t2 = make_tuple(4, 4.5, 'b');

3. 결론

C++ 표준에는 함수 탬플릿의 암시적 객체 생성 기법을 통해서 클래스 탬플릿의 명시적 객체 생성을 할 수 있는 함수들을 많이 제공하고 있다. 이는 Object Generator 기법에 그 근간이 있다.

1. 목적

이제 마무리 단계에 왔다. 바로 work의 사용법이다. work는 io_service start 전에 post()에 기술된 handler함수가 먼저 종료되는 상황에서 io_service start를 차 후에 호출하더라도 실제 post의 핸들러 함수는 돌지 않는다. 이를 방지 하기 위해서 항상 block되어 돌도록 하기 위해서 사용한다.

2. 코드 설명

아래 코드에서 현재 상태로 코드를 돌리면 아무 동작을 하지 않는다. 비동기 동작과 유사한 동작을 위해서 post에 전달하는 방식을 thread로 변경하였다. 이 부분이 앞의 예제와 변경된 사항이다.

#include <iostream> #include <boost/asio.hpp> #include <boost/smart_ptr.hpp> #include <boost/bind.hpp> #include <boost/thread.hpp> #include <boost/chrono.hpp> #include <boost/thread/scoped_thread.hpp> #include <boost/lexical_cast.hpp> class CTest { public : CTest() : service(), strand(service) //CTest() : service(), strand(service), work(service) { std::cout << __FUNCTION__ << std::endl; } virtual ~CTest() { std::cout << __FUNCTION__ << std::endl; } void do_print(int x) { boost::function<void(int)> handler = [&](int x) { std::string curTrId = boost::lexical_cast<std::string>(boost::this_thread::get_id()); for(int i = 0; i < x; i++) { std::printf("[ %d -> current Thread Id : %s] \n", i, curTrId.c_str()); boost::this_thread::sleep_for(boost::chrono::milliseconds(100)); } }; service.post(strand.wrap(boost::bind(handler, x))); } void start(void) { std::cout << __FUNCTION__ << ", " << __LINE__ << std::endl; for(int i = 0; i < 2; i++) { print_threads.create_thread(boost::bind(&CTest::do_print, this, 100)); } for(int i = 0; i < 2; i++) { io_threads.create_thread(boost::bind(&boost::asio::io_service::run, &service)); } } void stop(void) { service.stop(); print_threads.join_all(); io_threads.join_all(); service.reset(); } private : boost::asio::io_service service; //boost::asio::io_service::work work; boost::asio::io_service::strand strand; boost::thread_group io_threads; boost::thread_group print_threads; }; int main(int argc, char* argv[]) { CTest test; test.start(); while(1) { char option; std::cout << "... in while loop ..." << std::endl; std::cin.get(option); if(option == 'x') { break; } } test.stop(); std::cout << "... end of main ..." << std::endl; return 0; }

3. 정리

1. 목적

boost asio 정리 -4는 정리 3에서 multi-thread에서 동일 handler로 처리될 경우 공유 자원에 대한 접근을 제어하기 위해서 lock대신 boost strand를 적용한 예제이다. strand는 handler 처리에 대해서 순차적인 처리를 보장해서 공유 자원 접근에 대한 제어를 lock 객체와 유사하게 해 준다.

2. 코드 설명

post()함수에 strand.wrap()함수로 handler를 한번 wrapping해 주면 strand 동작을 위해서 해 줄 일은 끝난다. 하지만 여기서 눈여겨 봐야할 부분이 strand1과 strand2 두 개의 객체를 선언하였는데 strand1로만 post함수를 wrapping했을 경우와 post 함수를 각각 strand의 wrap함수로 했을 때 동작은 다르다. 결론은 strand 하나의 객체로 wrapping해야지만 진정한 동기를 맞출 수 있다.

아래 코드는 start 함수의 strand wapping 하는 부분의 일 부분만 캡쳐한 것이고, 첫번째로 같은 strand 객체로 wrapping 했을 때 코드와 결과이다.

void start(void) { std::cout << __FUNCTION__ << ", " << __LINE__ << std::endl; #if 1 service.post(strand1.wrap(boost::bind(&CTest::do_print, this, 5))); service.post(strand1.wrap(boost::bind(&CTest::do_print, this, 5))); #else service.post(strand1.wrap(boost::bind(&CTest::do_print, this, 5))); service.post(strand2.wrap(boost::bind(&CTest::do_print, this, 5))); #endif for(int i = 0; i < 2; i++) { io_threads.create_thread(boost::bind(&boost::asio::io_service::run, &service)); } }

결과: 첫번째 post에 할당된 handler가 모두 완료되고, 두번째 handler가 순차적으로 돌고 있다.

hskim@hskim-VirtualBox:~/test/test_project/test1$ ./test CTest start, 352 ... in while loop ... [ 0 -> current Thread Id : 7f8ce1e7a700] [ 1 -> current Thread Id : 7f8ce1e7a700] [ 2 -> current Thread Id : 7f8ce1e7a700] [ 3 -> current Thread Id : 7f8ce1e7a700] [ 4 -> current Thread Id : 7f8ce1e7a700] [ 0 -> current Thread Id : 7f8ce1e7a700] [ 1 -> current Thread Id : 7f8ce1e7a700] [ 2 -> current Thread Id : 7f8ce1e7a700] [ 3 -> current Thread Id : 7f8ce1e7a700] [ 4 -> current Thread Id : 7f8ce1e7a700]

아래 코드는 post 함수에 서로 다른 strand 변수를 사용했을 때의 코드 조각이다.

void start(void) { std::cout << __FUNCTION__ << ", " << __LINE__ << std::endl; #if 0 service.post(strand1.wrap(boost::bind(&CTest::do_print, this, 5))); service.post(strand1.wrap(boost::bind(&CTest::do_print, this, 5))); #else service.post(strand1.wrap(boost::bind(&CTest::do_print, this, 5))); service.post(strand2.wrap(boost::bind(&CTest::do_print, this, 5))); #endif for(int i = 0; i < 2; i++) { io_threads.create_thread(boost::bind(&boost::asio::io_service::run, &service)); } }

결과: 서로 경쟁적으로 돌고 있음을 알 수 있다. 실행 결과를 보기 좋게 하기 위해서 루프는 5번만 돌렸다.

hskim@hskim-VirtualBox:~/test/test_project/test1$ ./test CTest start, 352 ... in while loop ... [ 0 -> current Thread Id : 7f2b3d0b2700] [ 0 -> current Thread Id : 7f2b3d8b3700] [ 1 -> current Thread Id : 7f2b3d0b2700] [ 1 -> current Thread Id : 7f2b3d8b3700] [ 2 -> current Thread Id : 7f2b3d0b2700] [ 2 -> current Thread Id : 7f2b3d8b3700] [ 3 -> current Thread Id : 7f2b3d0b2700] [ 3 -> current Thread Id : 7f2b3d8b3700] [ 4 -> current Thread Id : 7f2b3d0b2700] [ 4 -> current Thread Id : 7f2b3d8b3700]

3. 전체 코드

#include <iostream> #include <boost/asio.hpp> #include <boost/smart_ptr.hpp> #include <boost/bind.hpp> #include <boost/thread.hpp> #include <boost/chrono.hpp> #include <boost/thread/scoped_thread.hpp> #include <boost/lexical_cast.hpp> class CTest { public : CTest() : service(), strand1(service), strand2(service) { std::cout << __FUNCTION__ << std::endl; } virtual ~CTest() { std::cout << __FUNCTION__ << std::endl; } void do_print(int x) { std::string curTrId = boost::lexical_cast<std::string>(boost::this_thread::get_id()); for(int i = 0; i < x; i++) { std::printf("[ %d -> current Thread Id : %s] \n", i, curTrId.c_str()); boost::this_thread::sleep_for(boost::chrono::milliseconds(100)); } } void start(void) { std::cout << __FUNCTION__ << ", " << __LINE__ << std::endl; service.post(strand1.wrap(boost::bind(&CTest::do_print, this, 5))); service.post(strand1.wrap(boost::bind(&CTest::do_print, this, 5))); for(int i = 0; i < 2; i++) { io_threads.create_thread(boost::bind(&boost::asio::io_service::run, &service)); } } void stop(void) { service.stop(); io_threads.join_all(); service.reset(); } private : boost::asio::io_service service; boost::thread_group io_threads; boost::asio::io_service::strand strand1; boost::asio::io_service::strand strand2; }; int main(int argc, char* argv[]) { CTest test; test.start(); while(1) { char option; std::cout << "... in while loop ..." << std::endl; std::cin.get(option); if(option == 'x') { break; } } test.stop(); std::cout << "... end of main ..." << std::endl; return 0; }

4. 정리

1. 목적

boost asio 정리 -2는 io_service 처리를 single thread로 하였다. 여기서는 mulit-thread처리 방식에 대해서 알아본다. 하지만 내용은 매우 간단하다. io_service thread를 여러개 만들면 된다.

2. 코드 설명

기존의 코드와 형태가 좀 바꿨다. boost thread group를 통해서 io_service를 2개 생성함을 볼 수 있다. (boost::thread_group io_threads). 결론적으로 io_service에 대한 처리를 multi-thread로 처리하는 것이다. 또한 post() 함수를 통해서 2개의 handler함수를 추가함을 알 수 있다.

#include <iostream> #include <boost/asio.hpp> #include <boost/smart_ptr.hpp> #include <boost/bind.hpp> #include <boost/thread.hpp> #include <boost/chrono.hpp> #include <boost/thread/scoped_thread.hpp> #include <boost/lexical_cast.hpp> class CTest { public : CTest() : service() { std::cout << __FUNCTION__ << std::endl; } virtual ~CTest() { std::cout << __FUNCTION__ << std::endl; } void do_print(int x) { std::string curTrId = boost::lexical_cast<std::string>(boost::this_thread::get_id()); for(int i = 0; i < x; i++) { std::printf("[ %d -> current Thread Id : %s] \n", i, curTrId.c_str()); boost::this_thread::sleep_for(boost::chrono::milliseconds(100)); } } void start(void) { std::cout << __FUNCTION__ << ", " << __LINE__ << std::endl; for(int i = 0; i < 2; i++) { service.post(boost::bind(&CTest::do_print, this, 100)); } for(int i = 0; i < 2; i++) { io_threads.create_thread(boost::bind(&boost::asio::io_service::run, &service)); } } void stop(void) { service.stop(); io_threads.join_all(); service.reset(); } private : boost::asio::io_service service; boost::thread_group io_threads; }; int main(int argc, char* argv[]) { CTest test; test.start(); while(1) { char option; std::cout << "... in while loop ..." << std::endl; std::cin.get(option); if(option == 'x') { break; } } test.stop(); std::cout << "... end of main ..." << std::endl; return 0; }

3. 실행결과

기존 정리 -2와 유사하지만 차이는 io_service를 multi-thread로 처리한 것이고, 출력 결과도 post에 정의된 handler가 하나 모두 완료하고 다른 것이 순차적으로 되는 것이 아니라 random하게 실행된다. 여기서는 loop가 작아서 자세히 보이지 않지만 loop를 늘리면 random하게 보일 것이다. thread Id에 주목해보면 서로 번갈아 가면서 동작하는 것을 알 수 있다.

hskim@hskim-VirtualBox:~/test/test_project/test1$ ./test CTest start, 358 ... in while loop ... [ 0 -> current Thread Id : 7f6118fa3700] [ 0 -> current Thread Id : 7f61197a4700] [ 1 -> current Thread Id : 7f6118fa3700] [ 1 -> current Thread Id : 7f61197a4700] [ 2 -> current Thread Id : 7f6118fa3700] [ 2 -> current Thread Id : 7f61197a4700] [ 3 -> current Thread Id : 7f6118fa3700] [ 3 -> current Thread Id : 7f61197a4700] [ 4 -> current Thread Id : 7f6118fa3700] [ 4 -> current Thread Id : 7f61197a4700] [ 5 -> current Thread Id : 7f6118fa3700] [ 5 -> current Thread Id : 7f61197a4700] [ 6 -> current Thread Id : 7f6118fa3700] [ 6 -> current Thread Id : 7f61197a4700] [ 7 -> current Thread Id : 7f6118fa3700] [ 7 -> current Thread Id : 7f61197a4700] [ 8 -> current Thread Id : 7f6118fa3700] [ 8 -> current Thread Id : 7f61197a4700] [ 9 -> current Thread Id : 7f61197a4700] [ 9 -> current Thread Id : 7f6118fa3700] [ 10 -> current Thread Id : 7f61197a4700]

4. 정리