<div id="readability-page-1" class="page"><div>
                <div id="SE-c14cbcba-4d7f-461d-8cfe-f96cc7b64416">
                                    <p id="SE-0796bbbb-5116-4a1d-be17-eabb1b41643c"><span id="SE-ff211c91-42c9-40de-be30-0f384065156c">레이몬드 챈이 블로그에 포스팅한 "How do I make an expression non-movable? What’s the opposite of std::move?" 아티클을 편역하였습니다. 이 글을 통해 std::move에 대한 기본기를 점검하고 이동 시맨틱을 사용하고 싶지 않을 때 유용한 방법을 알 수 있습니다.</span></p><p id="SE-767302a1-7c26-44c4-a5c5-8f3e0e8f6aad"><span id="SE-b30a2a37-e403-4c53-96f2-459087db888b">​</span></p><p id="SE-9d4bd5fd-bec8-44dc-881a-55a4a46895df"><span id="SE-9ae0b162-959b-4770-8363-d8a3d3b46cd8">std::move는 C++ 11에서 도입된 기능으로, 객체를 이동 시맨틱(move semantics) 처리합니다. 워낙 코드 최적화로 얻을 수 있는 성능의 이익이 많기도 하고, 심지어 C++ 11/17에서는 생성자 호출을 생략해 명시적으로 복사 제거(Copy elision)를 보장하는 규칙도 생겼으며, std::move의 효용성이 그리 없는 경우(모던 이펙티브 C++ 참고)도 다양하고 많아 std::move를 사용한다고 해서 반드시 객체의 데이터가 이동하는 로직이 수행되는 것은 아닙니다.</span></p><p id="SE-9319f1bb-5451-4c8d-b16a-9b6f497aa38b"><span id="SE-f76de7c6-07eb-45a5-9eb6-31be0172853b">하지만, 이동 시맨틱으로 처리하도록 컴파일러에게 전달하여 객체 소유권을 다른 객체로 이전하는 방법으로 성능 향상을 시도합니다. std::move를 사용함으로써, (1) 깊은 복사를 방지해 성능 향상을 이끌어 내고 (2) 효율적으로 메모리를 관리할 수 있으며 (3) 코드상으로 소유권이 명확해 리소스를 관리하기에 용이한 장점이 있습니다.</span></p><p id="SE-1f2d36dc-f63a-48e2-a3be-2bb2fd62b9ae"><span id="SE-3a59dedd-7544-437f-b10a-db444b71d71e">​</span></p><p id="SE-53db2139-fa69-4a15-804e-1ac951a8971d"><span id="SE-9218282a-a453-45d9-82d3-ef32b3364ddd">아래는 일반적인 복사와 이동의 차이점을 보여줍니다.</span></p>
                            </div>                <div id="SE-52047890-b2c6-460d-b169-21d31237561c">
                                    <p>#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;utility&gt; // std::move
#include &lt;iostream&gt;

class Foo {
public:
  Foo() { std::cout &lt;&lt; "생성자" &lt;&lt; std::endl; }
  ~Foo() { std::cout &lt;&lt; "소멸자" &lt;&lt; std::endl; }
  Foo(Foo&amp;&amp; other) noexcept { std::cout &lt;&lt; "생성자(이동)" &lt;&lt; std::endl; }
  Foo(const Foo&amp;) { std::cout &lt;&lt; "생성자(복사)" &lt;&lt; std::endl; }

  // 복사 할당 연산자
  Foo&amp; operator=(const Foo&amp; other) {
    if (this != &amp;other) { // 자기 할당 방지
      // 맴버를 복사하는 코드
      std::cout &lt;&lt; "할당 연산자(복사)" &lt;&lt; std::endl;
    }
    return *this;
  }

  // 이동 할당 연산자
  Foo&amp; operator=(Foo&amp;&amp; other) noexcept {
    if (this != &amp;other) { // 자기 할당 방지
      // 맴버를 이동하는 코드
      std::cout &lt;&lt; "할당 연산자(이동)" &lt;&lt; std::endl;
    }
    return *this;
  }

