Roopretelcham

상속(Inheritance)

상속에 대한 과거의 관점

: 기존에 정의해놓은 클래스의 재활용을 만들어진 문법적 요소

하지만 상속은 위와 같이 한 문장으로 정의할 수 있는 것이 아니며, 상속의 이점이 재활용에만 있는 것은 아니다.

데이터의 성격을 지닌 클래스 정의

급여관리 시스템에서 직원의 이름과 급여정보를 저장할 수 있는 클래스 정의

control 클래스(handler 클래스) 정의

: 기능의 처리를 실제로 담당하는 클래스

• 새로운 직원 정보의 등록                 AddEmployee
• 모든 직원의 이번 달 급여정보 출력    ShowAllSalaryInfo
• 이번 달 급여의 총액 출력                ShowTotalSalary

이러한 컨트롤 클래스는 기능 제공의 핵심이기 때문에 OOP에서 반드시 존재하는 클래스이다.

위의 두 클래스를 기반으로 하는 main함수

Output :

name: KIM

salary: 1000

name: LEE

salary: 1500

name: JUN

salary: 2000

salary sum: 4500

위의 프로그램은 큰 문제가 없어보이지만, 객체지향뿐만 아니라 소프트웨어 설계에 있어 중요시하는 다음의 요소를 만족하지 않는다.

• 요구 사항의 변경에 대응하는 프로그램의 '유연성'
• 기능의 추가에 따른 프로그램의 '확장성'

만약 직원의 고용형태가 다양해지고, 급여 계산 방식도 달라진다면 클래스의 추가 및 컨트롤 클래스안에 여러 소스의 추가수정이 불가피해진다.

따라서 이러한 문제는 '상속'을 통해 해결이 가능하다.

상속의 문법적 이해

 현실에서 상속(물려받음)하면 재산만을 떠올리기 쉽지만, 물려받는 것은 재산이 아닌 여러 특성일 수도 있다.

"지수는 아버지로부터 좋은 목소리와 큰 키, 재산을 물려받았다"

class Jisu : public Father    // Father클래스의 상속을 의미 (Jisu 클래스가 Father클래스로부터 물려받음을 의미)

상속의 방법과 그 결과

유도 클래스(derived)의 생성자 정의

유도 클래스는 기초(base) 클래스의 초기할 데이터를 인자로 전달받을 책임과,

그 데이터를 기초 클래스의 생성자 호출을 통해 전달할 책임을 진다.

유도 클래스의 생성자는 기초 클래스의 생성자를 호출하는 형태로 멤버 초기화가 이뤄진다.

유도클래스의 생성자에서 이니셜라이저가 의미하는 바는 생성자의 호출이다.

Person클래스의 생성자를 호출하면서 인자로 myage와 myname에 저장된 값을 전달하는 것이다.

상속에 관련된 예제

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

class Person
{
private:
	char name[50];	// 이름
	int age;		// 나이	
public:
	Person(char * myname, int myage)
	{
		strcpy(name, myname);
		age = myage;		
	}
	void WhatYourName() const
	{
		cout << "My name is " << name << endl;
	}
	void HowOldAreYou() const
	{
		cout << "I'm " << age << " years old" << endl;
	}
};

class UnivStudent : public Person
{
private:
	char major[50];     // 전공과목
public:
	UnivStudent(char * myname, int myage, char * mymajor)
		: Person(myname, myage)
	{
		strcpy(major, mymajor);
	}
	void WhoAreYou() const
	{
		WhatYourName();
		HowOldAreYou();
		cout << "My major is " << major << endl << endl;
	}
};

int main(void)
{
	UnivStudent ustd1("Lee", 22, "Computer eng.");
	ustd1.WhoAreYou();

	UnivStudent ustd2("Yoon", 21, "Electronic eng.");
	ustd2.WhoAreYou();
	return 0;
};

Output :

My name is Lee

I'm 22 years old

My major is Computer eng.

My name is Yoon

I'm 21 years old

My major is Electronic eng.

const 객체와 const 객체의 특성들

변수를 상수화 하듯이, 객체도 상수화 가능하다.

const SoSimple sim(20);

객체에 const 선언이 붙으면, 이 객체를 대상으로는 const 멤버함수만 호출이 가능하다.

(객체의 데이터 변경을 허용하지 않음)

아래 예제에서 const객체 sim의 멤버 함수 AddNum을 호출하려고 할 때, 호출이 불가능함을 확인할 수 있다. 

Output:

const와 함수 오버로딩

함수의 오버로딩이 성립하려면 매개변수 수나 자료형이 달라야 한다.

그 외에 const 선언 유무도 함수 오버로딩의 조건에 해당된다.

void SimpleFunc() { . . . . }

void SimpleFunc() const { . . . . }

Output:

friend 선언

: private 멤버의 접근을 허용하는 선언

• A 클래스가 B 클래스를 대상으로 friend 선언을 하면, B 클래스는 A 클래스의 private 멤버에 직접 접근이 가능하다.
• 단, A 클래스도 B 클래스의 private 멤버에 직접 접근 가능하려면, B 클래스가 A클래스를 대상으로 friend 선언을 해줘야 한다.

