🔥코딩 규칙 : move semantics_참조 카운팅 직접 만들기.

얕은 복사

: 클래스 멤버 데이터가 포인터가 있는 상태에서 ,
디폴트 복사 생성자가 호출되면, 두 객체의 포인터가
하나의 메모리를 공유하면서 발생하는 문제

해결하기

: 얕은 복사 문제를 해결하는 방법으로

• 깊은 복사
• 참조 카운팅 이 있음.

디폴트 복사 생성자의 특징

: 객체의 모든 멤버를 대입연산자로 처리함.
-> 얕은 복사 문제가 발생!

problem

: char * name, int age 를 멤버로 가지고 있는
Cat 클래스를 만들어라. name은 strcpy를 사용

• 1번 : 아래의 코드를 해결하는 복사 생성자 만들기
• 2번 : 참조 카운팅으로 만들어라

int main()
{
	Cat a("bom", 1);
    Cat b = a; 
    //Cat c(a);
}

- 얕은 복사로 인한 문제 발생 코드
-> 왜냐하면 컴파일러가 디폴트 복사 생성자를 통해 포인터 name의 주소를
2개의 객체가 공유하기 때문임.

• 1번. 깊은 복사로 처리하기
  : 복사 생성자에서 새로운 메모리를 할당하고, 값을 대입하는 것이다.
  

• 2번. 참조 카운팅을 활용하자.
  : 동일한 포인터에 대해 몇번을 참조하고 있는지를 카운팅하는 방법이다.

• c++의 shared_ptr에서 사용함.
  

// cppTest.cpp : 이 파일에는 'main' 함수가 포함됩니다. 거기서 프로그램 실행이 시작되고 종료됩니다.
//

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;

class Cat
{
private : 
	char* name;
	int age;
	int* refCnt;
public : 
	Cat(const char* _name, int _age)
		: age(_age)
	{
		refCnt = new int(1);
		name = new char[strlen(_name) + 1];
		strcpy(name, _name);
		cout << "refCnt 생성 " << endl;
	}

	~Cat()
	{
		
		{
			--(*refCnt);
			cout << "카운팅 1 감소" << endl;

		}
		
		if (*refCnt == 0)
		{
			delete[] name;
			delete refCnt;
			cout << "메모리 해제" << endl;
		}
		
	}

	Cat(const Cat& _cat)
		: age(_cat.age), name{_cat.name}
	{
		++(*_cat.refCnt);
		refCnt = _cat.refCnt;
		cout << "카운팅 1 증가" << endl;
		cout << "refCnt의 주소는? " << &(refCnt) << endl;
		cout << "refCnt의 주소는? " << &(_cat.refCnt) << endl;
		//name = new char[strlen(_cat.name) + 1];
		//strcpy(name, _cat.name);
	}
	void print() const
	{
		cout << name << endl;
	}
};



int main()
{
	Cat a("bom", 1);
	Cat b = a;
	
	b.print(); 
	a.print();
}

---

✨임시객체와 복사 대입

problem

1) const char* , int 타입의 멤버를 가지고, 고양이의 이름과 나이를 입력하자.
2) 객체를 반환하는 foo 함수를 만들자.
3) main에서 Car c(foo);
4) c.print 해서 이름을 출력하자.
5) 추가적으로 이동생성자 호출되었을 때의 this 포인터의 주소도 확인해보자.

• 복사와 이동생성자를 만들고, 먼저 복사 테스트 후에 이동테스트 하자.

  이동 생성자의 모양은 Cat(&&) 이고, 복사 생성자처럼 멤버간 대입을 하고,
  포인터가 있을 경우, 원본 객체 멤버를 = nullptr 처리해서 참조값을 날리자.

int main()
{
Cat a = foo();
a.print();
std::cout << &a << std::endl;

}

---

복사 생성자와 이동생성자에 대해 알아보자.

• 아래의 코드를 실행해보자.

#include <iostream>
using namespace std;
#include <string>

#include <vector>
#include <limits.h>
#include <algorithm>
#include <map>

class Cat
{
private:
	char* name;
	int age;
public:
	Cat(const char* _name, int _age)
		: age{ age }
	{
		std::cout << "constru" << std::endl;
		name = new char[strlen(_name) + 1];
		strcpy(name, _name);
		std::cout << this << std::endl;
	}

	Cat(const Cat& _copy)
	{
		std::cout << "copy constru" << std::endl;
		name = new char[strlen(_copy.name) + 1];
		strcpy(name, _copy.name);
		std::cout << this << std::endl;

	}
	~Cat()
	{
		if (name != 0)
		{
			delete[] name;
			std::cout << "delete name! " << std::endl;
		}
		std::cout << "destructor" << std::endl;
	}

	void print()
	{
		std::cout << name << std::endl;
	}

	//Cat(Cat&& movObj)
	//{
	//	std::cout << "move Call" << std::endl;
	//	name = movObj.name;
	//	age = movObj.age;
	//	std::cout << this << std::endl;
	//	movObj.name = 0;
	//}
};

