가상함수 테이블 포인터(vptr)을 이용해 가상함수를 호출하기 때문에 객체의 처음 4바이트가 어떤 클래스의 가상 함수 테이블을 가리키는지에 따라 다른 가상 함수를 테이블이 구체적으로 어떻게 생성되고 객체는 자신의 처음 4바이트를 어떻게 초기화시키는지 알아보자

가상 함수 테이블이 클래스 단위로 생성된다고 했는데, C++ 컴파일러가 가상함수 테이블을 클래스 단위로 생성하는 것은 객체의 메모리 크기를 줄이기 위해서 이다. 만약 객체 메모리 영역에 직접 가상 함수 포인터를 생성한다면 가상 함수 개수에 비례하여 객체의 크기는 늘어날 것이다.

어차피 동일한 클래스로 생성된 객체들은 동일 가상 함수를 호출해야 하기 때문에 이것은 메모리 낭비가 아닐수 없다.

그래서 C++ 컴파일러는 가상함수를 가리키는 포인터를 테이블로 구성하고 이것을 클래스 단위로 생성한 다음 이 테이블에 대한 포인터를 객체 맨 앞에 4바이트에 설정함으로서 간단하게 객체에 가상함수 테이블을 포함하는 효과를 가질수 있도록 한다. 이렇게 C++ 컴파일러가 가상함수 테이블을 관리하기 때문에 가상함수를 가지는 클래스는 가상함수의 개수에 상관없이 객체의 크기는 항상 멤버 변수의 총 크기에 4바이트를 더한 크기로 생성될수 있게 된다.

가상 함수에 대한 모든 원리는 테이블과 관련이 있기 때문에 이것에 대해 좀더 알아보자

가상 함수 테이블의 크기는 해당 클래스에 정의된 가상함수 개수에 비례한다.

여기서 정의된 가상함수란 상위 클래스에 정의된 가상함수도 포함한다.

그래서 상위 클래스에 두개의 가상함수가 정의되고, 자신의 클래스에 하나의 가상 함수가 정의 된다면 가상 함수 테이블 내의 항목은 상위 클래스의 가상 함수를 가리킨다. 너무나 당연한 이야기지만 가상 함수 테이블 내의 항목은 재정의 된 가상 함수를 가리킨다. 가상 함수 테이블의 이런 특징 때문에 어떤 클래스가 가상 함수를 상속 받아 가상 함수를 재정의 하지 않고 객체를 생성하여 해당 가상 함수를 호출하면 상위 클래스에 정의된 가상 함수가 호출된다. 

속성

볼드체로 표시된 것은 필수 속성, 회색으로 표시된 것은 HTML 4.01에서 권장하지 않는(deprecated) 속성입니다.

예제

 <OBJECT data="mlk.mov" type="video/quicktime" title="Martin Luther King's &quot;I Have a Dream&quot; speech"
 width="150" height="150"> <PARAM name="pluginspage" value="http://quicktime.apple.com/"> <PARAM name="autoplay" value="true"> <OBJECT data="mlk.wav" type="audio/x-wav"  title="Martin Luther King's &quot;I Have a Dream&quot; speech"> <PARAM name="autostart" value="true"> <PARAM name="hidden" value="true"> <A href="mlk.html">Full text of Martin Luther King's "I Have a Dream" speech</A> </OBJECT> </OBJECT>    

 <OBJECT classid="java:yahtzee.class" codetype="application/java" width="400" height="250" title="my yahtzee game" standby="Get ready to play Yahtzee!">   Enable Java support to play!</OBJECT> 

 <OBJECT data="example.gif" title="Nice Photo" /> 

<OBJECT classid="clsid:F08DF954-8592-11D1-B16A-00C0F0283628" id="Slider1" width="200" height="40" border="2">  <PARAM name="BorderStyle" value="1" />  <PARAM name="MousePointer" value="0" />  <PARAM name="Enabled" value="1" />  <PARAM name="Min" value="0" />  <PARAM name="Max" value="10" /></OBJECT>

지원 브라우저/HTML 버전

이 태그를 지원하는 브라우저의 최소 버전은 아래와 같습니다.

IE 3, NN n/a, HTML 4

참고