5행의 friend선언으로 Girl 클래스 내에서는 Boy 클래스의 모든 private 멤버에 직접 접근이 가능해진다.

(물론 Girl 클래스에서 따로 friend 선언을 하지 않으면, Boy 클래스에선 Girl 클래스의 private 멤버 접근이 불가)

Output :

Her phone number: 010-1234-5678

His height: 170

위에서 5행의 클래스 선언이 없이도 컴파일이 되는데 11행의 선언이 Girl이 클래스의 이름임을 알리는 역할도 있기 때문이다.

friend class Girl;    // Girl은 클래스의 이름이며, Girl 클래스를 friend 선언한다!

friend 선언은 신중해야한다

: friend 선언은 객체지향의 '정보 은닉'에 반하는 선언이므로  신중히 선언해야 한다.

friend 선언은 연산자 오버로딩에서 유용하게 쓰이게 된다.

함수의 friend 선언

전역변수를 대상으로도, 클래스의 멤버 함수를 대상으로도 friend 선언이 가능하다.

friend로 선언된 함수는 자신이 선언된 클래스의 private 영역에 접근 가능하다.

#include <iostream>
using namespace std;
 
class Point;   // Point가 클래스의 이름임을 알림
 
class PointOP
{
private:
        int opcnt;
public:
        PointOP() : opcnt(0)
        {  }
 
        Point PointAdd(const Point&, const Point&);  
        Point PointSub(const Point&, const Point&);  
        ~PointOP()
        {
               cout << "Operation times: " << opcnt << endl;
        }
};
 
class Point
{
private:
        int x;
        int y;
public:
        Point(const int &xpos, const int &ypos) : x(xpos), y(ypos)
        {  }
        friend Point PointOP::PointAdd(const Point&, const Point&);       // PointOp클래스의 멤버함수 PointAdd에 대한 friend 선언
        friend Point PointOP::PointSub(const Point&, const Point&);       // PointOp클래스의 멤버함수 PointSub에 대한 friend 선언
        friend void ShowPointPos(const Point&);       // 58행에 정의된 함수 ShowPointPos에 대한 friend선언
};
 
Point PointOP::PointAdd(const Point& pnt1, const Point& pnt2)
{
        opcnt++;
        return Point(pnt1.x + pnt2.x, pnt1.y + pnt2.y);      // 30행 friend선언으로 인해 private 멤버 접근 가능
}
 
Point PointOP::PointSub(const Point& pnt1, const Point& pnt2)
{
        opcnt++;
        return Point(pnt1.x - pnt2.x, pnt1.y - pnt2.y);      // 31행 friend선언으로 인해 private 멤버 접근 가능
}
 
int main(void)
{
        Point pos1(1, 2);
        Point pos2(2, 4);
        PointOP op;
 
        ShowPointPos(op.PointAdd(pos1, pos2));
        ShowPointPos(op.PointSub(pos2, pos1));
        return 0;
}
 
void ShowPointPos(const Point& pos)
{
        cout << "x: " << pos.x << ", ";       // 32행 friend선언으로 인해 private 멤버 접근 가능
        cout << "y: " << pos.y << endl;       // 32행 friend선언으로 인해 private 멤버 접근 가능
}

Output:

x: 3, y: 6
x: 1, y: 2
Operation times: 2

이는 friend 선언이외에 함수 원형 선언이 포함되어 있다.

void ShowPointPos(const Point&);

C++에서의 static

C에서와 같이 전역변수와 지역변수에 내릴수 있는 static 선언의 의미는 C++에서도 통용된다.

전역변수에 선언된 static

: 선언된 파일내에서만 참조를 허용 

분할 컴파일시, 파일간에 접근이 불가능해진다. (개별화 됨)

지역변수에 선언된 static

: 전역변수의 성격을 지니게 됨, 지역변수와 달리 함수를 빠져나가도 소멸되지 않음

처음 1회만 초기화되고, 프로그램 종료시까지 메모리 상주(전역변수의 특성)

선언된 함수내에서만 접근 가능(지역변수의 특성)

static선언된 변수는 전역변수와 같이 따로 초기화하지 않을 시, 0으로 자동 초기화된다.

#include <iostream>
using namespace std;

void Counter()
{		
	static int cnt;	
	cout << "Current cnt: " << cnt << endl;
	cnt++;
}

int main()
{
	for (int i = 0; i<10; i++)
	{
		Counter();
	}	
	return 0;
}

Output:

Current cnt: 0
Current cnt: 1
Current cnt: 2
Current cnt: 3
Current cnt: 4
Current cnt: 5
Current cnt: 6
Current cnt: 7
Current cnt: 8
Current cnt: 9

 static 멤버 변수 (클래스 변수)

: static 변수는 객체 별로 존재하는 변수가 아니라, 프로그램 전체 영역에서 하나만 존재하는 변수로 

