04. 연산자 오버로딩 / 이동 생성자&이동 대입 연산자 / 동적 메모리

 

< 연산자 오버로딩 >

#include <iostream>
#include "save.h"
using namespace std; 

// 아래의 main이 돌아가도록 코딩해보자

class Person {
private:
	int age;
public:
	Person(int age) : age(age)
	{
		cout << "Person::Person(age) 생성자 완료" << endl;
	}

	Person()
	{
		cout << "Person::Person() 생성자 완료" << endl;
	}

	~Person()  // 소멸자
	{
		cout << "Person::~Person 소멸자 완료" << endl;
	}

	void introduce();

	Person add(const Person& p);
	Person sub(const Person& p);
	Person mul(const Person& p);
	Person div(const Person& p);
};

int main()
{
	Person player(30);
	Person enemy(15);
	player.introduce();
	enemy.introduce();

	Person addPlayer = player.add(enemy);
	addPlayer.introduce();

	Person subPlayer = player.sub(enemy);
	subPlayer.introduce();

	Person mulPlayer = player.mul(enemy);
	mulPlayer.introduce();

	Person divPlayer = player.div(enemy);
	divPlayer.introduce();
}

void Person::introduce()
{
	cout << "나이 : " << age << endl;
}

Person Person::add(const Person& p)
{
	Person m(this->age + p.age);
	return m;
}

Person Person::sub(const Person& p)
{
	Person m(this->age - p.age);
	return m;
}

Person Person::mul(const Person& p)
{
	Person m(this->age * p.age);
	return m;
}

Person Person::div(const Person& p)
{
	Person m(this->age / p.age);
	return m;
}

// main함수의 .add 역할을 +가 할 순 없을까? => .operator+

// 컴파일러 -> +를 만나면 operator+() 멤버 함수를 찾고
// 이의 멤버함수 왼쪽과 오른쪽을 살펴보고 수행한다.

// 다음으로 바꿀 수 있다.

class Person {
private:
	int age;
public:
	Person(int age) : age(age)
	{
		cout << "Person::Person(age) 생성자 완료" << endl;
	}

	Person()
	{
		cout << "Person::Person() 생성자 완료" << endl;
	}

	~Person()  // 소멸자
	{
		cout << "Person::~Person 소멸자 완료" << endl;
	}

	void introduce();

	Person operator+(const Person& p);
	Person operator-(const Person& p);
	Person operator*(const Person& p);
	Person operator/(const Person& p);
};

int main()
{
	Person player(30);
	Person enemy(15);
	player.introduce();
	enemy.introduce();

	Person addPlayer = player + enemy;      // + 3 을 하면 ? => 형변환을 통해 객체가 하나 더 만들어져 그대로 수행됨
	addPlayer.introduce();

	Person subPlayer = player - enemy;
	subPlayer.introduce();

	Person mulPlayer = player * enemy;
	mulPlayer.introduce();

	Person divPlayer = player / enemy;
	divPlayer.introduce();
}

void Person::introduce()
{
	cout << "나이 : " << age << endl;
}

Person Person::operator+(const Person& p)
{
	Person m(this->age + p.age);
	return m;
}

Person Person::operator-(const Person& p)
{
	Person m(this->age - p.age);
	return m;
}

Person Person::operator*(const Person& p)
{
	Person m(this->age * p.age);
	return m;
}

Person Person::operator/(const Person& p)
{
	Person m(this->age / p.age);
	return m;
}

// main함수
Person addPlayer = 3 + enemy;           // 왜 안될까?

// + 연산자를 보고 operator 연산자를 찾는데
// 3 + 를 봐서는 어떤 클래스인지 알 수 없음
// 클래스 내부 함수로만 정의하는 것이 아닌 일반 전역 함수로 정의 가능하다.

// Person class 내부
friend Person operator+(const Person& p, const Person& pp);

// 정의부분
Person operator+(const Person& p, const Person& pp)
{
	Person m(p.age + pp.age);
	return m;
}

// 오버로딩 또한 가능하다


// * friend
// 자신의 개체뿐만이 아닌 다른 타입의 개체를 접근 가능
// 하나의 클래스에서 다른 클래스의 내부 데이터에 접근 해야할 경우
// 함수나 클래스 선언 앞에 선언할 수 있고 접근 제어 지시자 영향을 받지 X

// 복사생성자와 짝인 복사대입연산자
// 복사생성자 -> 객체를 같은 형식(클래스)의 객체로 초기화할 때 호출되는 함수
// 복사 대입 연산 -> 같은 형식의 객체끼리 복사하는 용도

// 복사 대입 연산자
	Person& operator=(const Person& p);

