Android Framework 분석을 위한 C++ 4일차

1. 순수 가상함수와 추상 클래스

 

추상클래스를 만들기 위해서는 가상함수를 선언해야 하며, 0으로 초기화 시켜주어야 한다.

추상클래스의 목적은 이를 상속하는 하위 클래스에게 구현의 임무를 부여하는 데 있다.

#include <iostream> using namespace std; //순수 가상함수와 추상클래스 - 92 pages // 추상클래스 : 순수 가상함수가 1개 이상있는 클래스 // 추상클래스 목적 : 자식에게 특정한 함수를 반드시 만들어야 한다고 지시하는 것. // "모든 도형은 Draw()를 만들어야 사용할 수 있다" class Shape { public: virtual void Draw() = 0; //순수 가상함수 - 구현부가 없다. //virtual void Draw(); // 주의! 순수 가상함수가 아니라 그냥 함수 선언. // 추상클래스를 구현하려면, 반드시 = 0 으로 초기화 시켜주자. }; class Rect : public Shape // Draw()의 구현부를 제공하기 않으면 Rect도 역시 추상이다. { }; int main() { Shape S; // error. 추상클래스는 객체를 만들 수 없다. Rect r; }

 

인터페이스의 탄생

#include <iostream> using namespace std; //순수 가상함수와 추상클래스 - 92 pages // 강한결합(tightly coupling) : 하나의 클래스가 다른 클래스의 이름을 직접 사용하는 것 // 경직된 디자인, 교체 불가능하다. // // 약한결합(loose coupling) : 두 클래스 사이에 인터페이스(함수 이름에 대한 약속) // 가 있고, 인터페이스를 사용해서 통신하는 것. // 유연하고 교체 가능한 디자인. // 스마트폰 제조 업자와 사람간에 인터페이스(계약서, 약속)를 정한다. // "모든 스마트폰은 아래 클래스부터 파생되기로 약속하자" class ISmartPhone { public: virtual void Calling(char* no) = 0; }; // 이제 규칙이 명확하게 있으므로 실제 폰이 없더라도 폰을 사용하는 코드를 먼저 설계할 수도 있다 class People { public: void UsePhone(ISmartPhone* p) { p->Calling("010-111-2222"); } }; // 진짜 스마트폰 설계자는 ISmartPhone의 자식으로만 만들면 된다. class Optimus : public ISmartPhone { public: virtual void Calling(char* no) { cout << "Calling with Optimus" << endl; } }; int main() { People p; Optimus o; p.UsepPhone(&o); }

 

좀 더 이쁘게 할려면, 이렇게 바꾸자.

#define interface struct interface ISmartPhone { public: virtual void Calling(char* no) = 0; };

 

인터페이스는 기능별로 나누는게 좋고, 다중상속으로 처리하면 된다.

#include <iostream> using namespace std; //순수 가상함수와 추상클래스 - 92 pages // 강한결합(tightly coupling) : 하나의 클래스가 다른 클래스의 이름을 직접 사용하는 것 // 경직된 디자인, 교체 불가능하다. // // 약한결합(loose coupling) : 두 클래스 사이에 인터페이스(함수 이름에 대한 약속) // 가 있고, 인터페이스를 사용해서 통신하는 것. // 유연하고 교체 가능한 디자인. // 스마트폰 제조 업자와 사람간에 인터페이스(계약서, 약속)를 정한다. // "모든 스마트폰은 아래 클래스부터 파생되기로 약속하자" #define interface struct interface ISmartPhone { public: virtual void Calling(char* no) = 0; }; // 인터페이스는 많은 함수를 넣지 말고, 기능별로 따로 분리하는 것이 좋다. interface IMP3 { public: virtual void PlayMP3(char* no) = 0; }; // 이제 규칙이 명확하게 있으므로 실제 폰이 없더라도 폰을 사용하는 코드를 먼저 설계할 수도 있다 class People { public: void UsePhone(ISmartPhone* p) { p->Calling("010-111-2222"); } }; // 진짜 스마트폰 설계자는 ISmartPhone의 자식으로만 만들면 된다. // 인터페이스의 자식을 만들 때는 상속 받는다. 라는 표현대시 // "ISmartPhone 인터페이스 구현해야 한다" 라고 표현한다. class Optimus : public ISmartPhone, public IMP3 { public: virtual void Calling(char* no) { cout << "Calling with Optimus" << endl; } virtual void PlayMP3(char* no) { cout << "play mp3" <<endl; } }; int main() { People p; Optimus o; p.UsepPhone(&o); }

 