프로그램 실행과 동시에 초기화되어 메모리 공간에 할당된다.

#include <iostream>
using namespace std;

class SoSimple
{
public:
	static int simObjCnt;
public:
	SoSimple()
	{
		simObjCnt++;
	}
};
int SoSimple::simObjCnt = 0;

int main(void)
{
	cout << SoSimple::simObjCnt << "번째 SoSimple 객체" << endl;
	SoSimple sim1;
	SoSimple sim2;

	cout << SoSimple::simObjCnt << "번째 SoSimple 객체" << endl;
	cout << sim1.simObjCnt << "번째 SoSimple 객체" << endl;
	cout << sim2.simObjCnt << "번째 SoSimple 객체" << endl;
	return 0;
}

0번째 SoSimple 객체
2번째 SoSimple 객체
2번째 SoSimple 객체
2번째 SoSimple 객체

위 예제에서 23,24행과 같이 객체의 이름을 이용해 접근하는 것은 좋지 않다.

멤버 변수에 접근하는 건지 static 변수에 접근하는 건지 혼동될 수 있어 잘 쓰지 않는다.

따라서 22행과 같이 class를 지정해 접근하는 것이 일반적이고 좋은 방법이다. 

또한 6행과 같이 public 선언되어있지않다면 class 외부에서는 static 멤버 변수에 접근이 불가능하다.

static 멤버 함수

- 특징 (static 멤버 변수의 특징과 일치)

• 선언된 클래스의 모든 객체가 공유한다.
• public 선언되면, 클래스를 지정해 호출 가능
• 객체의 멤버로 존재하는 것이 아니다!

위의 그림을 다시 상기해보면 static 변수와 static 함수는 객체의 생성과 아무런 연관이 없으며, 

객체 내부에 존재하는 변수가 아님을 알 수 있다.

객체와 동시에 생성되는 것이 아닌 전역 변수와 같이 앞서 메모리 공간에 할당된 상태이다.

아래 예제에서 14행의 주석을 해제하면 

"비정적 멤버 'SoSimple::num1'에 대한 참조가 잘못되었습니다. " 라는 에러 메시지가 뜨게 된다.

static 함수는 객체내에 존재하는 함수가 아니기 때문에, 멤버 변수나 멤버함수에 접근이 불가능하다.

당연히 static 변수에만 접근 가능하고, static 함수만 호출 가능하다.

const static 멤버

상수 정보를 담기위한 클래스 CountryArea

const static 멤버변수는, 클래스가 정의될때 지정된 값이 유지되는 상수이다. 따라서 이 경우 아래와 같이 선언과 동시에 초기화가 가능하다.

#include <iostream>
using namespace std;

class CountryArea
{
public:
	const static int RUSSIA			=1707540;
	const static int CANADA			=998467;
	const static int CHINA			=957290;
	const static int SOUTH_KOREA	        =9922;
};

int main(void)
{
	cout<<"러시아 면적: "<<CountryArea::RUSSIA<<"㎢"<<endl;
	cout<<"캐나다 면적: "<<CountryArea::CANADA<<"㎢"<<endl;
	cout<<"중국 면적: "<<CountryArea::CHINA<<"㎢"<<endl;
	cout<<"한국 면적: "<<CountryArea::SOUTH_KOREA<<"㎢"<<endl;
	return 0;
}

Output:

러시아 면적: 1707540㎢
캐나다 면적: 998467㎢
중국 면적: 957290㎢
한국 면적: 9922㎢

mutable 선언

: mutable로 선언된 멤버 변수는 const 함수내에서도 값의 변경이 가능

#include <iostream>
using namespace std;

class SoSimple
{
private:
	int num1;
	mutable int num2;
public:
	SoSimple(int n1, int n2)
		: num1(n1), num2(n2)
	{  }
	void ShowSimpleData() const
	{
		cout<<num1<<", "<<num2<<endl;
	}
	void CopyToNum2() const
	{
		num2=num1;
	}
};

int main(void)
{
	SoSimple sm(1, 2);
	sm.ShowSimpleData();
	sm.CopyToNum2();
	sm.ShowSimpleData();
	return 0;
}

Output:

1, 2
1, 1

C++ 스타일의 초기화

int num(20); // num=20;

int &ref(num); // &ref=num;

SoSimple sim2=sim1;

바로 위 문장은,

다음 문장과도 동일하게 해석된다.

SoSimple sim2(sim1);

객체 단위의 대입은 멤버 대 멤버의 복사가 일어난다. 이는 복사 생성자의 정의에 따라 달라질 수 있다.

#include <iostream>
using namespace std;

class SoSimple
{
private:
	int num1;
	int num2;
public:
	SoSimple(int n1, int n2)
		: num1(n1), num2(n2)
	{
		// empty
	}

	SoSimple(const SoSimple &copy)	// 복사 생성자의 정의
		: num1(copy.num2), num2(copy.num1)	// num1, num2값을 swap하도록 이니셜라이저
	{
		cout << "Called SoSimple(SoSimple &copy)" << endl;
	}