Cat foo()
{
	Cat c("naOng", 10);
	std::cout << "foo" << std::endl;
	std::cout << &c << std::endl;

	return c;
}

int main()
{
	Cat a = foo();
	a.print();
	std::cout << &a << std::endl;

}

• 실행 결과
  : 객체의 주소를 보는 것이 아니라, delete name을 보자.
  2번 출력됨.
  

• 결과 !
  :
  

foo 함수 호출로 인해 c객체가 만들어지고, name 포인터의 메모리가 할당됨.
이어서 반환을 하면서 a객체에다가 대입되는데, 여기서 foo 에서 할당된 c객체는 파괴됨. foo 함수는 객체를 반환하고 있기 때문에 임시객체가 생성되면서 복사 생성자의 인자에 전달함.
여기서 중요한 부분이 복사 생성자를 진입하면서 2번째 name 포인터의 메모리가 할당됨.
복사 생성자로 인해서 name 자원이 2번이나 할당되는데, foo 함수에서 반환하고 바로 사라지는 객체 c의 name 자원을 잘 사용하면 좋지 않을까? 란 생각을 해야 한다!

• 이동생성자란?
  이러한 부분을 개선하기 위해 c++11에서 도입된 것이 이동생성자이다.
  이동 생성자는 자원을 복사하는 것이 아니라. 이동하는 것임.
  얕은 복사처럼 포인터 주소만 넘겨주고, 원본 데이터에서는 메모리를 포기하면 됨.

• 고찰:
  차라리 foo 함수에서 객체 c가 할당된 name 의 메모리를 객체 a의 name에다가 자원 이동하면
  복사 생성자에서 2번째로 name 포인터가 할당되는 자원을 아낄 수 있음.
  여기서 알아야 되는 부분이 이동생성자나 복사 생성자나 어쨋든 호출하면
  객체는 생성된다는 것이다. name 자원이 2번 할당되는 것을 1번만 할당하자는 것이 이동생성자의 목적이다.

• 이동 생성자 있을 때의 코드와 결과

#include <iostream>
#include <vector>
//using namespace std;
//#include <stdio.h>
#include <winsock2.h>
#include <thread>
#pragma  comment(lib, "ws2_32")

#define _WINSOCK_DEPRECATED_NO_WARNINGS

#include <Windows.h>

#include <memory>
using namespace std;

#include <vector>
#include <algorithm>

class Cat
{
private : 
	char* name;
	int age;
public: 
	Cat(const char* _name, int _age)
		: age{age}
	{
		std::cout << "constru" << std::endl;
		name = new char[strlen(_name) + 1];
		strcpy(name, _name);
		std::cout << this << std::endl;
	}

	Cat(const Cat& _copy)
	{
		std::cout << "copy constru" << std::endl;
		name = new char[strlen(_copy.name) + 1];
		strcpy(name, _copy.name);
		std::cout << this << std::endl;

	}
	~Cat()
	{
		if (name != 0)
		{
			delete[] name;
			std::cout << "delete name! " << std::endl;
		}
		std::cout << "destructor" << std::endl;
	}

	void print()
	{
		std::cout << name << std::endl;
	}

	Cat(Cat&& movObj)
	{
		std::cout << "move Call" << std::endl;
		name = movObj.name;
		age = movObj.age;
		std::cout << this << std::endl;
		movObj.name = 0;
	}
};

Cat foo()
{
	Cat c("naOng", 10);
	std::cout << "foo" << std::endl;
	std::cout << &c << std::endl;
	
	return c;
}

int main()
{
	Cat a = foo();
	a.print();
	std::cout << &a << std::endl;

}

이동생성자 존재시 정리

// 위의 프로젝트는 코드 최적화가 안되어 있는 경우이다. 240803

• 일단 왜 이동생성자가 호출되었냐면? 임시객체를 반환하고 있기
  때문이라는 것을 파악해야 한다!

• 객체가 생성되는 것을 확인할 수 있고, 객체의 메모리가 이동하는 것은 아니고
  자원을 이동시키게 하는 것임.
  그리고 delete name은 한번만 출력되는 것을 확인하면서 메모리 할당 1번만 함1
  

• 이동 생성자냐 복사 생성자냐?
  : 바로 해제 되는 임시객체의 경우, 멤버 내 메모리 할당 이슈가 있으니까,
  이동 생정자가 복사보다는 좋음.

결론
-> foo에서 반환되는 객체 c가 값타입으로 반환됨.
컴파일러는 지역 객체인 c가 foo함수에서 제거되므로, 복사생성자를 암시적으로 호출함.
: foo() 함수의 경우, "hello" 가 호출되기도 전에 임시객체가
소멸됨.
메모리가 생성,해제가 발생한다는 것임.
차라리 foo에서 반환되는 임시객체의 자원을 그대로 객체 cc가 받는다면,
메모리 관점에서 성능을 가지고 올 수 있음.

240803 추가 최적화되어 있는 경우.

: 위의 코드를 실행하면, move 처리되지 않고, 최적화되어서 바로 생성자 하나만 호출된다.

