Special Effects FX 스스로를 감동시켜야 최선을 다 한 것이다.

#include <iostream>

#include <cstring>

using namespace std;

namespace COMP_POS

{

enum {CLERK, SENIOR, ASSIST, MANAGER};

void Select(int pos)

{

switch(pos)

{

case CLERK:

cout<<"사원"<<endl; break;

case SENIOR:

cout<<"주임"<<endl; break;

case ASSIST:

cout<<"대리"<<endl; break;

case MANAGER:

cout<<"과장"<<endl; break;

}

}

}

class NameCard

{

private:

char * name;

char * companyName;

char * tel;

int position;

public:

NameCard(char* na, char* comp, char* tele, int pos)        //생성자

:position(pos)                                

{

int len1 = strlen(na)+1;

int len2 = strlen(comp)+1;

int len3 = strlen(tele)+1;

name = new char[len1];

strcpy(name, na);

companyName = new char[len2];

strcpy(companyName, comp);

tel = new char[len3];

strcpy(tel, tele);

}

void ShowNameCardInfo(void) const

{

cout<<"이름 :"<<name<<endl;

cout<<"회사 :"<<companyName<<endl;

cout<<"전화번호 :"<<tel<<endl;

cout<<"직급 :"; COMP_POS::Select(position);

cout<<endl;

}

~NameCard()                                                            //소멸자

{

delete []name;

delete []companyName;

delete []tel;

}

};

int main(void)

{

NameCard manClerk("Lee", "abc", "010-875-5543", COMP_POS::CLERK);

NameCard manSenior("Jane", "def", "010-232-3439", COMP_POS::SENIOR);

NameCard manAssist("Jeon", "ghi", "010-844-1245", COMP_POS::ASSIST);

manClerk.ShowNameCardInfo();

manSenior.ShowNameCardInfo();

manAssist.ShowNameCardInfo();

return 0;

}

실행결과

Point 클래스는 점의 좌표를 알려주는 클래스이고, Circle 클래스는 원의 반지름과 중심점의 좌표를 알려주는 클래스이다. 그리고 마지막으로 Ring클래스는 Point, Circle 클래스를 묶는(캡슐화) 클래스이다. Ring클래스는 좌표정보와 반지름을 입력받아 Point, Circle에 전달한다. 

#include <iostream>

using namespace std;

class Point

{

private:

int xpos, ypos;

public:

Point(int x, int y) : xpos(x), ypos(y)         //Constructor

{}

void ShowPointInfo(void) const

{

cout<<"["<<xpos<<", "<<ypos<<"]"<<endl;

}

};

class Circle

{

private:

Point coord;

const int rad;

public:

Circle(const int x, const int y, const int r)

:coord(x, y), rad(r) //Constructor

{}

void ShowCircleInfo(void) const

{

cout<<"radius: "<<rad<<endl;

coord.ShowPointInfo();

}

};

class Ring

{

private:

Circle c1;

Circle c2;

public:

Ring(int x1, int y1, int r1, int x2, int y2, int r2)

:c1(x1, y1, r1), c2(x2, y2, r2)         //Constructor

{}

void ShowRingInfo(void) const

{

cout<<"Inner Circle Info..."<<endl;

c1.ShowCircleInfo();

cout<<"Outter Circle Info..."<<endl;

c2.ShowCircleInfo();

}

};

int main(void)

{

Ring ring(1, 1, 4, 2, 2, 9);

ring.ShowRingInfo();

return 0;

}

실행결과

객체생성시 반드시 호출되는 것이 생성자라면, 객체소멸시 반드시 호출되는 것은 소멸자이다.

* 클래스의 이름 앞에 '~'가 붙은 형태의 이름을 갖는다.

* 반환형이 선언되어 있지 않으며, 실제로 반환하지 않는다.

* 매개변수는 void형으로 선언되어야 하기 때문에 오버로딩도, 디폴트 값 설정도 불가능하다.

ex) ~AAA(void) {...}

소멸자는 객체소멸 과정에서 자동으로 호출이 된다. 그리고 프로그래머가 직접 소멸자를 정의하지 않으면, 디폴트 생성자와 마찬가지로 아무런 일도 하지 않는 디폴트 소멸자가 자동으로 삽입된다.

class AAA

{

// empty class

};

class AAA

{

public:

AAA() {}

~AAA() {}

};

위의 2개의 클래스는 100% 동일한 클래스이다.

소멸자는 대표적으로 말하자면 클래스내에서 힙영역에 생성한 메모리공간을 없애는데 사용이 된다.

private 생성자

: 클래스 내부에서만 객체의 생성을 허용하려는 목적으로 생성자를 private으로  선언하기도 한다.

여기서는 힙 영역에 생성된 객체를 참조의 형태로 반환하고 있다.

"힙에 할당된 메모리 공간은 변수로 간주하여, 참조자를 통한 참조가 가능하다."

private 생성자는 때로 유용하게 사용된다. 특히, 객체의 생성방법을 제한하고자 하는 경우에는 매우 유용하게 사용이 된다.

메모리 공간의 할당 이후에 생성자의 호출까지 완료되어야 '객체'라 할 수 있다. 

즉, 객체가 되기 위해서는 반드시 하나의 생성자가 호출되어야 한다. 그리고 이러한 기중에 예외를 두지 않기 위해서 생성자를 정의하지 않는 클래스에는 C++ 컴파일러에 의해서 디폴트 생성자라는 것이 자동으로 삽입된다.