	void ShowSimpleData()
	{
		cout << num1 << endl;
		cout << num2 << endl;
	}
};

int main(void)
{
	SoSimple sim1(15, 30);
	sim1.ShowSimpleData();
	cout << "생성 및 초기화 직전" << endl;	
	SoSimple sim2(sim1);	// SoSimple sim2=sim;
	cout << "생성 및 초기화 직후" << endl;
	sim2.ShowSimpleData();
	return 0;
}

Output:

15
30
생성 및 초기화 직전
Called SoSimple(SoSimple &copy)
생성 및 초기화 직후
30
15

키워드 explicit

: 묵시적 형 변환을 막는 키워드

SoSimple sim2=sim1;

위의 문장은, 

아래와 같이 묵시적 형 변환이 일어난다.

SoSimple sim2(sim1); 

위와 같은 묵시적 형 변환은 복사 생성자를 explicit으로 선언하면 막을 수 있다.

SoSimple sim2=sim1; 과 같은 형태의 객체 생성과 초기화를 막아줌

이는 복사 생성자 뿐만 아닌 생성자도 마찬가지이다.

AAA 생성자를 explicit 선언하면

다음과 같은 형태의 객체 생성은 불가능해진다.

AAA obj=3;

이는 아래와 같이 묵시적 형 변환이 이뤄지기 때문이다.

AAA obj(3);

위의 소스에서 22행을 주석처리 후 23행의 주석 부분을 해제해  컴파일해보면, SoSimple로 변환하기 위한 적절한 생성자가 없으며,

초기화 중': 'int'에서 'SoSimple'(으)로 변환할 수 없다는 오류를 보게 된다.

c++의 대입의 의미가 다른 부분인데, 묵시적 호출을 원하지 않는다면 이렇게 explicit 키워드를 활용할 수 있다.

얕은 복사 (default 복사 생성자의 문제점)

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

class Person
{
	char * name;
	int age;
public:
	Person(char * myname, int myage)	// 생성자 정의
	{
		int len = strlen(myname) + 1;
		name = new char[len];	// new 키워드를 통한 동적 할당
		strcpy(name, myname);
		age = myage;
	}
	void ShowPersonInfo() const
	{
		cout << "이름: " << name << endl;
		cout << "나이: " << age << endl;
	}
	~Person()
	{
		delete[]name;	// delete 키워드를 이용한 메모리 공간 해제
		cout << "called destructor!" << endl;
	}
};

int main(void)
{
	Person man1("Lee dong woo", 29);
	Person man2 = man1;		// default 복사 생성자에 의한 멤버대 멤버 복사가 이뤄짐
	man1.ShowPersonInfo();	
	man2.ShowPersonInfo();
	return 0;
}

Output :

이름: Lee dong woo

나이: 29

이름: Lee dong woo

나이: 29

called destructor!

위 예제 실행시 에러가 나며, 실행결과를 보면 문제점을 볼 수 있다.

25행에는 소멸자의 호출할 확인할 문장을 출력하도록 한 것을 볼 수 있는데, 실행결과에서는 소멸자가 딱 한번 호출된다.

이는 default 복사 생성자 호출에 의한 당연한 결과이다.

man1 객체의 name은 문자열이 저장된 메모리 공간은 가리키는 형태가 되며, 복사된 man2 객체의 name도 마찬가지로 이 메모리 공간을 가리킬 뿐이다. 

참조만 하는 멤버 name을 단순 복사했기 때문에 하나의 문자열을 두 객체가 가리키게 된 것이다.

또한 man1 객체가 소멸될 때 man1 객체의 멤버 name이 참조하는 문자열이 사라져버린다. ( delete [ ]name; )

이후 man2 객체가 소멸될 때 다음의 문장은 문제가 된다.

 delete [ ]name; 

이미 지워진 문자열을 대상으로 delete 연산을 하려 하는 것이다. 따라서 복사 생성자를 새롭게 정의해 이러한 문제를 해결 할 필요가 있다.

'깊은 복사'를 위한 복사 생성자의 정의

동일한 문자열을 포인터 참조하는 것이 아닌 객체의 문자열 자체를 복사해 참조하도록 해야한다.

따라서 이 경우 인자는 &ref 가 되게 된다.

아래에서 깊은 복사를 위한 복사 생성자를 정의한 실행결과를 확인해볼 수 있다.

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

class Person
{
	char * name;
	int age;
public:
	Person(char * myname, int myage)	// 생성자 정의
	{
		int len = strlen(myname) + 1;
		name = new char[len];	// new 키워드를 통한 동적 할당
		strcpy(name, myname);
		age = myage;
	}
	Person(const Person &copy)	// 깊은 복사를 위한 복사 생성자의 정의
		: age(copy.age)	
	{
		int len = strlen(copy.name) + 1;
		name = new char[len];	// new 키워드를 통한 동적 할당
		strcpy(name, copy.name);		
	}
	void ShowPersonInfo() const
	{
		cout << "이름: " << name << endl;
		cout << "나이: " << age << endl;
	}
	~Person()
	{
		delete[]name;	// delete 키워드를 이용한 메모리 공간 해제
		cout << "called destructor!" << endl;
	}
};