• OBJECT 요소는 인라인 요소(Inline Element)와 블록 요소(Block Element) 안에 모두 쓰일 수 있습니다.
• OBJECT 요소의 내용은 OBJECT 부모 요소 안에 포함될 수 있는 요소여야 합니다. 예를 들어 OBJECT가 A 요소 안에 포함되어 있다면, OBJECT는 블록 요소를 내용으로 포함할 수 없습니다.

#include <iostream>
using std::endl;
using std::cout;

template <typename T>
class Data
{
     T data;
public:
     Data(T d);
     void SetData(T d);
     T GetData();
};

template <typename T>
Data<T>::Data(T d) {
     data = d;
}

template <typename T>
void Data<T>::SetData(T d) {
     data = d;
}

template <typename T>
T Data<T>::GetData() {
     return data;
}

int main(void)
{
     Data<int> d1(0);
     d1.SetData(10);
     Data<char> d2('a');
 
     cout << d1.GetData() << endl;
     cout << d2.GetData() << endl;

    
     return 0;
}

사실 클래스가 아니라 Data <T> 템플릿이다.

템플릿은 함수 오버로딩과 유사한 형태로 구성이 된다.

템플릿을 기반으로 해서 다양한 형태의 코드가 컴파일 타임에 만들어진다.
즉 컴파일러가 만든다.

따라서 템플릿은 함수가 아니라, 함수를 만들어 내는 형틀에 지나지 않는다. 함수 템플릿이다.
따라서 템플릿 함수란 템플릿이 만든 다양한 형태의 함수를 만든다. 이것이 템플릿 함수이다.

인자 형태를 보며 템플릿 함수를 생성한다.

-템플릿은 선언과 정의를 분리하면 안된다.
 왜냐하면 컴파일 타임에 참조가 가능해야 하기 때문이다.

#include <iostream>
using std::cout;
using std::endl;

class Person
{
     int age;
     char name[20];
public:
     int GetAge() const {
         return age;
     }

     const char* GetName() const {
          return name; 
     }

     Person(int _age=1, char* _name="noname") {
          age=_age;
          strcpy(name, _name);
     }
};

class Student: public Person
{
     char major[20];
public:
     Student(char* _major) {
         strcpy(major, _major);
     }
     const char* GetMajor() const {
          return major;
     }
     void ShowData() const {
          cout << "이름 : " << GetName() << endl;
          cout << "나이 : " << GetAge() << endl;
          cout << "전공 : " << GetMajor() << endl;
     }
};

int main(void)
{
     Student zzang2k("computer");

     zzang2k.ShowData();

    
     return 0;
}

class Student
{
     const int id;
     int age;
     char name[20];
     char major[30];
public:
     Student(int _id, int _age, char* _name, char* _major):id(_id)
     {
          id=_id;
          age=_age;
          strcpy(name, _name);
          strcpy(major, _major);
     }
};

이 같은 경우 먼저 멤버변수 id가 메모리에 할당되고 쓰레기 값으로 채워진다. 그리고 생성자를 호출하여 초기화하려 하면 const키워드로 인해 컴파일 오류가 난다.

따라서 :id(_id) 와 같이 이니셜라이져(initializer) 를 이용하여 초기화 해야 한다.
이는 메모리가 할당되고 나서 생성자 몸체 부분이 실행되기 이전에 실행되고,
쓰레기 값이 들어가기 이전에 실행 된다. 따라서 const 키워드도 초기화 할 수 있다.



함수 상수화
멤버 변수 뒤에 const 키워드를 쓰면 해당 함수에서는 멤버 변수의 값 변경을 허용하지 않겠다라는 의미
왜 함수가 상수화 되었는데 멤버 변수를 조작하려 하느냐!
--> 프로그램을 안정적으로 구성하는데 도움

class Student
{
     const int id;
     int age;
     char name[20];
     char major[30];
public:
     Student(int _id, int _age, char* _name, char* _major):id(_id), age(_age)
     {
          strcpy(name, _name);
          strcpy(major, _major);
     }

    
     void ShowData() const
     {
          //age = 20; 이와 같이 조작하는 코드를 넣으면 컴파일 오류발생.
          cout<<"이름: "<<name<<endl;
          cout<<"나이: "<<age<<endl;
          cout<<"학번: "<<id<<endl;
          cout<<"학과: "<<major<<endl;
     }
};



조작할 수 있는 동기를 제공하지 않는다.
예를 들어 

class A {
     int cnt;

