r-value reference와 std::move

정성스러운 답변 감사합니다.

하지만 질문3에 대해서 좀 더 내용을 구체화해서 다시 설명드리자면,

일단 말씀해주신 move semantics의 동기, 목표등은 잘 이해하고 있습니다.

먼저 교수님께서 만드신 AutoPtr클래스에는 다음과 같은 두 개의 복사생성자가 포함돼 있습니다.
(편의상 아래를 복사생성자1로 부르겠습니다.)
(복사생성자2)


복사생성자 1은 l-value를 받은뒤(const AutoPtr& a),
새로운 객체를 만들어 그 주소를 가지게 되고(line29)
직접 하나하나 복사해주는 깊은복사를 수행합니다.(line30)

한편,
복사생성자 2는 r-value를 받은뒤(AutoPtr&& a),
주소를 이전받고(line47)
이전해주는 원래 본 친구는 널포인터를 갖게함으로써 소유권을 박탈시킵니다. (line49)

그리고 이 과정이 move semantics를 수행하는 과정입니다.

실제로
26번째 줄을 보면 std::move(res1);을 통해 res1를 r-value화 시켜주니, r-value형에 맞는 복사생성자 2가 호출됩니다.

그리고 복사생성자 2는 move semantics를 따르는 프로세스를 지니고요.

재차 말하면 제가 말씀드린 방금의 과정이
일일이 메모리를 복사하는 깊은복사가 아니라
성능에서 이점이 많은 move semantics를 사용하는 과정입니다.
이것이 본강좌에서 얘기하는 지향점인 것 같습니다.

하지만 여기서 위의 과정을 통해서가 아니라 아래의 과정을 따르면 우회적으로
move semantics를 사용할 수 있지 않나가 제 궁금증이고 천천히 설명드려보겠습니다.

먼저 main함수에서,
26번 째에 해당하는 코드에서 std::move를 지우고 우변을 오직 res1만 남겨본다면

다음과 같이 바뀝니다. (std::move지움)

이렇게 되면 기존에 res1는 move를 통해 r-value가 됐었지만
move를 쓰지 않으니 res1는 l-value 그 자체로 있게 됩니다.

res1이 res2로 복사되는 과정에서
우변(res1)이 l-value이니
l-value를 받는 복사생성자가 호출되어야 합니다.

l-value를 받는 복사생성자는 복사생성자 1이고 아래와 같이 구성돼있습니다.


원래대로라면 위와 같이 l-value객체를 받은뒤,
새로운 객체를 만든뒤 그 주소를 내가 가지고 있게 하고(line29)
내가 만든 객체에 타객체의 데이터들을 하나하나 복사하는 깊은복사를 수행합니다.(line30)

하지만 이 프로세스 중에서 앞서 말한 move semantics를 우회적으로 사용하기 위해 l-value를 받는 복사생성자의 일부를 아래와 같이 수정하고자 합니다.

아직 바뀐 것 없는
에서
로 내용물을 바꿨습니다.

여전히 파라미터를 보면(AutoPtr& a)
l-value를 받는 복사생성자임은 여전합니다.

하지만 바뀐 내용물을 보면
line26에서 타 AutoPtr객체의 포인터m_ptr이 가지고 있는 주소를
: m_ptr(a.m_ptr)을 통해 주소를 내게 이전 시켜주었습니다.

다음으로 line28의 a.m_ptr = nullptr을 통해 내게 주소를 이전시켜준 타객체가 가지고 있는 포인터를 널 포인터로 만들어서 소유권 박탈을 수행합니다.

이러면 나만 받은 주소를 통해 해당하는 객체에 접근할 수 있고,
내게 넘겨준 객체는 넘겨준 뒤 소유권을 잃으니 접근하지 못하게됩니다.

이러한 과정으로 r-value가 아닌 l-value를 받는 복사생성자인데도 우회적으로 move semantics를 사용하게 됩니다.

결론적으로
를 실행하게 되면
와 같이 move semantics를 사용하게 된 것처럼 됩니다.

실제로 바뀐 복사생성자 이후 move semantics의미대로 res1의 m_ptr은 널포인터가 되고,
res2의 m_ptr은 주소를 넘겨받아 유효한 주소를 단독으로 가지게 됩니다.

핵심은 r-value사용 없이도 move semantics를 썼다는 것인데 이렇게 우회하는 것이 되는것 처럼 보이나 적절한지 궁금하여 여쭤보는 것입니다.

혹여나 이해가 안 되도 괜찮은 것이 제가 너무 꼬아꼬아 생각하면서 본래 주제의 맥락을 잃는 것 같은 느낌이 들기는 합니다.
이미 충분히 정석적인 방법론을 충분히 인지하고 있으니
좀 어려움이 있으시면 넘어가도 좋을 것 같습니다!

감사합니다.

<main.cpp>

#include "AutoPtr.h"
#include "Resource.h"
#include <iostream>

using namespace std;

int main()
{
	{
		AutoPtr<Resource> res1(new Resource(1000000));

		cout << res1.m_ptr << endl;

		AutoPtr<Resource> res2 = res1;

		cout << res1.m_ptr << endl;
		cout << res2.m_ptr << endl;
	}
	return 0;
}

<변경후의 AutoPtr.h>

#pragma once