int main()
{
	Person player(30);
	Person enemy(15);

	Person addPlayer =  enemy;              // opeartor=() 안했는데도 잘돌아감 -> 왜?
	addPlayer.introduce();


}

Person& Person::operator=(const Person& p)
{
	this->age = p.age;
	return *this;
}

 

 

 

< 이동생성자 & 이동 대입 연산자 >

int main()
{
	Person player(30);
	Person enemy(15);

	Person copyPlayer(enemy);              
	Person movePlayer(std::move(player)); 
	// 돌아가긴 하는데
	// 기존 obj을 이용해 새로운 것을 만들 때
	// copy가 아니라 move해서 가져올 수 있다

}


// 클래스 내부
// 이동생성자
	Person(Person&& other) noexcept : age(other.age)
	{	
		// 얕은 복사
		other.age = 0;
		cout << "Person::Person() 이동생성자 완료" << endl;
	}
    
// 이동 대입 연산자
	Person& operator=(Person&& other) noexcept;
      
Person& Person::operator=(Person&& other) noexcept 
{
	this->age = other.age;
	other.age = 0;
	return *this;
}

// nocxcept : 예외를 던질 가능성 없음을 알림 (false일 경우 있다는 것)

 

 

 

 

< 동적할당 & 동적배열 >

// 클래스 내부
int setAge(int age) { return this->age = age; }

int main()
{
	Person* player = new Person(320);  // new -> 생성자

	player->introduce();

	int n;
	cin >> n;
	Person* mon = new Person[n];
	for (int i = 0; i < n; i++) {
		mon[n].setAge(i + 1);
		mon[n].introduce();
	}

	delete player;  // delete -> 소멸자
	delete[] mon;
}

 

 

 

< STRING의 class >

class STRING {
private:
	size_t num{}; //8
	char* p{};    //8

public:
	STRING();
	~STRING();
	STRING(const char* s);

	// 복사생성자(스페셜 함수)
	STRING(const STRING& other);

	STRING& operator=(const STRING& other);

	// 이동생성자와 이동할당연산자 ( && - r-value reference, 이동(move)과 완벽전달(perfect forwarding)에 사용)
	STRING(STRING&& other);

	// 연산자 오버로딩
	STRING operator+(const char*) const;
	STRING operator+(const STRING&) const;

	// 입출력기능은 이 클래스와 밀접한 기능이다.
	// 그래서 operator<< 함수는 STRING의 멤버에 아직 이 함수도 멤버함수인 것 처럼 자유롭게
	// 접근하도록 코딩하는 것이 합리적이다. -> 이 함수를 friend로 선언한다.

	friend std::ostream& operator<<(std::ostream&, const STRING&);
};

STRING::STRING() 
{

}

STRING::~STRING() 
{
	delete[]p;
}

STRING::STRING(const char* s) : num{ strlen(s) } 
{
	p = new char[num];
	memcpy(p, s, num);
}

// 복사생성자(스페셜 함수)
STRING::STRING(const STRING& other) : num(other.num) 
{
	p = new char[num];
	// deep copy
	memcpy(p, other.p, num);		// DMA;
}

STRING& STRING::operator=(const STRING& other) 
{
	// 나를 나로 할당할 이유가 없다
	if (this == &other)  // this는 주소기에 other도 주소
		return *this;

	num = other.num;
	delete[] p;
	p = new char[num];
	memcpy(p, other.p, num);

	return *this;
}

// 이동생성자와 이동할당연산자 ( && - r-value reference, 이동(move)과 완벽전달(perfect forwarding)에 사용)
STRING::STRING(STRING&& other) : num{ other.num } 
{

	// other의 자원을 가져온다
	p = other.p;
	// other를 초기화
	other.num = 0;
	other.p = nullptr;
}

STRING STRING::operator + (const char* str) const {
	STRING temp;			// default ctor 스페셜 함수

	temp.num = num + strlen(str);
	temp.p = new char(temp.num);

	memcpy(temp.p, p, num);
	memcpy(temp.p + num, str, strlen(str));

	return temp;			// 여기서 복사생성자가 호출되어야 하지만 RVO가 작동된다
	// RVO(Return Value Optimization) - 반환값 최적화
}

STRING STRING::operator+(const STRING& other) const {
	STRING temp;
	temp.num = num + other.num;
	temp.p = new char[temp.num];
	memcpy(temp.p, p, num);
	memcpy(temp.p + num, other.p, other.num);

	return temp;
}

std::ostream& operator<<(std::ostream& os, const STRING& s) 
{
	for (int i = 0; i < s.num; ++i)
		os << s.p[i];
	return os;
}