     int* GetPtr() const{
          return &cnt;  // Compile Error
     }
}
이 코드 역시 에러이다. 왜냐하면 GetPtr 함수를 호출하여 리턴 받은 놈은 주소를 얻기 때문에 변경할 여지가 충분히 있다.
따라서 참조만 하려고 한다면

class A {
     int cnt;

     const int* GetPtr() const{
          return &cnt;  
     }
}

이렇게 빼도박도 못하게 확실하게 해줘야 한다.



class A {
     int cnt;
     
     void ShowData() const {
          ShowIntro(); // Compile Error
          cout<<cnt<<endl;  
     }
    
     void ShowIntro() const{
          cout<<"현재 count의 값 : "<<endl;
     }
};

이건 왜 오류일까?
상수화 된 함수 내에서 상수화되지 않은 함수를 호출했다.
ShowIntro 함수가 멤버 조작을 하지 않는 함수라고 해도 컴파일러는 그걸 모른다. 왜냐 const되지 않았기 때문에.
컴파일러는 const냐 아니냐만 검사한다. 따라서 const 키워드를 붙이면 오류가 없겠지.

2. const 객체

기본적으로 변수, 함수에 쓰이는 const와 동일
다른 거 없다. 똑같이 생각해라.
const AAA aaa(10);

const 객체는 const 함수 이외이는 호출이 불가능하다.
데이터 변경이 허용되지 않는 객체!

const도 함수 오버로딩 조건에 포함된다.

#include <iostream>
using std::cout;
using std::endl;

class AAA
{
     int num;
public :
     AAA(int _num) : num(_num) {}

    
     void ShowData(){
          cout<<"void ShowData() 호출"<<endl;
          cout<<num<<endl;
     }
    
     void ShowData() const {
          cout<<"void ShowData() const 호출"<<endl;
          cout<<num<<endl;
     }
};

 
int main()
{
     const AAA aaa1(20);
     AAA aaa2(70);

     aaa1.ShowData();
     aaa2.ShowData();    //aaa2는 const 이다. 따라서 const 멤버 함수가 호출된다.

     return 0;
}

3. static 키워드
static 키워드는 지역 변수를 전역 변수의 형태로 만든다.
따라서 전역변수는 아무 곳에서나 참조 가능. 하지만 static 변수는 전역을 파일로 제한.

객체 지향에는 전역이라는 개념이 존재하지 않는다.
따라서 static 멤버가 등장했다.

#include<iostream>
using std::cout;
using std::endl;

class Person
{
     char name[20];
     int age;
     static int count;
public:
     Person(char* _name, int _age)
     {
          strcpy(name, _name);
          age=_age;
          cout<<count++<<"번째 Person 객체 생성"<<endl;
     }
    
     void ShowData(){
          cout<<"이름: "<<name;
          cout<<"나이: "<<age;
     }
};

int Person::count=1; // static 멤버 초기화

int main(void)
{
     Person p1("Lee", 13);
     Person p2("Hong", 22);

    
     return 0;
}

static 멤버의 특징
(정확히 말하면 static 멤버라는 표현은 없다. 왜냐면 클래스 멤버가 아니기 때문에.-> 클래스 객체 생성 전에 메모리에 할당되니깐!!)

-클래스 변수, 클래스 함수라 한다.
-메인함수 호출 이전에 메모리 공간에 올라가서 초기화된다(전역변수와 동일)
-그냥 초기화가 안된다. static 멤버 초기화무능로 초기화해야 한다.

static 멤버 변수(클래스변수)는 직접 접근 권한, 가릴 수 있는 권한(권한 지정 키워드에 영향을 받는다)을 제공한다.

생성자 내에서 초기화 할 수 없다. 왜냐 객체 생성 시 마다 초기화 되어야 한다. 말이 안된다.
따라서 static 멤버 초기 문장으로 초기화 해야 한다.

int Person::count=1; // static 멤버 초기화

4. explicit & mutable

explicit : 명시적 호출만 허용을 한다.

#include<iostream>
using std::cout;
using std::endl;

class AAA
{
public:
   explicit AAA(int n){
        cout<<"explicit AAA(int n)"<<endl;
     }
};

int main(void)
{
    // AAA a1=10;        //이 문장은 묵시적으로 아래와 같이 형변환되어 호출된다. 따라서 explicit 선언시 이와같이 하면 오류가 난다. 왜냐. explicit은 명시적으로만 사용하라라는 의미니깐!

        AAA a1(10);

     
    return 0;
}