#include <iostream> #include <string> #include <conio.h> using namespace std; // LineEdit.cpp // // GUI 라이브러리인 EditBox 같은 클래스를 설계해 보자. // 1. 입력된 값의 유효성을 확인하는 validation 기능을 추가하자. // 2. 값의 유효성 여부를 체크하는 알고리즘은 변경할 수 있어야 한다. // 3. 변하지 않는 것(전체알고리즘)과 변하는 것(세부 알고리즘)은 분리해야 한다. // c언어 : 변하는 것을 함수 인자로 만든다. (ex, sort()함수에서 비교함수) // c++언어 : // (A) 변하는 것을 가상함수로 만든다. // 파생클래스(자식)을 만들어서 가상함수를 재정의하면 변해야 하는 것을 // 바꿀 수 있다. // 전체적인 알고리즘은 부모에게 전체적인 알고리즘에서 다시 가상함수를 호출 // 자식에게 세부 알고리즘을 변경 할 수 있게 => "Template Method"라는 디자인 패턴 // (B) 변하는 것을 완전히 다른 클래스로 만든다. 단, 교체가능해야 한다. // 인터페이스를 먼저 설계해야 한다. // => GoF's의 디자인 패턴 중 "전략패턴(Strategy pattern)"이라는 패턴입니다. // 모든 validator가 지켜야 할 인터페이스를 설계한다. struct IValidator { virtual bool validate(string s, char c) = 0; virtual bool iscomplete(string s) {return true;} virtual ~IValidator() {}; //가상 소멸자.. 다음시간에 설명 }; //------------------------------------------------------------- class LineEdit { string data; IValidator* validator; public: LineEdit() : validator(0) {} void SetValidator(IValidator* p) {validator = p;} //--------------------------------------------------------- string getData() { data.clear(); while(1) { char c = getch(); if (c == 13 && (validator == 0 || validator->iscomplete(data))) break; // enter키 입력 if (validator == 0 || validator->validate(data, c)) //값의 유효성 여부를 외부 클래스에 물어본다. { data.push_back(c); cout << c; } } cout << endl; return data; } }; /* //(A) class LineEdit { string data; protected: virtual bool validate(char c) {return isdigit(c);} public: string getData() { data.clear(); while(1) { char c = getch(); if (c == 13) break; // enter키 입력 if (validate(c)) // 가상함수호출 { data.push_back(c); cout << c; } } cout << endl; return data; } }; */ //------------------------------------------------------------------------- //자식클래스를 만들어 validation 정책을 변경한다. class NameEdit : public LineEdit { public: virtual bool validate(char c) {return true;} }; // 이제 값의 유효성 여부를 확인하는 다양한 validator를 만들어 사용한다. class LimitDigitValidator : public IValidator { int limit; public: LimitDigitValidator(int n) : limit(n) {} virtual bool iscomplete(string s) {return s.size() > 3;} virtual bool validate(string s, char c) { if (s.size() < limit && isdigit(c)) return true; return false; } }; int main() { LineEdit e; LimitDigitValidator v(5); e.SetValidator(&v); while(1) { string s = e.getData(); cout << s << endl; } }

 

 

 

다음은 메뉴만들기를 객체 지향적으로 구현해 본 것이다.

 

메뉴를 만든다면, 우선 여러가지 형태가 있겠지만,

