[C++ 시험대비] 5주차 - 함수의 참조, 복사생성자

📌들어가기 전에 정리

 

- 레퍼런스 변수

: 값과 주소값 모두 가지고 있다라고 우선 생각하기

 

- 동적할당

: 말 그대로 프로그램이 실행되고 나서 할당 

예를 들어 배열의 크기를 동적으로 할당해줄 수 있겠쥬?

 

- 복사생성자

 

예를 들어 Person p1=new Person();

Person p2;

p1=p2; 같이 어떤 객체를 복사한다? 그러면 복사생성자가 생성됨 

우리도 모르는 사이에 디폴트 복사 생성자가 실행되고 있는거

근데 이 디폴트 복사생성자는 얕은 복사이기에 값도 복사하고 주소값 공간을 따로 사용하는 깊은 복사를 해주기 위해 

레퍼런스 변수를 사용하여 깊은 복사 복사생성자를 커스터마이징하는 과정이 필요함!

 

헷갈리는 개념정리 끝 본론으로 들어가자!

 

값에 의한 호출로 객체 전달하기

 

매개변수 객체 공간이 스택에 할당된다.

매개변수 객체가 그대로 복사된다 -> 매개변수 객체의 생성자가 호출되지 않는다!

 

왜 생성자가 호출되지 않을까? 

=> 호출되는 순간 실인자 객체 상태를 매개변수 객체에 그대로 전달하기 위함!

 

#include <iostream>
using namespace std;

class Circle {
private:
	int radius; 
public:
	Circle(); 
	Circle(int r);
	~Circle();
	double getArea()  { return 3.14*radius*radius; }
	int getRadius() { return radius; }
	void setRadius(int radius) { this->radius = radius 
}; 

Circle::Circle() {
	radius = 1;
	cout << "생성자 실행 radius = " << radius << endl;
}

Circle::Circle(int radius) {
	this->radius = radius;
	cout << "생성자 실행 radius = "  << radius << endl;
}

Circle::~Circle() {
	cout << "소멸자 실행 radius = " << radius << endl;
}
void increase(Circle c) {
	int r = c.getRadius();
	c.setRadius(r+1);
}

int main() {
	Circle waffle(30);
	increase(waffle);
	cout << waffle.getRadius() << endl;
}

 

 

매개변수 c의 생성자는 실행되지 않는다!  단 함수 빠져나갈때 c에 대한 소멸자가 실행됨

 

waffle과 c는 서로 다른 공간에 있다.

 

 

 

 

주소에 의한 호출로 객체 전달하기

 

매개변수는 객체에 대한 포인터 변수로 선언

함수 호출 시 생성자 소멸자가 실행되지 않는 구조 

 

int main(){
	Circle waffle(30);
    increase(&waffle);

}

void increase(Circle *c) {
	int r = c->getRadius();
	c.setRadius(r+1);
}

 

waffle의 주소가 c에 전달된다. 앞선 경우와 다르게 waffle과 c가 같은 공간을 공유한다.

 

 

참조란?

 

참조는 이미 존재하는 객체나 변수에 대한 설명이다. 

이름만 생기며 새로운 공간을 할당하지 않는다.

 

int n=2;

int &refn=n; 

 

아무튼 지금 상황에서는 값과 주소값 가진다고 생각해두자. 

 

n=4;

refn++;

이라면 n은 뭘까? 5가 될것이다. refn도 5가된다.

 

int* p=&refn; 

*p=20;

이라면 ref은 뭘까? 20이다!! 그러면 n은 뭘까? 둘이 주소값 공유하고 있으니 20이다. 

 

 

 

참조에 의한 호출

 

함수의 매개변수를 참조타입으로 선언한다.

참조 매개변수 이름만 생기고 공간은 생기지 않는다.

실인자 변수 공간을 공유한다! (참조에 의한 호출도 주소에 의한 호출 처럼 swap이 될 것 )

 

 

 

참조를 쓴다면 매개변수가 increase(Circle &c)

포인터 쓴다면 increase(Circle* c)

 

 

#include <iostream>
using namespace std;

class Circle {
	int radius;
public:
	Circle() { radius = 1; }
	Circle(int radius) { this->radius = radius; }
	void setRadius(int radius) { this->radius = radius; }
	double getArea() { return 3.14*radius*radius; }
};

int main() {
	Circle donut;
	readRadius(donut);
	cout << "donut의 면적 = " <<donut.getArea() << endl;
}

그냥 readRadius에 그냥 donut만 들어가기 때문에 참조변수를 썼다는 것을 알 수 있음 

 

void readRadius(Circle &c)

 

 

값을 리턴하는? 참조를 리턴하는? 

 

char c = 'a';

char get() { // char 리턴
	return c; // 변수 c의 문자(‘a’) 리턴
}

char a = get(); // a = 'a'가 됨

get() = 'b'; // 컴파일 오류

 

char get()이면 c 안의 문자인 'a'리턴을 한다. 'a'='b'일수 없기에 컴파일 오류가 뜬다.

 

char c = 'a';

char& find() { // char 타입의 참조 리턴
	return c; // 변수 c에 대한 참조 리턴 
}

char a = find(); // a = 'a'가 됨

char &ref = find(); //  ref는 c에 대한 참조
ref = 'M'; // c= 'M'

find() = 'b'; // c = 'b'가 됨

char& get()이면 char타입의 공간에 대한 참조를 리턴한다. 

즉, find()가 리턴한 공간에 ref가 들어가기에 ref='M'은 c='M'이 될 수 있는 것이다.

뿐만 아니라 find()='b'도 c='b'가 될 수 있다. 

 

즉, 참조리턴은 값의 반환이 아닌 공간의 반환이다. 

 

#include <iostream>
using namespace std;

char& find(char s[], int index) {
	return s[index]; // 참조 리턴
}

int main() {
	char name[] = "Mike";
	cout << name << endl;

	find(name, 0) = 'S'; // name[0]='S'로 변경
	cout << name << endl;

	char& ref = find(name, 2); 
	ref = 't'; // name = "Site"
	cout << name << endl;
}

 

여기서 find(name,0)을 보면 name[0]='S'가 된다!

 

 

깊은복사와 얕은 복사 

 

⭐ 한줄 정리

 

얕은복사는 공간을 생성하지 않고, 주소값을 복사한다. 그렇기에 주소값을 공유한다.

깊은 복사는 공간을 따로 생성해서 주소값과 값을 복사한다. 그래서 서로 다른 공간에 주소값을 가진다. 

 

 

🎀 ppt상에서 주절주절

 

¨얕은 복사(shallow copy)

¤객체 복사 시, 객체의 멤버를 1:1로 복사

¤객체의 멤버 변수에 동적 메모리가 할당된 경우

n사본은 원본 객체가 할당 받은 메모리를 공유하는 문제 발생

¨깊은 복사(deep copy)

¤객체 복사 시, 객체의 멤버를 1:1대로 복사

¤객체의 멤버 변수에 동적 메모리가 할당된 경우

n사본은 원본이 가진 메모리 크기 만큼 별도로 동적 할당

n원본의 동적 메모리에 있는 내용을 사본에 복사

¤완전한 형태의 복사

n사본과 원본은 메모리를 공유하는 문제 없음

 

 

복사생성자

 

객체가 복사 생성될 때 호출되는 특별한 생성자. 

class Circle{