int main(void)
{
	Person man1("Lee dong woo", 29);
	Person man2 = man1;		// 깊은 복사를 위한 복사 생성자 추가로 깊은 복사가 이뤄짐
	man1.ShowPersonInfo();
	man2.ShowPersonInfo();
	return 0;
}

Output :

이름: Lee Chul Soo

나이: 30

이름: Lee Chul Soo

나이: 30

called destructor!

called destructor!

복사 생성자의 호출 시점

1. 기존에 생성된 객체를 이용해 새로운 객체를 초기화는 경우

Person man1("Lee Chul Soo");

Person man2(man1); // 복사 생성자 호출

이 경우 man1과 man2의 멤버대 멤버 복사가 일어남은 앞의 예제에서 보았다.

2. Call-by-value 방식의 함수 호출 과정에서 객체를 인자로 전달하는 경우

#include <iostream>
using namespace std;

class SoSimple
{
private:
	int num;
public:
	SoSimple(int n) : num(n)
	{  }
	SoSimple(const SoSimple& copy) : num(copy.num)
	{
		cout << "Called SoSimple(const SoSimple& copy)" << endl;
	}
	void ShowData()
	{
		cout << "num: " << num << endl;
	}
};

void SimpleFuncObj(SoSimple ob)
{
	ob.ShowData();
}

int main(void)
{
	SoSimple obj(7);
	cout << "함수호출 전" << endl;
	SimpleFuncObj(obj);
	cout << "함수호출 후" << endl;
	return 0;
}

Output:

함수호출 전
Called SoSimple(const SoSimple& copy)
num: 7
함수호출 후

위의 예제 30행에서 아래와 같이 obj 객체가 생성 후 SimpleFuncObj 함수가 호출 될 때, 

obj의 복사 생성자가 호출되고 obj와 ob의 멤버대 멤버 복사가 일어나게 된다.

함수 호출과 함께 복사가 이뤄지는 형태는 다음 그림과 같다.

3. 객체를 반환하되, 참조형으로 반환하지 않는 경우

아래 예제에서는 obj객체 생성후 SimpleFuncObj 함수 호출과정에서 obj 객체를 인자로 전달하고 있다.

또한 함수 호출과정에서 ob 객체가 반환된다.

객체의 반환이란건 객체의 생성과 함께, 함수가 호출된 영역으로 복사해 넘긴다는 뜻과 같다.

객체가 반환이 될 때는 임시 객체 (Temporary Object)가 생성되게 된다.

이러한 임시객체의 특성은 리터럴 상수와도 비슷하다. (int num=3+4; 에서 3과 4)

메모리 공간에 할당이 되지만 금방 사라지게 될 객체이다.

AddNum 함수의 반환형이 참조형(SelfRef &)이므로 객체 자신을 참조할 수 있는 참조자를 반환함에 유의하자. (반환된 참조값을 가지고 함수를 연이어 호출)

#include <iostream>
using namespace std;

class SoSimple
{
private:
	int num;
public:
	SoSimple(int n) : num(n)
	{ }
	SoSimple(const SoSimple& copy) : num(copy.num)
	{
		cout << "Called SoSimple(const SoSimple& copy)" << endl;
	}
	SoSimple& AddNum(int n)
	{
		num += n;
		return *this;
	}
	void ShowData()
	{
		cout << "num: " << num << endl;
	}
};

SoSimple SimpleFuncObj(SoSimple ob)
{
	cout << "return 이전" << endl;
	return ob;
}

int main(void)
{
	SoSimple obj(7);
	SimpleFuncObj(obj).AddNum(30).ShowData();
	obj.ShowData();
	return 0;
}

Output:

Called SoSimple(const SoSimple& copy)
return 이전
Called SoSimple(const SoSimple& copy)
num: 37
num: 7

반환할 때 만들어진 객체의 소멸시점

#include <iostream>
using namespace std;

class Temporary
{
private:
	int num;
public:
	Temporary(int n) : num(n)
	{
		cout << "create obj: " << num << endl;
	}
	~Temporary()
	{
		cout << "destroy obj: " << num << endl;
	}
	void ShowTempInfo()
	{
		cout << "My num is " << num << endl;
	}
};

int main(void)
{
	Temporary(100);
	cout << "********** after make!" << endl << endl;

	Temporary(200).ShowTempInfo();
	cout << "********** after make!" << endl << endl;

	const Temporary &ref = Temporary(300);	// 참조값이 반환되므로 참조자로 참조 가능하다.
	cout << "********** end of main!" << endl << endl;
	return 0;
}

Output:

create obj: 100
destroy obj: 100
********** after make!

create obj: 200
My num is 200
destroy obj: 200
********** after make!

create obj: 300
********** end of main!

destroy obj: 300