#include<iostream>
using std::cout;
using std::endl;

class AAA
{
private:
     mutable int val1;
     int val2;

public:
     void SetData(int a, int b) const 
     {
          val1=a;  // val1이 mutable이므로 OK!
          val2=b;  // Error!
     }
};

int main(void)
{
     AAA a1;
     a1.SetData(10, 20);
    
     return 0;
}

AAA a1 = 10;
AAA a1(10);

위의 두 문장은 같다. 아래와 같이 묵시적으로 변환된다고 생각해라!

int main(void)
{
    int val1(20);    //val1 이라는 변수를 20으로 초기화 하겠다.
    AAA a1(10);

    ..........
}

class AAA
{
    public:
        AAA() { }
        AAA(int i) { }
        AAA(const AAA& a) { }        //복사 생성자
};

int main(void)
{
    AAA obj1;
    AAA obj2(10);
    AAA obj3(obj2);
    
    return 0;
}

복사 생성자는 자신과 동일한 타입의 객체에 대한 레퍼런스를 인자로 받는다
복사 생성자를 지정해주지 않으면 디폴트 복사 생성자가 삽입된다.

따라서,
디폴트 생성자, 디폴트 소멸자, 디폴트 복사 생성자는 컴파일러가 자동으로 삽입힌다.
디폴트 생성자/소멸자는 아무일도 하지 않지만,
디폴트 복사 생성자는 멤버 대 멤버 복사를 수행한다.

2. 디폴트 복사 생성자

사용자 정의 복사 생성자가 없을 때 자동 삽입
멤버 변수 대 멤버 변수의 복사를 수행

얕은 복사에 의한 메모리 참조 오류가 있다.
따라서 deep copy 필요

#include<iostream>
using std::cout;
using std::endl;

class Person
{
     char *name;
     char *phone;
     int age;
    public:
         Person(char* _name, char* _phone, int _age);
         Person(const Person& p) {
              name = new char[strlen(p.name)+1];
              strcpy(name, p.name);

              
              phone = new char[strlen(p.phone)+1];
              strcpy(phone, p.phone);

            
              age = p.age;
         }

         ~Person();
         void ShowData();
};

Person::Person(char* _name, char* _phone, int _age)
{
     name=new char[strlen(_name)+1];
     strcpy(name, _name);

     phone=new char[strlen(_phone)+1];
     strcpy(phone, _phone);

     age=_age;
}

Person::~Person()
{
     delete []name;
     delete []phone;
}
void Person::ShowData()
{
     cout<<"name: "<<name<<endl;
     cout<<"phone: "<<phone<<endl;
     cout<<"age: "<<age<<endl;
}

int main()
{
     Person p1("KIM", "013-333-5555", 22);
    // Person p2=p1;
     Person p2(p1);

     p2.ShowData();
     p2.ShowData();
 
     return 0;
}

3. 복사 생성자 호출 형태 3가지

case1: 기존에 생성된 객체로 새로운 객체 초기화

case2: 매개변수 역시 1. 메모리 공간 할당 2. 초기화의 과정을 거친다.
           하지만 초기화 과정에서 값을 직접 대입하는 게 아니라 복사 생성자를 호출하여 인자로 전달한다.

case3: AAA i(10);
           AAA j = i;
           일반 변수와 같이 직접 대입하지 않는다.
           j가 지니고 있는 생성자를 호출. 그 과정에서 i객체가 인자로 전달된다. 이 때 j의 복사생성자를 호출하게 된다.

관련 있는 데이터와 함수를 하나로 묶는 것.
예) English 라는 클래스가 있고 멤버 변수가 a,b,c 가 있다고 하자
그렇다면 이 a,b,c 멤버 변수를 조작하는 모든 함수는 멤버 함수로 와야 한다.
다시 말하면 a,b,c는 내부의 함수를 통해서만 조작되어야 한다.

객체를 생성과 동시에 초기화 하기 위해서 사용된다.
객체는 생성과 동시에 초기화 하는 것이 좋은 구조이다.

예를 들어. 먼저 객체를 만들고, 여기에 대입할 값을 검증했을 때  값이 유효하지 않다면 어쨌든 객체는 남아있다.
하지만 미리 검증하고 생성과 동시에 초기화 한다면 항상 유효한 객체만 남아있을 것.