  Foo CreateFoo() {
    return Foo(); // 임시 객체 생성
  }
};

int main() {
  std::vector&lt;Foo&gt; foos;
  Foo foo;
  std::cout &lt;&lt; "[[std::move 호출]]" &lt;&lt; std::endl;
  foos.push_back(std::move(foo));  
  Foo foo2;
  std::cout &lt;&lt; "[[할당 연산]]" &lt;&lt; std::endl;
  foo2 = foo;
  Foo foo3;
  std::cout &lt;&lt; "[[임시객체 생성]]" &lt;&lt; std::endl;
  foo3 = foo.CreateFoo();
  std::cout &lt;&lt; "[[코드종료]]" &lt;&lt; std::endl;
  return 0;
}

결과:
생성자
[[std::move 호출]]
생성자(이동)
생성자
[[할당 연산]]
할당 연산자(복사)
생성자
[[임시객체 생성]]
생성자
할당 연산자(이동)
소멸자
[[코드종료]]
소멸자
소멸자
소멸자
소멸자</p>
                                </div>                <div id="SE-2f18de07-bae9-42ed-99ec-e71c68a5ab9c">
                                    <p id="SE-344b408b-b480-4cec-9fbb-0dc2a0b3c3b0"><span id="SE-c6fc5df0-757e-4454-9857-37bbc3641c39">특히 CreateFoo() 멤버와 같이 리턴하는 임시 객체는 rvalue고, 이런 경우 이동 시맨틱으로 처리됩니다. 하지만 경우에 따라서 이동 시맨틱으로 처리되지 않고, 복사 할당으로 강제하고 싶을 때가 있습니다.</span></p><p id="SE-c960be67-1652-419e-88e9-968e6f91a0f8"><span id="SE-f4b2ac6a-106a-4ad6-8956-26e9b83b519c">아래의 GetThing은 임시 객체를 리턴하고, 이런 경우 이동 시맨틱으로 처리 됩니다.</span></p>
                            </div>                <div id="SE-dbcb8dea-602f-458d-a354-c618b1c5f28a">
                                    <p>extern Thing GetThing();
Thing thing;
thing = GetThing();</p>
                                </div>                <div id="SE-1ab20aa9-3169-4da6-8807-23fd4a4cb39a">
                            <p id="SE-abdb205a-ea52-46bf-b683-2129c6d1e09a"><span id="SE-802e8c40-0e68-4fd6-96f7-947ebb27098e">여기에 객체 상수화(const-ifying)를 적용하여 복사만 가능하게 만들 수 있습니다.</span></p>
                        </div>                <div id="SE-adb2dc8c-21c7-4da4-9fa9-1496b48e91c1">
                                    <p>template&lt;typename T&gt;
std::remove_reference_t&lt;T&gt; const&amp; no_move(T&amp;&amp; t) {
    return t;
}</p>
                                </div>                <div id="SE-5c74c259-e017-4812-bf6b-451d519df3c3">
                                    <p id="SE-0597b634-233e-45e0-b1d5-222e1533febd"><span id="SE-bc9cad78-c900-47ad-beea-9c7873072268">no_move 함수는 템플릿이기 때문에 인자인 T&amp;&amp; t는 우측 값 참조(rvalue reference)가 아닌 보편 참조(universal reference)를 나타냅니다. 인자로 lvalue, rvalue를 모두 받을 수 있습니다. std::remove_reference_t&lt;T&gt; 타입 트레이트는 레퍼런스를 제거합니다. 예를 들어 T가 int&amp;인 std::remove_reference_t&lt;int&amp;&gt;는 int가 되고, 이는 no_move의 결괏값 타입이 됩니다. 여기에 const&amp;를 붙여 수정할 수 없는 상수 참조 객체를 리턴하게 됩니다.</span></p><p id="SE-9bd522e7-eb73-4e95-83c5-690aa218baa2"><span id="SE-7e4f7387-968f-44b2-b340-be6ecb057c7c">결국 인자 t의 타입(T)인 상수 참조 객체, 쉽게 말해 읽기 전용 값을 리턴하게 됩니다. 읽기 전용 값이기 때문에 이 값은 이동이 불가능 합니다. C++에서는 상수를 이동할 수 없습니다. 따라서 이 상수화는 복사를 강제합니다.</span></p>
                            </div>                <div id="SE-b462a3a0-dc87-44dd-beb6-b38119514522">
                                    <p>Foo foo;