위의 예제에서 객체 생성은 하지만 객체의 이름이 없으며, 이는 임시 객체의 생성을 뜻한다.

하지만 참조자를 이용하면 반환된 참조값을 이용해 참조 가능하다.

실행 결과를 보면 참조자에 참조되는 임시객체는 메모리 공간이 바로 소멸되지 않음을 알 수 있다.

return 전에 소멸자의 호출됨을 출력된 문장을 통해 확인이 가능하다.

객체 배열

: 객체를 기반으로 객체 배열의 선언이 가능하다.

클래스 이름이 SoSimple일 때, 객체 기반의 배열을 다음과 같이 선언한다.

SoSimple arr[10];

동적 할당

SoSimple * ptrArr = new SoSimple[10];

이러한 형태의 배열 선언은, 열개의 SoSimple 객체가 모여서 배열을 구성하는 형태이다.

이 경우에도 생성자는 호출이 되나, 배열 선언과정에서는 호출할 생성자를 별도로 명시하지 못한다. (생성자에 인자를 전달하지 못함)

위와 같이 객체 기반 배열이 생성되려면 다음 형태의 생성자가 반드시 정의되야 하낟.

So Simple() { . . . .}

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

class Person
{
private:
	char * name;
	int age;

public:
	Person(char * myname, int myage)
	{
		int len = strlen(myname) + 1;
		name = new char[len];
		strcpy(name, myname);
		age = myage;
	}
	Person()	// 배열 생성시 필요한 생성자 정의
	{
		name = NULL;
		age = 0;
		cout << "called Person()" << endl;
	}

	void SetPersonInfo(char * myname, int myage)	// 초기화 함수
	{
		name = myname;
		age = myage;
	}
	void ShowPersonInfo() const
	{
		cout << "이름: " << name << ", ";
		cout << "나이: " << age << endl;
	}

	~Person()
	{
		delete[]name;
		cout << "called destructor!" << endl;
	}
};

int main(void)
{
	Person parr[3];		// 객체 기반 배열의 선언

	char namestr[100];
	char * strptr;
	int age;
	int len;

	for (int i = 0; i<3; i++)	// for문을 통해 이름, 나이 입력받아서 객체를 초기화
	{
		cout << "이름: ";
		cin >> namestr;
		cout << "나이: ";
		cin >> age;

		len = strlen(namestr) + 1;
		strptr = new char[len];						
		strcpy(strptr, namestr);
		parr[i].SetPersonInfo(strptr, age);
	}

	parr[0].ShowPersonInfo();
	parr[1].ShowPersonInfo();
	parr[2].ShowPersonInfo();

	return 0;
}

Output :

called Person()

called Person()

called Person()

이름: 가가가가가가

나이: 1

이름: 나나나나나나나나

나이: 2

이름: 다다다다다다다다다

나이: 3

이름: 가가가가가가, 나이: 1

이름: 나나나나나나나나, 나이: 2

이름: 다다다다다다다다다, 나이: 3

called destructor!

called destructor!

called destructor!

객체 포인터 배열

: 객체의 주소 값 저장이 가능한 포인터 변수로 이뤄진 배열

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

class Person
{
private:
	char * name;
	int age;
public:
	Person(char * myname, int myage)
	{
		int len = strlen(myname) + 1;
		name = new char[len];
		strcpy(name, myname);
		age = myage;
	}
	Person()
	{
		name = NULL;
		age = 0;
		cout << "called Person()" << endl;
	}
	void SetPersonInfo(char * myname, int myage)
	{
		name = myname;
		age = myage;
	}
	void ShowPersonInfo() const
	{
		cout << "이름: " << name << ", ";
		cout << "나이: " << age << endl;
	}
	~Person()
	{
		delete[]name;
		cout << "" << endl;		// 소멸자 호출과 delete 연산을 확인하기 위함
	}
};

int main(void)
{
	Person * parr[3];	// 객체 포인터 배열 선언

	char namestr[100];
	char * strptr;
	int age;
	int len;

	for (int i = 0; i < 3; i++)
	{
		cout << "이름: ";
		cin >> namestr;
		cout << "나이: ";
		cin >> age;

		parr[i] = new Person(namestr, age);	// 객체를 생성해, 주소값을 배열에 저장

	}
	for (int i = 0; i < 3; i++)
	{
		parr[i]->ShowPersonInfo();
		delete parr[i];		// new 연산을 한만큼 delete 연산 진행
	}

	return 0;
}

Output : 

이름: 가가가가, 나이: 22

이름: 나나나나나, 나이: 33

이름: 다다다다다다다, 나이: 44

이름: 가가가가, 나이: 22

이름: 나나나나나, 나이: 33

이름: 다다다다다다다, 나이: 44

this 포인터의 이해

: 멤버 함수 내에서 객체 자신을 가리키는 용도로 사용되는 포인터

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

class SoSimple
{
	int num;
public:
	SoSimple(int n) : num(n)	// 생성자, 멤버 이니셜라이저 int num=n;
	{
		cout << "num=" << num << ", ";
		cout << "address=" << this << endl;
	}