이동 생성자

: 이동생정자는 객체 내의 멤버 자원을 이동시키는 것이지, 객체의 메모리를
통째로 옮기는 것은 아님/

이동생성자를 어떻게 만들까?

(이동생성자 작성하지 않았을 때) 위에서 임시객체가 call 되면서 복사 생성자를 호출하는 결과를 확인할 수 있었음.
임시객체는 Rvalue이므로, const& Obj 타입보다 우선순위가 높은 Obj&& 인자로
되어 있는 이동생성자를 호출하게 하자.
- 추가적으로 자원을 그대로 이동하고, 원본 객체를 초기화하는 작업을 해야함.
- 1) 멤버 자원을 그냥 복사 대입한 후,
- 2) 인자로 받은 것중에서 포인터가 있다면, 포인터를 0으로 설정

0으로 설정하게 되면,

• delete 시에 메모리가 0등의 없는 경우 문제 발생하지 않고, 그냥 스킵한다고 한다.

---

• 예시코드의 설명 대로 하기 위한 개념
  : c++에서 참조되는 포인터가 0이라면, 멤버 데이터의 해제는
  발생하지 않음. 딱히 조건 처리안해도 됨.

• 그림

  • 동일한 메모리를 참조하고 있음.
    

• 이 상황에서 임시객체쪽의 참조를 0으로 하자.
  

이동 생성자를 호출해서 자원을 아끼는 방법.

1. 이미 만들어진 name의 메모리를 새로운 객체::name이 참조하게 한후
2. 인자로 들어오는 객체의 name이 가리키는 값을 0으로 설정하자.

이동 생성자의 모양

복사 생성자의 인자처럼 사용하기에는 lvalue로 보냈을 때는
소멸되지 않고 , 계속해서 사용이 가능하므로!
->즉, rvalue에 한해서만 처리를 해야 하므로
(Point &&p) 형태로 인자를 설정해야 함.
-> 따라서 복사 생성자와 이동 생성자 2개를 만들어야 함.
--> 이동생성자를 만들지 않으면, 임시객체를 복사생성자가 사용하게 된다.

이동 생성자의 정의

: rvalue를 인자로 받아서 원본 객체의
소유권, 자원을 이전하게 하는 생성자를 말함.
포인터의 경우는 주소를 넘기고, 원본 객체가 가리키는 포인터를 nullptr 처리해야 함.

이동 생성자는 언제 사용할까?

: 객체의 소유권을 이전하고 싶을 때 사용함.

중요

이동 수행 후, 반드시 해야할 동작.
: 원본의 포인터는 반드시 0값으로 만들어야 함!
-> 0으로 하면 소멸자에서 delete 하는 코드가 있더라도 아무일 없이 지나간다.

problem

: 그림 1번을 타이핑 한후, 이동처리해서 자원 name 이
다시 한번 동적할당되는 것을 차단하자.

• 그림 1번 : 이동 생성자가 없을 경우
  : 임시 객체 생성, 해제가 발생함.
  

중요 move 이후 원본 포인터는 0으로 초기화해야 함!

**- 그림 2번 : 이동 생성자를 만들 경우.

반드시 원본 포인터의 메모리를 0으로 만들어야 함!

• 결론 : 자원을 이동했고, 내가 소멸자 출력확인을 위해 !=0 조건처리 했지만,
  조건 처리를 하지 않더라도, 해제가 되지 않는 것을 확인할 수 있었음.
  -> 와우! 컴파일러가 일을 알아서 잘하네???!! ㅋㅋㅋㅋ
  -> 이유가 있다. c++11 창시자님의 책을 보면, delete 는 메모리가 이미 없는 객체에 한해서는 동작을 하지 않는다고 한다. 240803
  

---

정리

• 복사 생성자는 cont &point 형태이기 때문에
  lvalue, rvalue 2개 모두 받을 수 있음.

• 이동생성자는 point&& 이기 때문에 rvalue만 받을 수 있음.

우선순위

: rValue를 인자로 보낼때 호출되는 우선순위.
이동 생성자 > 복사 생성자.

• 만약 임시객체로 초기화할 경우, 이동생성자나 복사 생성자가 호출됨.
  1) 이동 생성자가 있다면, 소유권 이전 됨. , 1번보다는 효율적임.
  2) 이동생성자가 없다면, 복사 발생
  3) 이동생성자가 없다고 해도, 에러는 아님

copy ellipse

// move 생성자를 주석 처리하자.

• 복사 최적화
  : 임시객체를 복사할 경우, 컴파일러가 복사를 호출하지 않고, 생성자를 호출함.

int main()
{
	point p;
    point p2 = p;
    point p3 = point(); 
}

• 비주얼의 경우, 복사최적화가 되어 있기 때문에, 함수를 반환하는 것을 대입하는 방식으로 rvalue를 복사 생성자에서 호출되는 것을 확인할 수 있음.

int main()
{
	point p = foo();
}

결론

• 클래스를 설계할 때, 이동생성자, 복사 생성자 2개를 모두 만들자!