code cat

module_init() 매크로는 모듈형태로 컴파일시 module insertion time에 불린다.

만약 모듈형태로 컴파일 되지 않았으면, module_init()은 __initcall()과 같은 동작을 하는데 이는 boot time시에 불린다.

__initcall()은 다음과 같이 정의되어 있다.

가끔 svn에서 다음과 같이 충돌이 난다고 한다.

"svn: file_name remains in conflict"

이럴 땐, 당황하지 말고,

하면 된다.   이래도 좀 더 꼬여서 안 될때가 있는데 그 때는 상위 디렉터리로 이동 뒤,

하면 된다.

출처: engadget.com

출처: http://stackoverflow.com/questions/2966409/cpio-vs-tar-and-cp

cpio가 tar보다 나은 점은 뭘까?

우선 cpio는 하드링크를 보존한다.  또한 cpio는 파일이름길이에 대한 제한이 없다. timestamp 또한 보존한다. 

스크립트를 쓸 때 파일들에 대한 통제가 편리하다는 점도 있다. 

find . -type f -name '*.sh' -print | cpio -o | gzip >sh.cpio.gz

참고로 find를 써서 많은 파일들의 리스트를 넘기려고 하면 command-line length가 overrun될 가능성이 있다.  그래서 이럴 경우, 중간 파일을 사용해 주는게 좋다.

cp에 대해선 다음에 더 알아보자.

vim에서 TAB(탭)을 4 space로 설정하기

vimrc파일에서 다음과 같이 세팅해 주면 된다.

set softtabstop=4                              ; TAB키를 눌렀을때 몇 칸을 이동?

set tabstop=4                                  ; 하나의 TAB을 몇 칸으로 인식? 

set shiftwidth=4                               ; <<, >>을 눌렀을 때 몇 칸을 이동?

set expandtab                                  ; TAB을 space로 인식

;set noexpandtab                                ; TAB을 TAB으로 인식                         

출처: kldp

페어 코딩에 대한 좋은 글이 있어서  kldp에서 퍼왔다.

페어코딩을 하기 위한 자세 (원제는 아니였는데 그냥 제목을 붙여봤다)

* 소스코드의 소유와 책임이 개인이 아닌 팀에 있다. 아무나 다른 사람의 코드를 비판하고 고칠 수 있다.
* "우리"에 잘못이 있지, 특정인에게 잘못이 있지 않다. 코드는 비난하더라도 사람은 비난하지 않는다.
* 같이 일하다 결과가 있을 때마다 서로 축하한다. 하이 파이브나 괴성 등으로 서로의 감정을 공유한다.
* 급한 일이 있으면 상대에게 이야기하고 양해를 구한다. 서로 존중하면서 해결해야 할 사적인 문제는 바로 해결한다.
* 아무리 나보다 못한 사람에게도 배울점이 있음을 간과하지 말며, 나도 언제나 다른 사람이 저지르는 실수를 똑같이 저지를 수 있음을 잊지 않는다.
* 좋은 아이디어가 있으면 바로 바로 상대방과 상의하며 프로그래밍 한다.
* 짝이 틀린 것을 지적하면 고마움을 표한다.
* 짝이 틀린 길로 들어서면 바로 지적한다. 만일 그에 대해 짝이 멈추지 않게 계속 한다면 의중을 파악하려고 노력한 후 그래도 자신이 옳다는 생각이 들면 기회를 기다렸다가 조리있게 왜 그것이 틀렸는지 설명한다.
* 일이 안풀리고 막히면 바로 상대에게 넘긴다.
* 상대에게 프로그래밍을 해설 및 중계방송 하는 느낌으로 자신의 생각을 끊임없이 말해준다. 상대가 자신의 생각을 이야기 하면 귀담아 듣고 문제는 없는지 어떻게 앞으로 일들이 펼쳐져야 할지 머리속에 그리며 함께 일한다.
* 일을 마치기 전에 상대에게 얼마나 고마운지, 짝이 없었다면 자신이 얼마나 형편없는 결과물을 만들어 냈을지 서로 이야기 하고 격려한다.
* 열심히 일한 후에는 칼퇴근 한다.

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.. 아 쓰기도 어려운데, 그래서 할 수 있는 방법이 다음과 같다.

.... 걍 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 키워드를 써서 처리해야 한다.  아니 이런 구조를 아예 피하자.

다중상속과 캐스팅

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

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

RTTI (Run-Time Type Informationi)

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

#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; class Obj { public: Obj() { cout << "Obj::Obj()" << endl; } ~Obj() { cout << "Obj::~Obj() " << endl; } void foo() const { cout << "Obj::foo()" << endl; } void goo() const { cout << "Obj::goo()" << endl; } }; int main() { Obj* obj = new Obj; obj->foo(); delete obj; return 0; }

스마트 포인터가 추가되면 다음과 같다.

#include <iostream> using namespace std; class Obj { public: Obj() { cout << "Obj::Obj()" << endl; } ~Obj() { cout << "Obj::~Obj() " << endl; } void foo() const { cout << "Obj::foo()" << endl; } void goo() const { cout << "Obj::goo()" << endl; } }; class Sptr { Obj* s_obj; public: Sptr( Obj* p ) : s_obj(p) {} ~Sptr() { delete s_obj; } Obj* operator->() { return s_obj; } Obj& operator*() { return *s_obj;} }; int main() { Sptr sp = new Obj; // = Sptr sp(new Obj); sp->goo(); delete obj; return 0; }

sp를 보면 포인터는 아닌데, sp->goo()를 하는 걸 보면 포인터 같기도 하고, 헷갈린다?

우선 Sptr sp = new Obj 는 Sptr sp(new Obj)와 같다.   C++에서 객체의 대입, a = new b 는 a(new b)라고 생각해도 무방하다.  Sptr의 생성자를 보면 Obj* p를 인자로 받고, Obj* s_obj를 p로 초기화 시켜준다.  결국 sp는 Obj* 를 멤버로 갖는 객체가 생성된 것이다. 

그럼 ->는 무엇인가?  그것은, 연산자 오버로딩을 통해 구현된 것이다.

Obj* operator->()   { return s_obj; }

결국엔 Obj* 타입인 s_obj를 리턴하는 것이다. 그럼 결국엔,

sp->goo()는  (sp.operator->())goo()

인 것이고 sp.operator->()는 Obj*를 리턴함으로,

(sp.operator->())->foo()로 해석하게 되어 마치 포인터로 함수를 호출하는 거처럼 작동한다.

다시 말해 스마트 포인터(sp)는 객체이지만 마치 다른 객체(Obj)의 포인터(Obj*)역활을 한다.

레퍼런스 카운팅

위에서 보다싶이, 내부적으로 포인터 변수를 가지고 있으므로, 얕은 복사(shallow copy)가 발생할 확률이 높다.

물론 이를 방지하기 위해, 깊은 복사(deep copy)를 구현할 수도 있으나, 이는 성능이슈 및 스마트(?)하지 않으므로, 대신 레퍼런스 카운팅 기법을 쓰는게 좋다.