	void ShowSimpleData()
	{
		cout << num << endl;
	}

	SoSimple * GetThisPointer()
	{
		return this;	
		// this를 반환. 이는 this가 가리키는 객체의 포인터를 반환하라는 의미로, 반환형이 SoSimple * 형 
	}
};

int main(void)
{
	SoSimple sim1(100);
	SoSimple * ptr1 = sim1.GetThisPointer();	// sim1 객체의 주소값을 * ptr1 에 저장	
	cout << ptr1 << ", ";		// ptr1에 저장된 주소값 출력
	ptr1->ShowSimpleData();		// ptr1이 가리키는 객체의 ShowSimpleData 함수 호출

	SoSimple sim2(200);
	SoSimple * ptr2 = sim2.GetThisPointer();
	cout << ptr2 << ", ";
	ptr2->ShowSimpleData();
	return 0;
}

Output:

num=100, address=0xffeb3708
0xffeb3708, 100
num=200, address=0xffeb3704
0xffeb3704, 200

this는 객체 자신을 가리키며, 위치한 객체내에서 자료형과 주소 값이 결정된다.

0xffeb3708에 할당된 sim1 객체 내에서는 this는 sim1 형의 포인터이면서 그 주소 값은 0xffeb3708 이 된다.

this 포인터 활용

객체의 주소 값으로 접근가능한 대상은 멤버 변수이다.

따라서 this->num1은 멤버 변수 num1을 의미한다.

위의 생성자는 아래의 같은 형태의 생성자로 대신할 수도 있다.

// this 포인터가 아닌 이니셜라이저를 통한 초기화 예

멤버 이니셜라이저에서는 this포인터 사용불가. 

Self-Reference의 반환

: 객체 자신을 참조할 수 있는 참조자

this포인터를 이용해, 객체가 자신의 참조에 사용할 수 있는 참조자의 반환문을 구성 가능

#include <iostream>
using namespace std;

class SelfRef
{
private:
	int num;
public:
	SelfRef(int n) : num(n)
	{
		cout << "객체생성" << endl;
	}
	SelfRef& Adder(int n)
	{
		num += n;
		return *this;	// 이는 객체 자신의 포인터가 아닌 객체 자신을 반환
		// 함수의 반환형이 참조형(SelfRef &)이므로 객체 자신을 참조할 수 있는 참조자 반환
	}
	SelfRef& ShowTwoNumber()
	{
		cout << num << endl;
		return *this;
	}
};

int main(void)
{
	SelfRef obj(3);
	SelfRef &ref = obj.Adder(2);	// 객체 obj의 참조값을 반환, 참조자 ref가 객체 obj의 참조자가 됨

	obj.ShowTwoNumber();
	ref.ShowTwoNumber();

	ref.Adder(1).ShowTwoNumber().Adder(2).ShowTwoNumber();	
	return 0;
}

Output:

객체생성
5
5
6
8

34행에서  객체 ref의 Adder함수가 호출. Adder함수는 참조값을 반환하므로, 반환된 참조 값을 가지고 ShowTwoNumber 함수 호출이 가능하다.

마찬가지로 ShowTwoNumber가 반환하는 참조 값을 이용해 다시금 함수를 이어서 호출 할 수 있게 된다.

이는 두 함수 Adder, ShowTwoNumber가 객체의 참조 값을 반환하기 때문에 가능하다.

생성자 (constructor)

: 클래스의 이름과 동일한 이름의 함수이면서,

반환형이 선언되지 않았고 실제 반환하지 않는 함수가 생성자

생성자는 객체 생성시 멤버변수의 초기화에 사용가능 

(객체 생성시 생성자가 딱 한번 호출)

- 위에서 생성자가 정의되었으니 객체 생성과정에서 자동호출되는 생성자에게 전달할 인자의 정보를 추가

SimpleClass sc(20) // 생성자에 20 전달 (stack 할당)

SimpleClass * ptr = new SimpleClass(30); // (heap에 동적 할당)

생성자도 오버로딩과 매개변수의 default값 설정이 가능하다.

생성자의 오버로딩

#include <iostream>
using namespace std;

class SimpleClass
{
	int num1;
	int num2;

public:
	SimpleClass()
	{
		num1=0;
		num2=0;
	}
	SimpleClass(int n)
	{
		num1=n;
		num2=0;
	}
	SimpleClass(int n1, int n2)
	{
		num1=n1;
		num2=n2;
	}

	void ShowData() const
	{
		cout<<num1<<' '<<num2<<endl;
	}
};

int main(void)
{
	SimpleClass sc1;
	sc1.ShowData();

	SimpleClass sc2(100);
	sc2.ShowData();

	SimpleClass sc3(100, 200);
	sc3.ShowData();

	return 0;
}

Output:

0 0
100 0
100 200

매개변수의 default 값 설정

#include <iostream>
using namespace std;

class SimpleClass
{
	int num1;
	int num2;

public:	
	SimpleClass(int n1=0, int n2=0)
	{
		num1=n1;
		num2=n2;
	}