	Circle(const Circle& c); //복사생성자 선언
    
 }
 
 Circle::Circle(const Circle& c); //복사 생성자 구현

 

🎀 특징

복사생성자는 한 클래스에 오직 한개만 선언가능

복사생성자는 보통 생성자와 클래스 내에서 중복 선언 가능하다! 

클래스에 대한 참조 매개변수를 가지는 독특한 생성자.

 

#include <iostream>
using namespace std;

class Circle {
private:
	int radius; 
public:
	Circle(const Circle& c); // 복사 생성자 선언
	Circle() { radius = 1; }
	Circle(int radius) { this->radius = radius; }
	double getArea() { return 3.14*radius*radius; }
}; 

Circle::Circle(const Circle& c) { // 복사 생성자 구현
	this->radius = c.radius;
	cout << "복사 생성자 실행 radius = " << radius << endl;
}

int main() {
	Circle src(30); // src 객체의  보통 생성자 호출
	Circle dest(src); // dest 객체의 복사 생성자 호출

	cout << "원본의 면적 = " << src.getArea() << endl;
	cout << "사본의 면적 = " << dest.getArea() << endl;
}

 

Circle src(30)을 하면 Circle(int radius) 호출됨

Circle dest(src) 하면 Circle(const Circle& c) 호출됨

 

 

디폴트 복사생성자

 

Circle::Circle(const Circle& c) {

  this->radius = c.radius;

  // 원본 객체 c의 각 멤버를 사본(this)에 복사한다.

}

 

이런 형식이 디폴트 복사생성자이다.

복사생성자가 선언되지 않은 클래스인 경우, 컴파일러가 자동으로 디폴트 복사생성자를 삽입한다.

 

 

 

얕은복사의 문제점

 

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

class Person { // Person 클래스 선언
	char* name;
	int id;
public:
	Person(int id, const char* name); // 생성자
	~Person(); // 소멸자
	void changeName(const char *name);
	void show() { cout << id << ',' << name << endl; }
};

Person::Person(int id, const char* name) { // 생성자
	this->id = id;
	int len = strlen(name); // name의 문자 개수
	this->name = new char [len+1]; // name 문자열 공간 핟당
	strcpy(this->name, name); // name에 문자열 복사
}

Person::~Person() {// 소멸자
	if(name) // 만일 name에 동적 할당된 배열이 있으면
		delete [] name; // 동적 할당 메모리 소멸
}

void Person::changeName(const char* name) { // 이름 변경
	if(strlen(name) > strlen(this->name))
		return; 
	strcpy(this->name, name);
}
int main() {
	Person father(1, "Kitae");			// (1) father 객체 생성
	Person daughter(father);			// (2) daughter 객체 복사 생성. 복사생성자호출

	cout << "daughter 객체 생성 직후 ----" << endl;
	father.show();						// (3) father 객체 출력
	daughter.show();					// (3) daughter 객체 출력

	daughter.changeName("Grace"); // (4) daughter의 이름을 "Grace"로 변경
	cout << "daughter 이름을 Grace로 변경한 후 ----" << endl;
	father.show();						// (5) father 객체 출력
	daughter.show();					// (5) daughter 객체 출력

	return 0;								// (6), (7) daughter, father 객체 소멸
}

 

Person father(1,"kitae")를 하면 Person(int id,const char* name) 생성자가 호출된다.

Person daughter(father); 를 하면 디폴트 복사생성자가 호출되는데

디폴트 복사생성자를 보면

 

Person::Person(const Person& p) {
	this->id = p.id;
	this->name = p.name;
}

 

요게 호출된다.

 

근데 문제는 daughter와 father가 얕은복사가 되면서 같은 메모리 공간을 공유하게 된다!

 

daughter,father순으로 객체가 소멸된다. 근데 문제점이  둘이 같은 주소값을 가리키니까

daughter가 소멸되고 나면 father가 가리키는 주소값은 가리키고 있었는데 가리키지 않았습니다?! 상황이 되면서

프로그램이 비정상 종료된다.

 

소멸자에서 daugther 객체소멸되면서 이미 name이 날아가버렸는데

father에서 이미 날아가버린애 날리려니 에러가 뜨는 것이다..!

 

그럼 해결책은 무엇일까? 바로 깊은복사를 사용하는 것이다. 

이름에 대한 새로운 공간 만들면 된다.  this-> new char[len+1] 이런방식으로 새로운 문자열 공간을 할당할 수 있다.

그리고 strcpy(this->name, name); 를 하면서 name에 문자열을 복사할 수 있다.

 

자 근데, 지금까지  Person 클래스를 봤을 때 객체를 깊은 복사를 할 수 있는 메서드가 없다..!

깊은 복사를 하는 생성자의 매개변수는 int id,const char* name이다. 

근데 우리가 매개변수로 받아와야 하는 건 객체이다..!!

 

그래서 여기서 복사생성자를 커스터마이징을 해야한다!!

바로 매개변수로 참조변수를 받아오는 것이다!!

 

Person::Person(const Person& person) { // 복사 생성자
	this->id = person.id; // id 값 복사
	int len = strlen(person.name);// name의 문자 개수
	this->name = new char [len+1]; // name을 위한 공간 핟당
	strcpy(this->name, person.name); // name의 문자열 복사
	cout << "복사 생성자 실행. 원본 객체의 이름 " << this->name << endl;
}

 

father와 daughter가 서로 다른 메모리 공간을 가지고 있기에 daughter가 먼저 소멸자 호출되어도

father에는 아무런 영향이 가지 않는다!!

 

 

🎀 더 찾아본 바로는 

 

깊은 복사(Deep Copy)는 '실제 값'을 새로운 메모리 공간에 복사하는 것을 의미하며,

얕은 복사(Shallow Copy)는 '주소 값'을 복사한다는 의미입니다.

 

얕은 복사는 디폴트 복사 생성자인 반면, 깊은 복사는 복사 생성자를 재정의함으로써 원하는 멤버 변수만 복사를 해주는 형식이다. 그래서 얕은 복사의 문제점을 해결할 수 있다.

 얕은 복사는 디폴트 복사 생성자로 대충 복사하는 감이라면, 깊은 복사는 복사 생성자를 재정의해줌으로써 객체간의 같은 메모리 공간 참조를 막아주기에 깊은 복사라고 하는 것 같다.

* 복사 생성자에 const로 인자를 받아오는데, 그 이유는 기존의 객체의 멤버 변수 값을 건드리지 않겠다는 의미이다.

  그래서 복사 생성자에 const로 받아오는 것을 권장한다.

 

https://musket-ade.tistory.com/30

[ C++ ] 깊은 복사( deep copy )와 얕은 복사 ( shallow copy )