기존의 방법으론 생성과 동시에 초기화 할 수 없다. 왜냐하면 정보은닉 때문.
따라서 어떤 방법이 있을까? 바로 생성자!

생성자
-클래스와 이름 동일
-리턴타입이 없음. 리턴하지도 않는다.

#include<iostream>
using std::cout;
using std::endl;

class AAA {
     int i, j;
public:
     AAA(int _i, int _j)
     {
          i = _i;
          j = _j;
     }

    
     AAA(int _i, int _j, int _x)
     {
          i = _i;
          j = _j;
          j = _x;
     }

     void showData()
     {
          cout << i <<' '<< j << endl;
     }
};

int main()
{
     AAA abc(111,222);
     abc.showData();

    
     return 0;
}

디폴트 생성자 : 생성자가 하나도 정의되지 않은 경우.
(모든 객체는 반드시 생성자를 가지고 있다. 직접 정의한 생성자가 없을 경우 컴파일러가 자동으로 생성자를 삽입한다.)

예) Person min("123", 180. "hohoho");    //이건 가능, 인자 3개를 갖는 생성자 호출
     Person ho();    //이건 안된다. 함수 선언 같지 않나?
     Person ho;        //따라서 요렇게 해야 한다.    void 생성자 호출

-생성자를 하나 정의해두었으면 void를 인자값을 받는 디폴트 생성자는 자동으로 붙지 않는다. 따라서 따로 하나 만들어줘야 된다.
-생성자도 두 개 이상 들어가도 된다. 왜냐하면 함수이기 때문에. 오버로딩 할 수 있지 않겠나?ㅋㅋ
-또한 디폴트 매개변수 설정도 가능하다.

객체가 소멸되는 시점은 기본 자료형 변수, 구조체 변수가 소멸되는 시점과 동일하다.
소멸자 : -객체의 메모리 반환을 위해서 객체 소멸 시 자동으로 호출되는 함수
            -전달인자는 항상 void
            - 클래스 이름 앞에 ~(틸트)클래스명 이 붙은 형태

객체의 생성 순서 : 메모리 할당 -> 생성자 호출
객체의 반환 순서 : 소멸자 호출 -> 메모리 반환

Point arr[5];
객체를 멤버로 지니는 배열이다.
기본적으로 void 생성자의 호출을 요구한다.

 

객체 포인터 배열
 Point* arr[5];

 
 for(int i=0; i<5; i++)
 {
      arr[i]=new Point(i*2, i*3);  // new에 의한 객체 동적 생성.
 }

this 포인터

자기 자신의 포인터 값 리턴. 자기 참조 포인터.

class Person
{
    public:
         Person* GetThis() {        //당연히 Person* 타입이어야 한다. 왜냐하면 자기 자신의 주소를 리턴하기 때문에.
              return this;
         }
};

 

class Person
{
     int aaa = 100;
     int bbb = 200;

public:
     Data(int aaa, int bbb) {    
          this->aaa = aaa;        //this->aaa는 멤버변수  aaa이다
          this->bbb = bbb;        //왜냐하면  this는 Person의 주소를 가지기 때문에 당연하다. 매개변수 주소는 모른다.
     }

    
     void printfAll() {
          cout << aaa << " " << bbb << endl;
     }

};

 

private 영역에 접근을 허용한다.

A클래스 내에서
    firend class BBB;
라고 하면 클래스 BBB는 AAA의 private 영역에 접근이 가능하다.

#include <iostream>
using std::cout;
using std::endl;

class counter
{
    private:
         int val;

    public:
         counter() {
              val = 0;
         }

        
         void print() const {
              cout << val << endl;
         }

         friend void setX(counter& c, int val);
};

void setX(counter& c, int val)
{
     c.val = val;
}

int main()
{
     counter cnt;
     cnt.print();

   
     setX(cnt, 2002);
     cnt.print();

     return 0 ;
}

클래스가 함수를 freind로 선언
클래스가 클래스를 friend로 선언 모두 가능

#include <iostream>
using std::cout;
using std::endl;

class AAA
{
    private:
         int val;
         friend class BBB;
};

class BBB
{
    public:
         void setData(AAA& aaa, int val)
         {
              aaa.val = val;
         }
};