foo = no_move(foo.CreateFoo());

결과:
생성자
할당 연산자(복사)
소멸자</p>
                                </div>                <div id="SE-f33962de-88e2-4b02-a127-c7c742de4d1f">
                                    <p id="SE-7d6ec87c-6a36-4d71-ac00-d03207c34036"><span id="SE-e6b39086-cabd-4420-bd5e-b0e05c7838d8">no_move는 인자로 어떤 종류의 참조도 받고, 그 객체에 대한 상수 참조를 리턴합니다.</span></p><p id="SE-ca692189-cef3-4be8-b978-f6045dd1be6a"><span id="SE-43d0fd8a-385b-425c-9c12-2f76f6676129">​</span></p><p id="SE-10b3d333-4fde-49dc-aa42-687292a183c3"><span id="SE-90e5f3ec-1460-4bb6-9f77-f3042251687d">다음 코드는 이동 할당이 아닌 복사 할당이 이루어 집니다.</span></p>
                            </div>                <div id="SE-17086612-b8be-472f-9733-fae806dfa63f">
                                    <p>extern std::vector&lt;int&gt; make_vector();
v = no_move(make_vector());</p>
                                </div>                <div id="SE-e514d0d0-a972-4931-a3ff-f07586988733">
                            <p id="SE-cc0a34a6-814e-4a0a-baac-0574ace4eb4a"><span id="SE-3ac2ea9c-ed85-48b1-bfeb-23ab7e893a7d">다음 코드는 복사 제거(copy elision) 최적화가 되며, 바로 값이 부여됩니다. 복사나 이동이 이루어 지지 않습니다.</span></p>
                        </div>                <div id="SE-80a7dce2-72a1-4b3c-a538-19a2f43da1b7">
                                    <p>std::vector&lt;int&gt; v = make_vector();</p>
                                </div>                <div id="SE-b55e2103-7679-499e-ba55-30517ffd4f35">
                            <p id="SE-0fd3a146-7ee2-4008-9969-bce87bc50bfe"><span id="SE-86e8c92e-e9f8-4c1f-bdcd-8e89317191f9">하지만, 여기에 no_move를 붙이면 복사가 강제됩니다.</span></p>
                        </div>                <div id="SE-d86a079c-0570-4cfb-bcaa-a0d065e250d2">
                                    <p>std::vector&lt;int&gt; v = no_move(make_vector());</p>
                                </div>                                                    </div></div>

내 성격 100% 활용하기 -上-

레이몬드 챈이 블로그에 포스팅한 "How do I make an expression non-movable? What’s the opposite of std::move?" 아티클을 편역하였습니다. 이 글을 통해 std::move에 대한 기본기를 점검하고 이동 시맨틱을 사용하고 싶지 않을 때 유용한 방법을 알 수 있습니다. std::move는 C++ 11에서 도입된 기능으로, 객체를 이동 시맨틱(move semantics) 처리합니다. 워낙 코드 최적화로 얻을 수 있는 성능의 이익이 많기도 하고, 심지어 C++ 11/17에서는 생성자 호출을 생략해 명시적으로 복사 제거(Copy elision)를 보장하는 규칙도 생겼으며, std::move의 효용성이 그리 없는 경우(모던 이펙티브 C++ 참고)도 다양하고 많아 std::move를.......

std::move의 반대개념, 비이동성(non-movable) 표현하기

댓글