- 디폴트 생성자는 인자를 받지 않으며, 내부적으로 아무런 일도 하지 않는 생성자이다. -

class A

{

int num;

public:

int GetNum(void)

{

return num;

}

};

class A

{

int num;

public:

A() {} //디폴트 생성자.

int GetNum(void)

{

return num;

}

}; 

위의 2개의 클래스는 완전히 동일하다.

따라서, 모든 객체는 한번의 생성자 호출을 동반한다. 이는 new 연산자를 이용한 객체의 생성에도 해당하는 이야기다. 

즉, 위의 클래스를 다음의 형태로 생성해도 객체의 생성과정에서 생성자가 호출된다.

A * ptr = new A;

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

A * ptr = (A*)malloc(sizeof(A));

malloc 함수호출 시, 실제로는 A클래스의 크기정보만 바이트 단위로 전달되기 때문에 생성자가 호출이 되지 않는다.

$ 객체를 동적으로 할당하려는 경우에는 반드시 new 연산자를 이용해야 한다.

생성자 불일치

위에 보인, 매개변수가 void형으로 선언되는 디폴트 생성자는 생성자가 하나도 정의되어 있지 않을 때에만 삽입이 된다. 즉, 다음과 같이 정의된 클래스에는 디폴트 생성자가 삽입되지 않는다.

class A

{

int num;

public:

A(int n) : num(n) {} //int형 하나를 인자로 받는 생성자.

};

따라서 다음의 형태로는 객체성성이 가능하다.

A simple(10);

A * simPtr = new A(10);

그러나 다음의 형태로는 개체생성이 불가능하다. 다음 문장에서 요구하는 생성자가 정의되지도, 자동으로 삽입되지도 않았기 때문이다.

A simple;

A * simPtr = new A();

따라서 위의 형태로 객체를 생성하기 원한다면, 다음의 형태로 생성자를 추가해야 한다.

A() : num(0) {}

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

11라인에서 이니셜라이저가 쓰였는데 이것은 이렇게 된다. int num1 = n1;

또 다른 멤버 이니셜라이저를 이용한 멤버 초기화

class Rectangle

{

private:

Point upLeft;

Point lowRight;

public:

Rectangle(const int &x1, const int &y1, const int &x2, const int &y2)

:upLeft(x1, y1), lowRight(x2, y2) //이니셜라이저

{

                //empty

}

};

/* 여기서 Rectangle 클래스는 두 점의 정보를 직접 전달받을 수 있게 정의되어있다. 그리고 "이니셜라이저"를 통해 이 정보를 멤버인 Point 객체를 초기화하고있다. */

멤버 이니셜라이저가 의미하는 바

1. 객체 upLeft의 생성과정에서 x1과 y1을 인자로 전달받는 생성자를 호출하라.

2. 객체 lowRight의 생성과정에서 x2와 y2를 인자로 전달받는 생성자를 호출하라.

이렇듯 멤버 이니셜라이저는 멤버변수로 선언된 객체의 생성자 호출에 활용된다.

따라서, 프로그래머는 생성자의 몸체에서 초기화 하는 방법과 이니셜라이저를 이용하는 초기화 방법 중에서 선택이 가능하다.

그러나 일반적으로 멤버변수의 초기화에 있어서는 이니셜라이저를 선호하는 편이다.

여기에는 다음 두 가지 이점이 있기 때문이다.

1. 초기화의 대상을 명확히 인식할 수 있다.

2. 성능에 약간의 이점이 있다.

생 성 자

클래스 정의에서 다음의 형태를 띠는 함수가 생성자이다.

# 클래스의 이름과 함수의 이름이 동일하다.

# 반환형이 선언되어 있지 않으며, 실제로 반환하지 않는다.

이러한 유형의 함수를 가리켜 '생성자'라 하며, 생성자는 "객체 생성시 딱 한번 호출된다."

----------------------------------------------------------------------------------------------------------------------------------------------------------------

* 생성자도 함수의 일종이니 오버로딩이 가능하다.

* 생성자도 함수의 일종이니 매개변수에 '디폴트 값'을 설정할 수 있다.

28라인의 함수 void SimpleClass(void) 와 46라인의 함수void SimpleClass(int n1=1, int n2=0) 를 다음과 같은 문장으로 구성하면 안된다.

SimpleClass sc1();                (X)

다음과 같이 구성을 해야 한다.

SimpleClass sc1;                                                    (O)

SimpleClass * ptr = new SimpleClass;                  (O)

SimpleClass * ptr = new SimpleClass();                (O)

매개변수가 선언되어 있지 않으니 소괄호를 생략할 수 있다.

그렇다면, 다음 문장도 허용이 가능할 것 같은데 허용이 안된다!!

SimpleClass sc1();                (X)

예제)

출력 결과 : 20, 30

※ 보통 함수의 원형은 전역적으로(함수 밖에) 선언하지만, 위 예제에서 보이듯이 함수내에 지역적으로도 선언 가능하다.

위 예제의 42라인의 문장은 이러한 함수의 원형 선언에 해당된다. 즉, 이 문장을 void형(인자를 받지 않는) 생성자의 호출문으로 인정해 버리면, 컴파일러는 이러한 문장을 만났을 때, 이것이 객체생성문인지 함수의 원형선언인지를 구분할 수 없게 된다.

그래서 이러한 유형의 문장은 객체생성이 아닌, 함수의 원형선언에만 사용하기로 약속하였다.