	void ShowData() const
	{
		cout<<num1<<' '<<num2<<endl;
	}
};

int main(void)
{
	SimpleClass sc1;
	sc1.ShowData();

	SimpleClass sc2(100);
	sc2.ShowData();

	SimpleClass sc3(100, 200);
	sc3.ShowData();
	return 0;
}

Output:

0 0
100 0
100 200

클래스에 생성자가 하나도 정의되어 있지 않아도, 객체 생성시 생성자가 호출

-> 컴파일러에 의해 다음과 같은 default 생성자가 자동 삽입 

SimpleClass() { }

이는 new 연산자를 이용하는 객체의 생성에도 해당된다.

단, 다음과 같이 new연산자 대신 malloc 함수를 이용하면 생성자는 호출되지 않는다.

AAA * ptr = (AAA*)malloc(sizeof(AAA));    // AAA 클래스의 크기 정보만 바이트 단위로 전달

객체의 생성 예들

SimpleClass * ptr1=new SimpleClass();    (o)

SimpleClass * ptr1=new SimpleClass;    (o)

SimpleClass sc1;   (o)

SimpleClass sc1(); (x)

-> 이러한 형태의 객체 생성은 불가

컴파일러가 함수의 원형 선언인지 객체 생성인지 판단 불가

(sc1 함수이며, 인자가 void형이고 반환형이 SimpleClass인 함수라고 볼 수도 있다.)

다음예제와 같이 SimpleClass sc1()같은 유형의 문장은 함수의 원형선언으로 볼 수도 있으므로, 

이러한 유형의 문장은 객체 생성이 아닌 함수의 원형선언에만 사용가능하다.

#include <iostream>
using namespace std;

class SimpleClass
{
	int num1;
	int num2;

public:
	SimpleClass(int n1=0, int n2=0)
	{
		num1=n1;
		num2=n2;
	}

	void ShowData() const
	{
		cout<<num1<<' '<<num2<<endl;
	}
};

int main(void)
{
	SimpleClass sc1();    // 함수의 원형 선언!
	SimpleClass mysc=sc1(); // sc1 함수를 호출해, 이 때 반환되는 객체의 값으로 mysc 객체를 초기화
	mysc.ShowData();

	return 0;
}

SimpleClass sc1()
{
	SimpleClass sc(20, 30);
	return sc;
}

Output:

20 30

Member Initializer(멤버 이니셜라이저)를 이용한 멤버 초기화

위에서 Point 클래스에 생성자를 적용하고 객체를 생성하는 것은 무리가 없다.

하지만 Rectangle 클래스의 생성자 정의는 큰 문제가 있다. Rectangle 클래스는 두 개의 Point 객체를 멤버로 지니고 있기 때문이다. (upLeft, lowRight)

위의 클래스에서 생성자가 삽입되었으므로 default 생성자는 호출되지 않는다.

그렇다고 하여 void 생성자를 별도로 추가한다면? 생성자도 오버로딩이 되기 때문에 객체는 생성되겠지만 유효한 값을 전달받지 못하게 된다. (쓰레기 값)

따라서 Rectangle 객체가 생성될 때, 두 개의 Point 객체가 생성되며, 각 인자가 유효한 값을 전달받을 수 있는 생성자를 호출 할 수 있어야 한다.

이 문제 해결을 위해 '멤버 이니셜라이저'를 이용하면, 객체의 초기화를 수월하게 해줄 생성자를 호출할 수 있게 된다.

// 생성자가 추가된 Rectangle 클래스의 선언

// Rectangle 클래스의 생성자 정의

다음의 문장이 '멤버 이니셜라이저'를 뜻하며, 이것을 통해 수월하게 멤버 초기화가 가능하다.

:upLeft(x1, y1), lowRight(x2, y2)

"객체 upLeft의 생성과정에서 x1, y1을 인자로 전달받는 생성자 호출,

객체 lowRight의 생성과정에서 x2, y2을 인자로 전달받는 생성자 호출"

범위지정 연산자 ::

: namespace외에도 명시적(explicitly)으로 클래스(구조체)멤버나 전역변수 지정

다음은 Point, Rectangle 클래스에 생성자를 추가한 예제이다.

 Point.h

 Point.cpp

 Rectangle.h

 Rectangle.cpp

 RectangleConstructor.cpp

Output : 

좌 상단: [1, 1]

우 하단: [5, 5]

 객체가 아닌 멤버 변수의 초기화

: 이렇게 초기화 하는 경우 멤버 변수가 선언과 동시에 초기화

위의 클래스에서 생성자의 몸체에서 보인 초기화,

num2=2;

는 다음의 두 문장과 같다.

int num2;

num2=n2;

하지만 이니셜라이저를 이용한 다음의 초기화,

num1(n1)

는 다음의 문장과 같다.

int num1=n1;

따라서 이러한 특성을 이용해 const 멤버변수도 이니셜라이저를 이용해 초기화 가능하다.