15.4 std::move

#include <iostream>
using namespace std;

template<typename T>
class AutoPtr
{
public:
	T* m_ptr;

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

	~AutoPtr()
	{
		cout << "AutoPtr destructor" << endl;

		if (m_ptr != nullptr) delete m_ptr;
	}

	AutoPtr(const AutoPtr& a) // 💎복사 생성자💎 
	{
		cout << "AutoPtr copy constructor" << endl;

		// deep copy
		m_ptr = new T;  
		*m_ptr = *a.m_ptr; // 📜Resource.h 의 대입 연산자 호출하여 깊은 복사 수행
			
	}

	AutoPtr& operator = (const AutoPtr& a) // 💎대입 연산자 오버로딩💎
	{
		cout << "AutoPtr copy assignment" << endl;
		
		if (&a == this)
			return *this;

		if (m_ptr != nullptr) delete m_ptr;

		// deep copy
		m_ptr = new T;  
		*m_ptr = *a.m_ptr; // 📜Resource.h 의 대입 연산자 호출하여 깊은 복사 수행
														
		return *this;
	}
	//AutoPtr(const AutoPtr& a) = delete;
	//AutoPtr& operator = (**const** AutoPtr& a) = delete;  

	AutoPtr(AutoPtr&& a)  // 💎이동생성자💎
		:  m_ptr(a.m_ptr) // 소유권 이전
	{ 
		a.m_ptr = nullptr; // 소유권 박탈
	
		cout << "AutoPtr move constructor" << endl;
	}

	AutoPtr& operator = (AutoPtr&& a)  // 💎이동 대입 연산자 오버로딩💎 
	{
		cout << "AutoPtr move assignment" << endl;

		if (&a == this)
			return *this;

		if (m_ptr != nullptr) delete m_ptr; 
		
		m_ptr = a.m_ptr;  // 소유권 이전
		a.m_ptr = nullptr;  // 소유권 박탈

		return *this;
	}

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

#include <iostream>

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

		cout << res1.m_ptr << endl;

		AutoPtr<Resource> res2 = res1; //  복사 생성자가 호출된다. res1은 L-Value니까 
        //move semantics로 바꾸고 싶다하면 AutoPtr<Resource> res2 = std::move(res1); //L-value를 R-value로 바꿔준다.

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

#include <iostream>

using namespace std;

template<class T>
void MySwap(T &a, T &b)
{
    //T tmp = a;
    //a = b;
    //b = tmp;
    
    T tmp{ std::move(a) };
    a = std::move(b);
    b = std::move(tmp);
}

int main()
{
    {
        AutoPtr<Resource res1(new Resource(3));
        res1->setAll(3);
        
        AutoPtr<Resource> res2(new Resource(5));
        res2->setAll(5);
        
        MySwap(res1, res2);
        
        res1->print();
        res2->print();
    }
    return 0;
}

#include <iostream>
using namespace std;

class Resource
{
public:
	int * m_data = nullptr;
	unsigned m_length = 0;

public:
	Resource() // 기본 생성자
	{
		cout << "Resource constructed" << endl;
	}

	Resource(unsigned length) // 일반 매개변수 1개 생성자
	{
		cout << "Resource length constructed" << endl;
		this->m_data = new int[length];
		this->m_length = length;
	}

	Resource(const Resource &res) // 💎복사 생성자💎 
	{
		cout << "Resource copy constructed" << endl;
		
		Resource(res.m_length);

		for (unsigned i = 0; i < m_length; ++i)  // 내용물을 전부 깊은 복사 (시간이 꽤 걸림)
			m_data[i] = res.m_data[i];
	}
 
	~Resource()  // 소멸자
	{
		cout << "Resource destroyed" << endl;
	}

	Resource & operator = (Resource & res)  // 💎대입 연산자 오버로딩💎
	{
		cout << "Resource copy assignment" << endl;

		if (&res == this) return *this; // 대입하려는게 자기 자신이면 아무것도 안함
		
		if (this->m_data != nullptr) delete[] m_data; // 1. 내 자신의 m_data 비워주기

		m_length = res.m_length; // 2. 대입으로 넘겨받은 res의 length 로 내 length 갱신
		
		m_data = new int[m_length]; // 3. 비워진 내 자신의 m_data에 새로운 공간 할당받기
		for (unsigned i = 0; i < m_length; ++i) // 4. m_data내용물 넣기.
			m_data[i] = res.m_data[i]; //  대입으로 넘겨받은 res의 m_data 내용물들을 **내 m_data**에 깊은 복사

		return *this;
	}
    
    void print()
    {
        for(unsigned i=0;i<m_length;++i)
            std::cout << m_data[i] << " ";
       std::cout << "\n";
    }
    
    void setAll(const int& v)
    {
        for (unsigned i=0;i<m_length;++i)
        {
            m_data[i] = v;
        }
    }
};

#include <iostream>
#include <utility> // ✨✨
#include <vector>

int main()
{
	{
		vector<string> v;
		string str = "Hello";

		v.push_back(str); //copy semantics

		cout << str << endl; // Hello 그대로 있다.
		cout << v[0] << endl;

		v.push_back(std::move(str)); // move semantics

		cout << str << endl;
		cout << v[0] << " " << v[1] << endl;
	}
	
	return 0;
}