int main()
{
     AAA aaa;
     BBB bbb;

     bbb.setData(aaa, 10);

    
     return 0;
}

friend 선언은 단방향성이다. 기억할 것.
friend는 그다지 유용하지 않다.(연산자 오버로딩에는 유용)

함수를 가리키는 포인터다.

#include <iostream>
using namespace std;

void dog()
{
     cout << "i'm dog" << endl;
}

void cat()
{
     cout << "i'm cat" << endl;
}

int main(void)
{

     void (*pDog)();
     void (*pCat)();

    
     pDog = &dog;    //pDog 에는 dog()의 시작 주소가 들어간다
     pCat = &cat;

    
     (*pDog)();        //마치 함수의 이름인 것 처럼 사용할 수 있다.
     (*pCat)();

    
     return 0;
}

함수원형 : int MyFunc(int a, char* p);  //함수 원형이 이렇다면
함수포인터 : int (*ptr)(int, char*);     //요렇게 선언하면 되겠지

기본 자료형과 사용자 자료형의 사용법 일치
C에서는 struct 키워드를 붙여야 했다. 물론 typedef 가 있긴 하지..
하지만 C++에서는 기본 자료형이나 사용자 자료형 모두 하나의 자료형으로 인식한다.(구분짓지 않는다. 이걸 c++의 철학이라고 하나..ㅋ)

#include <iostream>
using namespace std;

struct Account {
     char accID[20];
     char secID[20];
     char name[20];
     int balance;

    
     void Deposit(int money) {
          balance+=money;
     }

    
     void Withdraw(int money) {
          balance-=money;
     }
};

int main(void)
{
     Account zzang2k={"1234", "9999", "zzang2k", 10000};

    
     zzang2k.Deposit(1000);        //함수도 똑같이 접근자를 통해서 호출
     cout << "잔액 : " << zzang2k.balance << endl;

    
     zzang2k.Withdraw(6000);
     cout << "잔액 : " << zzang2k.balance << endl;

    
     return 0;
}

C에서는 구조체 안에 함수를 넣을 수 없다.
하지만 C++ 에서는 가능!

왜 클래스라는 개념이 등장했나.
특정 객체의 함수를 호출한다 : 메시지를 전달한다. 
특정 객체 안에 있는 함수를 호출하는 행위를 Message Passing 이라 한다. 무엇을 알린다 라는 개념.

현실 세계의 사물 --> 추상화 --> 클래스화 --> 인스턴트화
따라서 클래스가 변수와 함수로 이루어져 있는 이유를 대충 알겄지?

내부접근 : 같은 클래스 내에서 접근
외부접근 : 다른 함수 또는 클래스에서 접근

private : 클래스 내부 접근만 허용
public : 어떤 경우이던 접근을 허용한다. 내부접근/외부접근을 모두 허용한다.
protected : 상속이라는 문법적 요소와 맞물려짐. 추후 설명.

-class는 접근제어를 명시해주지 않으면 디폴트 private: 이다.

-C++에서의 struct 에도 접근제어자를 선언할 수 있다. C++에서 struct는 class라고 생각해라.
단, struct로 선언하면 접근제어는 디폴트 public 이다.

-멤버 함수는 외부에 정의해라. 그래야 클래스를 보기에 편하다.

const int OPEN = 1;
const int CLOSE = 0;

class Door {

     int state;

public:
     void open();    //문을 오픈한다.
     void close();    //문을 닫는다.
     void showState();    //문의 상태를 보여준다.

};

void Door::open() {
     state = OPEN;
}

void Door::close() {
     state = CLOSE;
}

void Door::showState() {
     cout << "현재 문의 상태 : ";
     cout << ((state==OPEN) ? "OPEN" : "CLOSE") << endl;
}

-멤버 함수의 인-라인화
클래스내에 멤버 함수를 정의해 놓으면 자동으로 in-line화 된다.
클래스 밖으로 함수의 선언과 정의를 분리시키면 자동으로 in-line이 안된다.
따라서 외부의 정의에 inline 키워드를 써야한다.

C에서는 #define
C++에서는 inline 키워드

//위와 같은 의미이다.

inline void Door::open() {
     state = OPEN;
}

inline void Door::close() {
     state = CLOSE;
}

inline void Door::showState() {
     cout << "현재 문의 상태 : ";
     cout << ((state==OPEN) ? "OPEN" : "CLOSE") << endl;
}