#include <iostream>

using namespace std;

template<class T>
class AutoPtr
{
public:
	T* m_ptr;
public:
	AutoPtr(T* ptr = nullptr)
		: m_ptr(ptr)
	{
		std::cout << "AutoPtr default constructor " << std::endl;
	}

	~AutoPtr()
	{
		std::cout << "AutoPtr destructor " << std::endl;
		if (m_ptr != nullptr) delete m_ptr;
	}

	AutoPtr(AutoPtr& a)
		: m_ptr(a.m_ptr)
	{
		a.m_ptr = nullptr;		// really necessary?
		std::cout << "AutoPtr move constructor " << std::endl;
	}

	AutoPtr& operator = (const AutoPtr& a)
	{
		std::cout << "AutoPTr copy assignment " << std::endl;
		if (&a == this) // prevent self-assignment
			return *this;

		if (m_ptr != nullptr) delete m_ptr;
		// deep copy
		m_ptr = new T;
		*m_ptr = *a.m_ptr;
		return *this;
	}

	AutoPtr(AutoPtr&& a)
		: m_ptr(a.m_ptr)
	{
		a.m_ptr = nullptr;		// really necessary?
		std::cout << "AutoPtr move constructor " << std::endl;
	}

	AutoPtr& operator=(AutoPtr&& a)
	{
		std::cout << "AutoPtr move assignment " << std::endl;
		if (&a == this)
			return *this;

		if (!m_ptr) delete m_ptr;

		//shallow copy
		m_ptr = a.m_ptr;
		a.m_ptr = nullptr;
		return *this;
	}

	void test()
	{
		std::cout << m_ptr << " i'm here " << std::endl;
	}

	T& operator*() const { return *m_ptr; }
	T* operator->() const { return m_ptr; }
	bool isNull() const { return m_ptr == nullptr; }
};

<Resource.h>

#pragma once

#include <iostream>

class Resource
{
	//private:
public:
	int* m_data = nullptr;
	unsigned m_length = 0;
public:
	Resource()
	{
		std::cout << "Resource constructed" << std::endl;
	}

	Resource(unsigned length)
	{
		std::cout << "Resource length constructed" << std::endl;
		this->m_data = new int[length];
		this->m_length = length;
	}

	Resource(const Resource& res)
	{
		std::cout << "Resource copy constructed" << std::endl;
		Resource(res.m_length);

		for (unsigned i = 0; i < m_length; ++i)
			m_data[i] = res.m_data[i];
	}

	~Resource()
	{
		std::cout << "Resource destroyed" << std::endl;
		if (m_data != nullptr) delete[] m_data;
	}

	Resource& operator = (Resource& res)
	{
		std::cout << "Resource copy assignment" << std::endl;
		if (&res == this)
			return *this;

		if (this->m_data != nullptr)
			delete[] m_data;

		m_length = res.m_length;
		m_data = new int[m_length];

		for (unsigned i = 0; i < m_length; ++i)
			m_data[i] = res.m_data[i];

		return *this;
	}

	void print()
	{
		for (unsigned i = 0; i < m_length; ++i)
			std::cout << m_data[i] << " ";
		std::cout << std::endl;
	}

	void setAll(const int& v)
	{
		for (unsigned i = 0; i < m_length; ++i)
			m_data[i] = v;
	}
};

안녕하세요, 댓글로 잘 정리해주셔서, 확인 후 답변 드립니다.
좋은 궁금증이시네요.

l-value 참조를 받는 복사 생성자에서 깊은 복사 대신 얕은 복사를 수행하고, 원본 객체의 포인터를 nullptr 으로 설정함으로써 소유권을 이전하는 것처럼 보이게 하는 것은 C++ 표준에서 다음과 같은 이유로 권장하지 않는다고 합니다.

• l-value 와 r-value 의 의미 관점에서, l-value 참조는 대상 객체가 지속될 것임을 나타내고, r-value 참조는 대상이 임시적이거나 소멸될 것임을 의미합니다. l-value 참조를 사용하여 move semantics 를 구현하는 것은 다른 개발자에게 혼란을 일으킬 수 있습니다.

   

• 마찬가지로, 복사 생성자가 객체의 소유권을 암묵적으로 이전한다면, 함수에 의해 l-value 참조가 전달되고 함수 내에서 해당 참조를 복사하는 경우, 원본 객체가 무효화될 것이라고 예상하지 않는 개발자에게 혼란을 줄 수 있습니다.

이 외에도 보통 l-value 참조를 사용하는 복사 생성자는 객체에 대하여 깊은 복사를 수행할 것이라고 예상하는 상황에서 예상치 못한 오류를 범할 수 있다는 점등의 문제가 있을 수 있겠네요.

결론적으로, 말씀하신 내용처럼 복사 생성자를 변경하여 move semantics 를 구현하는 것은 기술적으로는 가능하지만, C++의 표준과의 일관성, 다른 개발자들의 예측 가능성 등에서 문제를 일으킬 수 있다는 점에서 권장되지 않습니다.

참고 :
Why move semantics have the same behavior as shallow copy in dynamic mem allocation?(링크)

Move semantics with LValue reference(링크)

첨부해주신 질문글에서 완벽히 이해했습니다.

명쾌한 답변 감사합니다