추상메뉴

 |-  팝업 메뉴     Vector<"추상메뉴">

  `-  메뉴 아이템

 

팝업메뉴는 여러가지 메뉴가 있을테니, Vector<"추상메뉴">로 구현하면 되고,

모든 메뉴는 title 및 command가 있으니, 이는 추상메뉴에 구현한다.

 

이렇게 하위 객체를 부모로 싸잡아서 구현하는 걸 composite 패턴이라고 한다. 

 

밑은 composite 패턴으로 구현한 고객관리 메뉴 코드이다.  동작성은 없다.

#include <iostream> #include <string> #include <vector> #include <conio.h> using namespace std; #define clrscr() system("cls") // Composite 패턴 : 포함과 관련된 패턴.. GUI디자인시의 핵심 패턴 // 그릇은 사물을 담을 수 있고, 그릇자체도 담을 수 있다. // 그릇과 사물은 공통의 부모가 있어야 한다. // 메뉴를 객체지향적으로 설계해 보자. // // 모든 메뉴의 부모 메뉴 class AbstractMenu { string title; public: AbstractMenu(string s) : title(s) {} string getTitle() const {return title;} // 모든 메뉴는 선택할 수 있다. 구현은 자식이 하게 하자! virtual void command() = 0; }; class MenuItem : public AbstractMenu { int id; public: MenuItem(string s, int n) : AbstractMenu(s), id(n) {} virtual void command() { cout << getTitle() << "메뉴가 선택되었습니다" << endl; getch(); } }; class PopupMenu : public AbstractMenu { vector<AbstractMenu*> submenus; //composite 패턴의 핵심 public: PopupMenu(string s) : AbstractMenu(s) {} void AddMenu(AbstractMenu* p){submenus.push_back(p);} virtual void command() { while(1) { clrscr(); //clear screen int sz = submenus.size(); for (int i = 0; i < sz; i++) cout << i+1 << ". " << submenus[i]->getTitle() << endl; cout << sz + 1 << ". 상위메뉴로 이동" << endl; cout << "메뉴를 선택하세요 >> "; int cmd; cin >> cmd; if (cmd == sz + 1) break; // 또는 return if (cmd < 0 || cmd > sz + 1) continue; // 이제 선택된 메뉴를 실행한다. submenus[cmd - 1]->command(); //어느 객체냐 따라서 PopupMenu/MenuItem의 command가 불림 // 다형성!!(메뉴 아이템인지 팝업메뉴인지 조사할 필요 없다.) } } }; int main() { PopupMenu* menubar = new PopupMenu("MENUBAR"); PopupMenu* p1 = new PopupMenu("고객관리"); PopupMenu* p2 = new PopupMenu("Tape관리"); PopupMenu* p3 = new PopupMenu("대여관리"); menubar->AddMenu(p1); menubar->AddMenu(p2); menubar->AddMenu(p3); p1->AddMenu( new MenuItem("고객추가", 11)); p1->AddMenu( new MenuItem("고객삭제", 12)); p1->AddMenu( new MenuItem("고객검색", 12)); p2->AddMenu( new MenuItem("Tape추가", 21)); p2->AddMenu( new MenuItem("Tape삭제", 22)); p3->AddMenu( new MenuItem("대여추가", 31)); p3->AddMenu( new MenuItem("대여삭제", 32)); menubar->command(); }

 

 

자원 반납을 위해서, 소멸자를 추가하자.

class AbstractMenu { string title; public: AbstractMenu(string s) : title(s) {} virtual ~AbstracMenu() {} // 가상 소멸자 string getTitle() const {return title;} // 모든 메뉴는 선택할 수 있다. 구현은 자식이 하게 하자! virtual void command() = 0; } class PopupMenu : public AbstractMenu { vector<AbstractMenu*> submenus; //composite 패턴의 핵 public: PopupMenu(string s) : AbstractMenu(s) {} ~PopupMenu() { //모든 하위 메뉴를 제거한다. for (int i = 0; i < submenus.size(); i ++) delete submenus[i]; } void AddMenu(AbstractMenu* p){submenus.push_back(p); ... menubar->command() delete menubar;

 

 

 

가상 소멸자

class A { public: ~A () {cout << "메모리A해지" << endl;} }; class B : public A { int* data; public: B() {data = new int[100]; cout << "메모리할당" << endl;} ~B() {delete[] data; cout << "메모리해지" << endl;} }; int main() { A* p = new B; delete p; // p가 가리키는 곳을 파괴하고, 소멸자를 호출해야 한다. // 소멸자가 가상이 아니면, static binding 하므로 ~A()만 호출 }

이렇게 해서 자원을 해지하려면, B가 해지되는게 아니라, A가 해지된다.  이를 해결하기 위해선,

~A() {cout << "메모리A해지" <<endl;}

앞에 virtual을 붙여서

 virtual ~A() {cout << "메모리A해지" <<endl;}
이라고 정의하면 된다. 

 

근데 또 가상소멸자에 의한 가상테이블이 생기는 것을 없애려, protected로 선언해, 컴파일 시 에러가 나게 하는 방법도 있다.

소멸자는 delete static_cast<B*>(p);로 바꿔야 한다.

class A { //public: // virtual ~A() {} // 가상테이블을 없애기 위해서 다음과 같은 방법도 있다. protected: ~A() {} }; class B : public A { int* data; public: B() {data = new int[100]; cout << "메모리할당" << endl;} ~B() {delete[] data; cout << "메모리해지" << endl;} }; int main() { A* p = new B; //delete p; // error. A소멸자가 protected이므로 // 이제 객체를 파괴할 때는 반드시 정확한 타입으로 // 캐스팅 한 후에 하기로 약속하자 delete static_cast<B*>(p); //ok }

 

그러나 delete static_ca.. 아 쓰기도 어려운데, 그래서 할 수 있는 방법이 다음과 같다.

template<typename T> class A { protected: ~A() {} public: void Clean() { delete static_cast<T*>(this);} }; class B : public A<B> { int* data; public: B() {data = new int[100]; cout << "메모리할당" << endl;} ~B() {delete[] data; cout << "메모리해지" << endl;} }; int main() { A* p = new B; //delete p; // error. A소멸자가 protected이므로 // 이제 객체를 파괴할 때는 반드시 정확한 타입으로 // 캐스팅 한 후에 하기로 약속하자 delete static_cast<B*>(p); //ok p->Clean();

.... 걍 c++ 하지 말자.

 

정리하자면, 상속관계에 있는 클래스에서 부모 클래스이 소멸자는 항상 가상함수로 만들자.

 

갑자기 생각난  mix-in 하고 upcasting하고 어떻게 틀리더라...

 

 

가상함수를 쓰면 다음과 같은 결과를 얻는다.

class A { int x; public: virtual void foo() { cout << "A::foo" << endl; } virtual void goo() {} virtual void hoo() {} }; class B : public A { int y; public: virtual void foo() { cout << "B::foo" << endl; } }; int main() { A a; cout << sizeof(a) << endl; // 4가 나와야 하지만 8이 나온다 B b; cout << sizeof(b) << endl; // 8이 나와야 하지만 12가 나온다 A* p = &b; p->foo(); // 이순간 컴파일러의 원리 // 1. foo가 가상이 아니라면 : static binding => p의 포인터타입으로 결정 // A::foo()호출 // 2. foo가 가상이라면 : *p[1]() 라고 기계어 코드를 생성해 놓는다. }

주석에도 있듯이,

foo가 가상이 아니라면 : static binding => p의 포인터타입으로 결정
                                 A::foo()호출
foo가 가상이라면        : *p[1]() 라고 기계어 코드를 생성해 놓는다.

 

*p[1]은 실제로 가상함수테이블(Virtual Function Table)의 인덱스를 가리킨다.  보통 컴파일러는 가상함수의 기능을 구현하기 위해 가상함수 테이블과 가상함수 테이블 포인터를 사용하는데, 가상함수테이블은 가상함수의 모든 주소를 가지고 있는 배열이며, 가상함수 포인터는 이 테이블을 가리킨다.

 

즉 가상함수를 사용하면, 다형성을을 얻을 수 있으나,

 

1. 가상함수 테이블을 위한 메모리 할당,

2. 가상함수 테이블 포인터로 인한 객체의 크기 증가,

3. 함수 호출시 함수 포인터에 의한 호출로 오버헤드 증가,

4. Inline을 사용하지 못함

 

다는 단점도 있다.  그리고 한가지 더! 가상함수는 run-time에 호출 될 함수가 결정되지만, default paramemter는 compile-time에 결정된다.  따라서 예상치 못한 결과가 나올 수 있으니 주의하자.

 

composite 패턴 실습

 

다음은 composite 패턴을 이용해서 만들어 본 비디오 대여점 메뉴이다. 기본적인 메뉴만 구성되어 있다.

#include <iostream> #include <string> #include <vector> #include <conio.h> using namespace std; #define clrscr() system("cls") // Composite 패턴 : 포함과 관련된 패턴.. GUI디자인시의 핵심 패턴 // 그릇은 사물을 담을 수 있고, 그릇자체도 담을 수 있다. // 그릇과 사물은 공통의 부모가 있어야 한다. // 메뉴를 객체지향적으로 설계해 보자. // // 모든 메뉴의 부모 메뉴 class AbstractMenu { string title; public: AbstractMenu(string s) : title(s) {} string getTitle() const {return title;} // 모든 메뉴는 선택할 수 있다. 구현은 자식이 하게 하자! virtual void command() = 0; }; class MenuItem : public AbstractMenu { int id; public: MenuItem(string s, int n) : AbstractMenu(s), id(n) {} virtual void command() { cout << getTitle() << "메뉴가 선택되었습니다" << endl; getch(); } }; class PopupMenu : public AbstractMenu { vector<AbstractMenu*> submenus; //composite 패턴의 핵심 public: PopupMenu(string s) : AbstractMenu(s) {} void AddMenu(AbstractMenu* p){submenus.push_back(p);} virtual void command() { while(1) { clrscr(); //clear screen int sz = submenus.size(); for (int i = 0; i < sz; i++) cout << i+1 << ". " << submenus[i]->getTitle() << endl; cout << sz + 1 << ". 상위메뉴로 이동" << endl; cout << "메뉴를 선택하세요 >> "; int cmd; cin >> cmd; if (cmd == sz + 1) break; // 또는 return if (cmd < 0 || cmd > sz + 1) continue; // 이제 선택된 메뉴를 실행한다. submenus[cmd - 1]->command(); //어느 객체냐 따라서 PopupMenu/MenuItem의 command가 불림 // 다형성!!(메뉴 아이템인지 팝업메뉴인지 조사할 필요 없다.) } } }; int main() { PopupMenu* menubar = new PopupMenu("MENUBAR"); PopupMenu* p1 = new PopupMenu("고객관리"); PopupMenu* p2 = new PopupMenu("Tape관리"); PopupMenu* p3 = new PopupMenu("대여관리"); menubar->AddMenu(p1); menubar->AddMenu(p2); menubar->AddMenu(p3); p1->AddMenu( new MenuItem("고객추가", 11)); p1->AddMenu( new MenuItem("고객삭제", 12)); p1->AddMenu( new MenuItem("고객검색", 12)); p2->AddMenu( new MenuItem("Tape추가", 21)); p2->AddMenu( new MenuItem("Tape삭제", 22)); p3->AddMenu( new MenuItem("대여추가", 31)); p3->AddMenu( new MenuItem("대여삭제", 32)); menubar->command(); }

 

 

 

 

Observer 패턴 실습

위에서 생성된 메뉴의 메세지를 처리하기 위한 모든 객체는 인터페이스를 정하고, 그 인터페이스로부터 상속받은 형태로 구현 할 수 있다.

관찰자(Observer)패턴은 하나의 상태 변화를 여러 객체에게 알려주는 패턴이다.

#include <iostream> #include <vector> using namespace std; // 메뉴 메세지를 처리하기 위한 모든 객체는 아래 인터페이스에서 파생되어야 한다. struct IMenuListener { virtual void OnCommand(int id) = 0; virtual ~IMenuListener() {} }; // 메뉴 아이템의 핸들러 추가하기... class MenuItem { int id; string title; IMenuListener* pMenuListener; vector<IMenuListener*> v; public: MenuItem(string s, int n, IMenuListener* p = 0) : title(s), id(n)//, pMenuListener(p) {} { if (p) v.push_back(p); } void addListener(IMenuListener* p) {v.push_back(p);} virtual void command() { // 여기서 메뉴가 선택되었다는 사실을 외부에 알려야 한다. //pMenuListener->OnCommand(id); // 관찰자 패턴(Observer) : 하나의 상태 변화를 여러명에게 알려준다. // one source multi use for (int i = 0; i < v.size(); i++) v[i]->OnCommand(id); } }; class VideoShop : public IMenuListener { public: virtual void OnCommand(int id) { if (11 == id) cout << "고객추가" << endl; else if (12 == id) cout << "고객삭제" << endl; } }; int main() { VideoShop vs; VideoShop vs2; MenuItem m1("고객추가", 11, &vs); m1.addListener(&vs2); MenuItem m2("고객삭제", 12, &vs2); m1.command(); m2.command(); }

 

 

 

객체의 이벤트 처리를 위해 인터페이스 방식(바로 전 예제)이 아닌 함수와 연결 하는 방식도 있다.

다음을 보자.

#include <iostream> using namespace std; // 객체의 이벤츠 처리 기술 // 1. 인터페이스 방식의 처리 : java, 안드로이드, 바다 드의 라이브러리가 사용 // 2. 함수와 연결 : QT, MFC, C#, 아이폰이 사용 class VideoShop { //vector<Tape*> v; public: void AddTape() {cout << "Tape added" << endl;} // v에 테입을 추가하는 함수 }; class MenuItem { VideoShop* obj; void(VideoShop::*handler)(); public: MenuItem() {} void SetMenuHandler(VideoShop* p, void(VideoShop::*f)()) { obj = p; handler = f; } void command() {(obj->*handler)();} }; void foo() { cout << "foo" << endl; } int main() { VideoShop vs; MenuItem m; m.SetMenuHandler(&vs, &VideoShop::AddTape); //m.SetMenuHandler(&foo); m.command(); }

 

 

 

다중상속

 

다중상속에는 여러가지 문제점 있겠지만, 아래와 같이 (주석처리 된 부분) 다중상속시에 발생할 수 있는 문제점이 있다.

#include <iostream> using namespace std; // 1. 다중상속은 좋지 않다! - 되도록 사용하지 말자! // 2. 안드로이드는 다중상속을 사용한다. class RefBase { public: int mCount; }; //class IInterface : public RefBase { int x; }; //class BpRefBase : public RefBase { int y;}; class IInterface : public virtual RefBase { int x; }; class BpRefBase : public virtual RefBase { int y;}; class HelloWorld : public IInterface, public BpRefBase { }; int main() { HelloWorld hw; hw.mCount = 0; }

 

주석같이 상속 받으면,

 

                  RefBase

                 /           \         

        IInterface         BpRefBase

                 \            /

                  HelloWord

 

IInterface, BpRefBase 모두 mCount라는 변수를 상속 받았으니, 컴파일러는 어느 녀석을 써야 하는지 모른다.  그래서 대신, virtual 키워드를 써서 처리해야 한다.  아니 이런 구조를 아예 피하자.

 

 

 

다중상속과 캐스팅

 

#include <iostream> using namespace std; // 다중 상속과 캐스팅 class A { int x; }; class B { int y; }; class C : public A, public B { int z; }; int main() { C c; A* pA = &c; cout << &c << endl; // 100번지라고 가정하면 cout << pA << endl; // ? // B* pB = &c; //c 안에서 B의 위치를 찾게 된다. // B* pB = static_cast<B*>(&c); //역시, C안에서 B의 위치를 찾게 된다. B* pB = reinterpret_cast<B*>(&c); cout << pB << endl; // ? }

reinterpret_cast<B*>(&c)는 c를 어떻게든 B처럼 보이게하라고 캐스팅 한다. 즉 C안에서 B의 위치를 찾는게 아니라, C가 B처럼 되는 것이다. 그래서 만약 우리가

 

한편 x와 y가 public으로 바뀌서, y에 값(10)을 대입해 보면 y가 아닌 x가 10으로 대입되는 걸 볼 수있다. (x가 먼저 상속받기 때문에, 그 주소에는 x가 먼저 위치하고, 그 다음에 y가 위치한다.)

 

#include <iostream> using namespace std; // 다중 상속과 캐스팅 class A { public: int x; }; class B { public: int y; }; class C : public A, public B { int z; }; int main() { C c; A* pA = &c; cout << &c << endl; // 100번지라고 가정하면 cout << pA << endl; // ? // B* pB = &c; //c 안에서 B의 위치를 찾게 된다. // B* pB = static_cast<B*>(&c); //역시, C안에서 B의 위치를 찾게 된다. B* pB = reinterpret_cast<B*>(&c); pB->y = 10; //결국 c.x에 들어간다. cout << c.x << endl; cout << pB << endl; // ? }

 

 

 

RTTI (Run-Time Type Informationi)

런타임에 typeinfo를 가져온다.  typeinfo는 가상함수테이블 상위에 위치하고 있으며, 가상함수가 있을 때만 존재한다.

#include <iostream> using namespace std; // RTTI : Run-Time Type Information - 91 page // 1. 가상함수 테이블을 통해 관리 된다. 가상함수가 있을 때만 동작 가능 class Animal { public: virtual ~Animal() {} }; class Dog : public Animal { public: int color; }; void foo(Animal* p) { // type_info 객체를 얻는 방법 2가지 const type_info& t1 = typeid(*p); // typeid(객체) cout << t1.name() << endl; const type_info& t2 = typeid(Dog); // typeid(클래스이름) // p가 Dog라면 color를 변경하고 싶다. //Dog* pDog = (Dog*)p; 이렇게 하지 말자. } int main() { Animal a; foo(&a); Dog d; foo(&d); }

 

 

#include <iostream> using namespace std; // RTTI : Run-Time Type Information - 91 page // 1. 가상함수 테이블을 통해 관리 된다. 가상함수가 있을 때만 동작 가능 // 2. typeid()연산자로 조사 : if (typeid(*p) == typeid(Dog)) // 3. class Animal { public: virtual ~Animal() {} }; class Dog : public Animal { public: int color; }; void foo(Animal* p) { if (typeid(*p) == typeid(Dog)) { Dog* pDog = static_cast<Dog*>(p); pDog->color = 10; cout << "p는 Dog입니다" << endl; } /* // type_info 객체를 얻는 방법 2가지 const type_info& t1 = typeid(*p); // typeid(객체) cout << t1.name() << endl; const type_info& t2 = typeid(Dog); // typeid(클래스이름) */ // p가 Dog라면 color를 변경하고 싶다. //Dog* pDog = (Dog*)p; 이렇게 하지 말자. } int main() { // Animal a; foo(&a); Dog d; foo(&d); }

 

 

 

#include <iostream> using namespace std; // RTTI : Run-Time Type Information - 91 page // 1. 가상함수 테이블을 통해 관리 된다. 가상함수가 있을 때만 동작 가능 // 2. typeid()연산자로 조사 : if (typeid(*p) == typeid(Dog)) // 3. dynamic_cast 사용 class Animal { public: virtual ~Animal() {} }; class Dog : public Animal { public: int color; }; void foo(Animal* p) { //Dog* pDog = static_cast<Dog*>(p); Dog* pDog = dynamic_cast<Dog*>(p); // down cast (부모를 자식주소에 담게되는 현상) // 을 막아준다. cout << pDog << endl; } int main() { Animal a; foo(&a); Dog d; foo(&d); } /* void foo(Animal* p) { if (typeid(*p) == typeid(Dog)) { Dog* pDog = static_cast<Dog*>(p); pDog->color = 10; cout << "p는 Dog입니다" << endl; } // type_info 객체를 얻는 방법 2가지 const type_info& t1 = typeid(*p); // typeid(객체) cout << t1.name() << endl; const type_info& t2 = typeid(Dog); // typeid(클래스이름) // p가 Dog라면 color를 변경하고 싶다. //Dog* pDog = (Dog*)p; 이렇게 하지 말자. } int main() { // Animal a; foo(&a); Dog d; foo(&d); } */

 

 

 

 

템플릿

 

템플릿과 타입

#include <iostream> using namespace std; // 템플릿과 타입 - 150 page // 1. 인자가 참조라면 : 정확한 타입으로 전달된다. // 2. 인자가 값이라면 : 배열 => 포인터로 변환된다. // 함수 => 함수 포인터로 변환된다. 이런 현상을 "Decay"라고 한다. template<typename T> void foo(const T& a) { //함수 템플릿에서는 가상함수가 없어도, 기본타입에 대해서도, RTTI를 사용할 수 있다. cout << typeid(a).name() << endl; } int main() { int x = 0; int y[10]; foo(x); // T 가 int foo(y); foo("AAA"); // T 가 char* }