code cat

https://developers.google.com/java-dev-tools/download-wbpro 에서 알려준 링크

를 사용하면 다음과 같이 인스톨이 제대로 되지 않는다.  

이는 WindowBuilder Pro에서 필요한 컴포넌트들이 WindowBuilder Pro 사이트에 존재하지 않아서 이다.

대신, eclipse Indigo 사이트에서 다운을 받아보자.

indigo관련 릴리즈들이 많아서 처음에 오래 걸린다.

리스트가 뜨면, Filter에 WindowBuilder 와 SWT 와 Swing 등으로 필터를 걸고 찾아서 인스톨 하면 된다.

출처: 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)를 구현할 수도 있으나, 이는 성능이슈 및 스마트(?)하지 않으므로, 대신 레퍼런스 카운팅 기법을 쓰는게 좋다.

1. cout, endl의 원리

cout은 원래 객체이며, endl의 경우 함수이다.  아래는 cout과 endl를 구현해 본 소스코드이다.

//#include <iostream> //using namespace std; // cout, endl의 원리 - 112 ~ 113 page #include <stdio.h> namespace std { class ostream { public: ostream& operator<<( int a ) { printf("%d", a); return *this; } ostream& operator<<( char* s ) { printf("%s", s); return *this; } ostream& operator<<( ostream&(*f)(ostream&) ) { return f(*this); } }; ostream cout; // cout은 결국 전역적으로 생성된 객체 ostream& endl( ostream& os ) { os << "\n"; return os; } }; using namespace std; //------------------------------------------------------------------------- ostream& two_endl( ostream& os) { os << "\n\n"; return os; } ostream& tab( ostream& os) { os << "\t"; return os; } int main() { cout << tab << "A" << tab << "B" << endl; cout << two_endl << "A" << endl; cout << endl; // cout.operator<<(함수포인터) int a = 0; cout << a; // cout.operator<<(a) 즉 인자로 int를 받는 버전 cout << "hello"; // cout.operator<<(char*) }  

추가로 tab이나 two_endl의 사용자정의 함수도 추가했다. 

그럼 이게 기존거랑 충돌이 나느냐? 아래를 보자.

위와 같이 우리가 만든 함수들도 기존 std 네임스페이스와 같이 쓸 수 있다.

cout은 c와 달리 출력 형태가 무엇인지 정해주지 않아도 된다. 그렇다면 사용자 정의 객체 일 경우 어떻게 해야 할까?

아래는 사용자 정의 객체인 Point를 만든 코드이다.

#include <iostream> using namespace std; // cout과 사용자 정의 객체 - 114 page class Point { int x; int y; public: Point( int a = 0, int b = 0 ) : x(a), y(b) {} }; int main() { Point p(1, 2); cout << p; // 될까? }

cout << p;  이 부분은 결국 cout.operator<<(Point)가 있으면 된다.

#include <iostream> using namespace std; // cout과 사용자 정의 객체 - 114 page class Point { public: int x; int y; Point( int a = 0, int b = 0 ) : x(a), y(b) {} }; ostream& operator<<( ostream& os, const Point& p ) { return os << p.x << ", "<< p.y; } int main() { Point p(1, 2); cout << p; // 될까? cout.operator<<(Point)가 있으면 된다. // cout은 라이브러리가 제공하므로 우리가 함수를 추가할 수 없다. // 즉 멤버 함수를 추가할 수 없다. // 하지만 연산자 재정의는 일반함수로도 가능한다. // operator<<( ostream, Point)를 만들어도 된다. }

만약 namespace를 쓴다면, 어떨까? cout은 이미 라이브러리에서 정의된 것인데, Graphic::을 붙일 수 없지 않은가?

#include <iostream> using namespace std; // cout과 사용자 정의 객체 - 114 page namespace Graphic { class Point { public: int x; int y; Point( int a = 0, int b = 0 ) : x(a), y(b) {} }; ostream& operator<<( ostream& os, const Point& p ) { return os << p.x << ", "<< p.y; } } int main() { Graphic::Point p(1, 2); Graphic::operator<<(cout, p); //연산자 재정의 함수를 직접 호출해도 된다. cout << p; // 될까? cout.operator<<(Point)가 있으면 된다. // cout은 라이브러리가 제공하므로 우리가 함수를 추가할 수 없다. // 즉 멤버 함수를 추가할 수 없다. // 하지만 연산자 재정의는 일반함수로도 가능한다. // operator<<( ostream, Point)를 만들어도 된다. }

그래서 2일차에서 나왔던 키네그 룩업이라는 기법을 써서, 어차피 Point라는 객체가 존재하는 namespace를 찾아서 쓸 수 있게 하는 것이다.

이런 문법들이 왜 이렇게 설계되었는지 더 자세히 알고 싶으면, Annoted Reference Manual : C++을 참조하라.

2. 변환 연산자

#include <iostream> using namespace std; class Complex { int real; int image; public: Complex() : real(0), image(0) {} Complex(int a = 0, int b = 0) : real(a), image(b) {} // 변환 연산자 : 객체를 다른 객체 타입으로 변환하게 한다. 리턴 타입이 함수이름에 포함 // 되므로, 리턴 타입을 명시하지 않는다. operator int() { return real; } }; int main() { double d = 3.4; int n = d; Complex c(1,2); int n2 = c; //? 될까? c.operator int() 함수가 있으면 된다. }

변환 연산자를 생성하면 된다.  변환 생성자도 추가됐다.

#include <iostream> using namespace std; // 변환 이야기.. - 115 page // 1. 변환 연산자 : 객체를 다른 타입으로. Complex -> 다른 타입(int) // 2. 변환 생성자 : 다른 타입을 객체로. 다른타입(int) -> Complex class Complex { int real; int image; public: // 인자가 1개인 생성자 : 다른 타입이 객체가 되도록 한다. 변환 생성자라고 한다. Complex(int a) : real(0), image(0) {} Complex(int a = 0, int b = 0) : real(a), image(b) {} // 변환 연산자 : 객체를 다른 객체 타입으로 변환하게 한다. 리턴 타입이 함수이름에 포함 // 되므로, 리턴 타입을 명시하지 않는다. operator int() { return real; } }; int main() { Complex c1; Complex c2(1, 2); int n = c2; // Complex -> int 변환, c2.operator int()가 필요. 변환연산자 c1 = n; // int -> Complex 변환. n.operator Complex()가 있으면 되지만 // n은 객체가 아니다. } /* int main() { double d = 3.4; int n = d; Complex c(1,2); int n2 = c; //? 될까? c.operator int() 함수가 있으면 된다. } */

#include <iostream> using namespace std; //라이브러리와 변환이야기 class String { public: explicit String(char* s) {} }; void foo( String s ) {} int main() { // 아래 2줄의 차이점은? String s1("AAA"); // 1. 그냥 생성자 호출 //String s2 = "AAA"; // 2. "AAA"(즉, char*)을 변환생성자를 사용해서 임시객체로 변경 // 복사 생성자를 호출해서 임시객체를 s2에 복사! foo(s1); foo("AAA"); // char* => String 변환이 되어야 한다. 하지만 지금은 explicit이다. foo( String("AAA")); // ok! }

3. new 연산자 이야기

#include <iostream> using namespace std; // new 연산자 이야기 - 134 ~ 137 page // 1. malloc : 메모리만 할당하고 생성자를 호출하지 않는다 - 객체가 아니다. // new : 메모리를 할당하고 생성자 호출 - 객체다 // 2. new의 정확한 동작 방식 // (A) operator new()라는 함수를 호출해서 메모리를 할당하고 // (B) (A)가 성공하면 생성자를 호출하고 // (C) static_cast로 객체타입으로 캐스팅 한 후 리턴 해 준다. class Point { int x, y; public: Point( int a = 0, int b = 0) : x(a), y(b) { cout << "생성자" <<endl; } ~Point() { cout << "소멸자" << endl; } }; int main() { Point* p = static_cast<Point*>(operator new( sizeof(Point))); //메모리만 할당 operator delete(p); //메모리만 제거 } /* int main() { // Point* p1 = static_cast<Point*>( malloc(sizeof(Point))); // free(p1); Point* p2 = new Point; delete p2; } */

new를 오버로딩하는 것도 가능하다.

#include <iostream> using namespace std; // 1. new가 사용하는 operator new를 다시 만들 수 있다. // - size_t를 인자로 가지고 void*를 리턴해야 한다. // 2. operator new 는 오버로딩도 된다. void* operator new( size_t sz) // 1 { cout << "my new" << endl; return malloc( sz); } void* operator new( size_t sz, char* s, int n) // 2 { cout << "my new2 " << s << n << endl; return malloc( sz); } void operator delete( void* p) { cout << "my delete" << endl; free(p); } int main() { int* p = new int; // 1 delete p; int* p2 = new("AA", 3) int; //2 delete p2; }

memory leak 검사하기

// memchk.h #include <stdio.h> #include <stdlib.h> #include <string.h> #ifdef _DEBUG struct MEM { char file[256]; int line; void* addr; }; int count = 0; // 메모리 할당 횟수 MEM info[1000]; // 할당 된 메모리 정보 void* operator new(size_t sz, char* file, int line) { void* p = malloc(sz); info[count].addr = p; info[count].line = line; strcpy(info[count].file, file); ++count; return p; } //------------------------------------------------------- void operator delete( void* p) { for ( int i = 0; i < count; i++ ) { if (info[i].addr == p ) // 할당정보 찾았다. { info[i] = info[count -1]; // 배열에서 제거 --count; free(p); break; } } } #define new new(__FILE__, __LINE__) int _main(); int main() { _main(); if (count > 0) { printf("%d개의 메모리 누수가 있습니다.\n", count); for (int i=0; i < count; i++) { printf("%s(%d), %p\n", info[i].file, info[i].line, info[i].addr); } } } // 마지막 할일은 ?? #define main _main // 동일한 원리에 의해서 C도 가능하다. //#define malloc(x) mymalloc(x, __FILE__, __LINE__) //#define free(x) myfree(x) #endif //new연산자이야기3.cpp #include <iostream> #include "memchk.h" using namespace std; // new의 다양한 활용(137 ~ 141) 1. - 메모리 릭 검출하기 -139 pg int main() { int* p1 = new int; int* p2 = new int; int* p3 = new int; // delete p2; return 0; // cout << __FILE__ << endl; // cout << __LINE__ << endl; // cout << __TIME__ << endl; }

placement new 개념

// placement new 개념
// 1. 기존의 메모리에 대해서 생성자를 호출할 때 사용하는 기술
// 2. new(기존메모리 주소) 타입;
// 3. C로  할당한 메모리(공유메모리등)을 객체처럼 사용하려고...
// 4. 또는 Template을 활용한 고성능 라이브러리 만들 때 주로 사용
//    안드로이드의 typehelpers.h 가 이 기술 사

#include <iostream> using namespace std; // placement new 개념 // 1. 기존의 메모리에 대해서 생성자를 호출할 때 사용하는 기술 // 2. new(기존메모리 주소) 타입; // 3. C로 할당한 메모리(공유메모리등)을 객체처럼 사용하려고... // 4. 또는 Template을 활용한 고성능 라이브러리 만들 때 주로 사용 // 안드로이드의 typehelpers.h 가 이 기술 사용 class Test { public: Test() { cout << "생성자" << endl; } ~Test() { cout << "소멸자" << endl; } }; /* void* operator new(size_t sz, void* p) { return p; } */ int main() { Test* p = new Test(); // 메모리 할당, 생성자 호출 new(p) Test; //????? //p->Test(); //error p->~Test(); //ok... delete p; // 소멸자 호출, 메모리 해제 }

분명히 new에서는 메모리 할당을 하지 않았음에도 불고하고, 객체를 리턴함으로써 생성자/소멸자를 호출한다.(확인)

안드로이드에서는 프로세스간 Binder를 써서 통신하는데, 이때 쓰는게 mmap이다. 이와 비슷하게

class Queue { int front; int rear; int buff[100]; public: Queue() : front(0), rear(0) {} // 초기화 코드 void push(int a) { buff[front++] = a;} }; int main() { Queue* p = (Queue*)malloc(sizeof(Queue)); //공유메모리 할당 코드라고 가정 new(p) Queue; //생성자 호출 //이제 c++객체가 되었으므로.. 안전하게 사용가능! p->push(10); //다 사용한 후에는 p->~Queue(); //소멸자를 호출하고 // 공유 메모리 해지하는 함수를 사용해서 메모리 해지 free(p); }

이제 new와 예외처리에 대해서 알아보자.

#include <iostream> using namespace std; // new와 예외. 그리고 생성자! class Test { }; int main() { //다음중 잘못된 곳을 지적해 보세요 int* p = new int[100]; if (p == 0) { cout << "메모리부족" << endl; } else delete[] p; }

멀쩡해 보이나?  1998년 이후, new가 실패 했을 경우, 더 이상 0을 리턴하지 않는다.

대신 다음과 같이 try... catch블록을 써서 체크해야 한다.

// 100 page 아래 박스 int main() { try { int* p = new int[100]; //이곳까지 왔다면 무조건 할당 성공 delete[] p; } catch(bad_alloc& e) { cout << "메모리부족" << endl; } }

만약 아래와 같이 메모리가 부족하면, p2의 생성자는 소멸이 되는가??

class Test { int* p1; int* p2; public: Test() { p1 = new int[100]; //할당 성공 p2 = new int[100]; //이순간 메모리가 부족하다면??? } ~Test() {delete[] p1; delete[] p2; } }; int main() { try { Test t; } catch(bad_alloc& e) { } }

안된다. 완전하게 끝난 생성자만 소멸이 가능하다.

그래서 두가지 해결책이 있다.

첫째로 스마트 포인터를 사용한다.

class Test { //int* p1; //int* p2; sptr<int> p1; sptr<int> p2; public: Test() { p1 = new int[100]; //할당 성공 p2 = new int[100]; //이순간 메모리가 부족하다면??? } //~Test() {delete[] p1; delete[] p2; } //스마트 포인터일 경우 해지 필요없다. };

두번째로 생성자에서 자원을 할당하지 말고 자원할당 전용함수를 만들어 사용한다.

// 2. 생성자에서 자원 할당하지 말고 자원할당 전용함수를 만들어 사용하자 (Construct) class Test { int* p1; int* p2; //sptr<int> p1; //sptr<int> p2; public: Test() { //p1 = new int[100]; //할당 성공 //p2 = new int[100]; //이순간 메모리가 부족하다면??? } //생성자에서 자원을 할당하지 말자!! 대신 할당전용함수를 만들자. void Construct() { p1 = new int[100]; p2 = new int[100]; } ~Test() {delete[] p1; delete[] p2; } //~Test() {delete[] p1; delete[] p2; } //스마트 포인터일 경우 해지 필요없다. }; int main() { try { Test t; t.Contruct(); } catch(bad_alloc& e) { } }

전체적인 소스는 다음과 같다.

#include <iostream> using namespace std; // new와 예외. 그리고 생성자! // 생성자 호출에 성공한 객체만이 소멸자를 호출한다. // 해결책 // 1. 스마트 포인터 사용 // 2. 생성자에서 자원 할당하지 말고 자원할당 전용함수를 만들어 사용하자 (Construct) class Test { int* p1; int* p2; //sptr<int> p1; //sptr<int> p2; public: Test() { //p1 = new int[100]; //할당 성공 //p2 = new int[100]; //이순간 메모리가 부족하다면??? } //생성자에서 자원을 할당하지 말자!! 대신 할당전용함수를 만들자. void Construct() { p1 = new int[100]; p2 = new int[100]; } ~Test() {delete[] p1; delete[] p2; } //~Test() {delete[] p1; delete[] p2; } //스마트 포인터일 경우 해지 필요없다. }; int main() { try { Test t; t.Contruct(); } catch(bad_alloc& e) { } } /* // 100 page 아래 박스 int main() { try { int* p = new int[100]; //이곳까지 왔다면 무조건 할당 성공 delete[] p; } catch(bad_alloc& e) { cout << "메모리부족" << endl; } } int main() { //다음중 잘못된 곳을 지적해 보세요 int* p = new int[100]; if (p == 0) { cout << "메모리부족" << endl; } else delete[] p; } */

4. 함수객체

함수객체에 대해서 알아보자.

#include <iostream> using namespace std; // 함수 객체 이야기 - 142 page // 1. 함수 객체(Function Object, Functor) : ()연산자를 재정의 해서 함수처럼 사용할 수 있는 객체 struct Plus { public: int operator()(int a, int b) { return a + b; } }; int main() { Plus p; // 예제) *p => p.operator*() int n = p(1, 2); // p.operator()(1, 2) cout << n << endl; }  

예제처럼, 객체를 함수처럼 연산자 오버로딩을 통해서 사용할 수 있다.

전에 함수포인터는 inline 치환이 불가능했었는데, 함수객체를 사용하면, 가능하게 된다.(예제만 설명하느라 컴파일은 안된다)

#include <iostream> using namespace std; // 함수 객체 이야기 - 142 page // 1. 함수 객체(Function Object, Functor) : ()연산자를 재정의 해서 함수처럼 사용할 수 있는 객체 // 2. 장점 : 1. 일반 함수보다 빠르다?(인라인 치환이 가능하다) // 2. 상태를 가지는 함수 // 3. signature가 동일한 함수는 같은 타입이다. // signature가 동일한 함수객체는 다른 타입이다. // 인라인 치환이 안된다. //void Sort(int* x, int n, int(*cmp)(int, int)) //{ //} //inline int cmp1(int a, int b) {return a - b;} //inline int cmp2(int a, int b) {return b - a;} // //------------------------------------------------ struct less { bool operator()(int a, int b) {return a < b;} }; struct greater { bool operator()(int a, int b) {return a > b;} } //함수 객체는 다른 타입이기 때문에, inline이라도 치환이 가능하다. template<typename T> void Sort(int* x, int n, T cmp) { if (cmp(x[i], x[j])) ... } int main() { less cmp1; greator cmp2; Sort(x, 10, cmp1); // Sort( int*, int, less) 함수 생성 Sort(x, 10, cmp2); // Sort( int*, int, greater) 함수 생성 // 코드가 2개가 생성된다. }

함수객체의 장점은 즉, inline함수를 쓸 수 있으니, 빠르다는 점이 있겠다

sort를 통해서 함수객체에 대해서 더 알아보자.

#include <iostream> #include <algorithm> // 우리가 만든 sort가 여기 있습니다. #include <functional> // less, greater등의 함수객체 가 있습니다. using namespace std; int main() { int x[10] = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10}; //qsort(x, 10, sizeof(int), cmp1); // c 표준 함수 // 10000 개 이상 비교시 성능 저하 있음 sort( x, x + 10); // c++ 표준함수 .. 기본 연산자 <로 비교 // 주의 시작과 개숫가 아니라 시작과 끝다음 전달 greater<int> cmp; // int 2개를 >로 비교하는 함수객체 sort( x, x + 10, cmp); for (int i = 0; i < 10; i++) cout << x[i] << endl; }

좀 더 다듬어 보자.

#include <iostream> #include <algorithm> // 우리가 만든 sort가 여기 있습니다. #include <functional> // less, greater등의 함수객체 가 있습니다. using namespace std; template<typename T> struct absLess { bool operator()(T a, T b) { return abs(a) < abs(b); } }; int main() { int x[10] = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10}; //qsort(x, 10, sizeof(int), cmp1); // c 표준 함수 // 10000 개 이상 비교시 성능 저하 있음 sort( x, x + 10); // c++ 표준함수 .. 기본 연산자 <로 비교 // 주의 시작과 개숫가 아니라 시작과 끝다음 전달 absLess<int> cmp; // int 2개를 >로 비교하는 함수객체 sort( x, x + 10, cmp); for (int i = 0; i < 10; i++) cout << x[i] << endl; }

쉬어가는 코너

#include <iostream> using namespace std; //이제 싱글 링크드 리스트를 만들어 봅시다. template<typename T> struct Node { T data; Node* next; Node( T a, Node* n ) : data(a), next(n) {} }; template<typename T> class iterator { Node<T>* current; public: iterator(Node<T>* p = 0) : current(p) {} //xfind로 보내려면 ++, !=, * 연산이 되어야 한다. iterator& operator++() { // current = current->next; return *this; } T& operator*() { return current->data;} bool operator!=( const iterator& s) { return current != s.current; } bool operator==( const iterator& s) { return current == s.current; } }; template<typename T> class slist { Node<T>* head; public: slist() : head(0) {} // 모든 컨테이너 설계자는 자신의 요소를 가리키는 반복자 이름을 iterator라는 // 이름으로 외부에 알려주기로 약속하자. typedef slist_iterator<T> iterator; void push_front( const T& a ) { head = new Node<T>( a, head ); } // 모든 컨테이너는 자신의 시작과 마지막 다음 요소를 가리키는 스마트 포인터를 // 리턴하기로 약속하자 iterator begin() { return iterator<T>(head); } iterator end() { return iterator<T>(0); } }; int main() { slist<int> s; s.push_front(10); s.push_front(20); s.push_front(30); s.push_front(40); // 이순간의 메모리 그림이 130 page에 있습니다. // iterator<int> p2 = xfind( s.begin(), s.end(), 20); //복사해오세요 // cout << *p2 << endl; // 20 slist<int>::iterator p = s.begin(); while ( p != s.end() ) { cout << *p << endl; ++p; } }

5. STL

아래의 코드를 참조하자.

#include <iostream> #include <list> #include <string> #include <vector> #include <algorithm> #include <functional> using namespace std; // STL : Standard Template Library => C++ 표준이 제공하는 라이브러리 // list, vector, set, map, string 등의 클래스(컨테이너라고 부릅니다.) // find(), sort()등의 함수(알고리즘이라고 부릅니다. 일반함수) // // 안드로이드 : 자체적으로 list, vector, stringe등을 자체적으로 지원 // STL도 사용가능 int main() { vector<int> v(5); // 5개짜리 배열처럼 동작하는 클래스 for (int i = 0; i < 5; i++) v[i] = i; reverse( v.begin(), v.end() ); sort(v.begin(), v.end()); for (int i = 0; i < 5; i++) cout << v[i] << endl; // v에서 처음 반복자를 꺼내보세요. vector<int>::iterator p = v.begin(); cout << *p << endl; } /* int main() { string s = "hello"; string::iterator p = s.begin(); ++p; cout << *p << endl; sort(s.begin(), s.end()); cout << s << endl; // 무작위로 섞는 함수는 random_shuffle()입니다. 섞어서 출력해 보세요. } */

6. 상속

생성자는 부모 먼저 불리우고, 자식의 생성자가 불리며 소멸자는 반대의 순서이다.

#include <iostream> using namespace std; // 상속에서의 생성자/소멸자 이야기 - 80 page // 1. 상속에서의 생성자 호출 순서 // 2. 기본적으로 부모생성자는 디폴트 생성자 호출 class Animal { public: Animal() { cout << "Animal()" << endl; } // 1 Animal(int n) { cout << "Animal(int)" << endl; } // 2 ~Animal() { cout << "~Animal()" << endl; } // 3 }; class Dog : public Animal { public: Dog() { cout << "Dog()" << endl; } // 4 Dog(int n) { cout << "Dog(int)" << endl; } // 5 //Dog(int n) : Animal(n) { cout << "Dog(int)" << endl; } // 2번을 부름 ~Dog() { cout << "~Dog()" << endl; } // 6 }; int main() { Dog d(1) // 1 -> 5 -> 6 -> 3 (자식이 디폴트가 아니더라도 부모는 디폴트 생성자 호출) // 하지만 자식에서 부모생성자를 명시적으로 호출하면 2번을 호출 할 수 있다. Dog d; // 1 -> 4 -> 6 -> 3 }

Dog()에서 비록 우리가 아무런 부모생성자 호출 코드를 안 넣었어도 컴파일러가 Dog() : Animal() { ...} 이런 식으로 추가해 준다.  즉 부모 생성자가 먼저 만들어지더다라도, 자식 생성자가 먼저 호출은 된다.

protected에 대한 문제

class Animal { protected: //외부에서 접근금지, 자식은 접근가능 Animal() {} }; class Dog : public Animal { public: Dog() {} }; // 다음 중 에러 Animal a; // error Dog d; // ok

protected 생성자는 자신은 만들 수 없지만, 자식은 만들 수 있게 하는 기술.

어떤 관계로 상속 받았냐에 따라서 자식이 물려받은 변수에 영향을 미친다.

#include <iostream> using namespace std; // 접근 변경자 - 82 page // class A { private: int a; protected: int b; public: int c; }; /* class B : public A { int a; //메모리에 놓이지만 접근은 안됌 protected: int b; // public: int c; }; class B : protected A // protected이하의 권한을 overwrite // (public -> protected, protected -> protected) { int a; //메모리에 놓이지만 접근은 안됌 protected: int b; // protected: int c; }; class B : private A // private 이하의 권한을 overwrite // (private, protected, public -> private) { int a; protected: int b; public: int c; }; */ class B : private A { }; int main() { A aaa; B bbb; aaa.c = 0; // 1 bbb.c = 0; // 2. error 자식은 private으로 물려받음 }

근데 왜 private을 쓸까? (정말 몰라서 묻는건 아니고, 다음 예제를 보자는 말이다)

#include <iostream> using namespace std; // 접근 변경자 - 82 page // // 왜 private상속이 필요할까? // list가 이미 있다. #include <list> //그런데 스택이 필요하다. // 1. stack을 만들자 // 2. list를 한쪽 방향으로만 사용하면 스택이다. list를 재사용하자! // Adapter 패턴 : 기존 클래스의 인터페이스(함수이름)만 변경해서 다른 클래스처럼 // 보이게 하는 기술 // private상속 : 구현은 물려받지만(즉, 부모의 함수를 자식이 내부적으로 사용하지만) // 인터페이스는 물려받지 않겠다.(즉, 부모의 함수를 외부로 노출하지는 않겠다) // 는 철학을 담은 기술. template<typename T> class Stack : public list<T> { public: inline void push(const T& a) {push_back(a);} // 부모의 함수 다시 호출 inline void pop() {pop_back();} inline T& top() {return back();} }; int main() { Stack<int> s; s.push(10); s.push_front(20); // 이런건 스택의 개념에 맞지 않는다. private으로 막자 cout << s.top() << endl; }

Vector클래스의 상속권한을 private으로 바꾸자.

template<typename T> class Stack : public list<T> { public: inline void push(const T& a) {push_back(a);} // 부모의 함수 다시 호출 inline void pop() {pop_back();} inline T& top() {return back();} };

7. Upcasting

자식 클래스는 public으로 상속 받았을 경우, 부모가 요구되는 인자에 자식 클래스로서 갈 수 있다.

좀 더 자세한 Upcating에 대한 소스를 보자.

#include <iostream> using namespace std; // upcasting - 아주 중요합니다. // 1. 부모 포인터로 자식의 주소를 담을 수 있다. 부모* = &자식 // 부모 참조 변수 = 자식 객체 // 2. 장점 및 활요 // (A) 동종(동일 부모자식)을 처리하는 함수를 만들 수 있다 // (B) 동종(동일 부모자식)을 저장하는 컬렉션(배열, list등)을 만들 수 있다. // 3. 주의할 점 // 부모포인터 자식 객체를 가리킬때 자식의 고유한 멤버에 접근할 수 없다. // 접근하려면 자식 타입으로 다시 캐스팅으로 해야 한다. class Animal { public: int age; void Cry() {} }; class Dog : public Animal{}; class Cat : public Animal { public: int color; }; int main() { Cat c; Animal* p = &c; // Upcasting p->age = 10; // ok. Animal에세 물려받은 멤버 p->color = 10; // error. Cat의 고유멤버 // 대신 아래와 같이 casting해야 함 static_cast<Cat*>(p)->color = 10; // ok } /* //void NewYear( Dog* p ) // Dog만 처리하는 함수 //void NewYear( void* p) // 모든 포인터를 처리하는 함수 //void NewYear( T p ) // 모든 타입을 처리하는 함수 //void NewYear(Animal* p) // 모든 동물(Animal 자식)을 처리하는 함수 { ++p->age; } int main() { //Dog* woori[10]; Animal* woori[10]; Dog d; NewYear(&d); Cat c; NewYear(&c); } */ /* void foo(Animal* p) { } int main() { Animal a; foo(&a); //ok Dog d; foo(&d); //될까요? } */

8. 함수 오버라이딩

부모의 함수가 적당하지 않을 때, 같은 이름의 함수로 오버라이드를 할 수 있다.

예를 들어,

Anima* p = &Dog;

라고 있을 때,

p->Cry()

라고 하면,

A:Cry(),

B:Cry()

중 어느 함수를 불러야 할지 결정하게 되는데 이를 바인딩이라고 한다.

바인딩(binding)은 다음의 두 종류가 있다.

관련된 코드는 아래를 참조하자.
#include <iostream> using namespace std; // 함수 오버라이드 와 가상함수 class Animal { public: void Cry() { cout << "Animal::Cry" << endl; } // 1 }; class Dog : public Animal { public: // void Cry() { cout << "Dog::cry" << endl; } // 2 }; int main() { Animal a; a.Cry(); // 1 Dog d; d.Cry(); // 2 Animal* p = 0; // 다형적 객체 int n; cin >> n; if (n == 1) p = &d; else p = &a; p->Cry(); // 1 ? 2 } //바인딩(binding) // static binding : 컴파일러가 컴파일시간에 결정. 원리는 포인터 타입으로 호출 // (early binding) c++, c# // // dynamic binding : 컴파일러가 컴파일시 메모리 조사하는 코드를 생성. // 실행시 메모리에 어떤 객체가 있는지 조사해서 호출 // (late binding) java, objective-c, c++(virtual), c#(virtual)

마지막으로 OOP 개념을 살린 예제 코드 한번 보자.(두번 보자)

#include <iostream> #include <vector> using namespace std; // 파워포인트와 같은 도형편집기를 만들어 보자. // 1. 각 도형을 타입으로 만들자. // 2. 공통의 부모가 있다면, 모든 도형을 묶어서 관리 할 수 있다. // 3. 모든 자식의 공통적인 특징은 반드시 부모로부터 제공되어야 한다. // 그래야 묶어서 처리 할 수 있다!! Liskov Substitution Principle (LSP라고 한다) // 4. 부모의 함수 중 자식이 재정의 하게 되는 함수는 반드시 가상함수로 해야 한다. // 그래야 묶어서 처리 할 때 제대로 동작한다. // "가상함수가 아니라면 재정의 하지 말라" => effective c++에 있는 격언 // 5. OCP : 기능 확장에 열려있고 (Open) // 코드 수정에는 닫혀 있어야 하고 (Close) // 한다는 이론 (Principle) // "다형성은 OCP를 만족하는 좋은 디자인 기술이다!" // 6. Prototype 디자인 패턴 : 자신의 복사본을 만드는 가상함수 // 7. 리팩토링 책에 있는 문장입니다. 잘 생각해보세요 // "Replace Type Code with Polymorphism" // 8. 모든 자식에 공통의 전체 알고리즘은 부모가 제공한다. // 하지만 변경되어야 하는 세부 알고리즘은 protected 가상함수로 제공한다. // 전체 알고리즘함수에서 세부 알고리즘 함수를 호출해서 세부알고리즘은 자식이 변경 // 할수 있게 하자! // "templated method" 라는 디자인 패턴 // c++ 진영에서는 NVI(Non Virtual Interface)라고도 부른다. class Shape { public: /* virtual void Draw() { //mutex.lock(); cout << "Shape::Draw" << endl; //mutex.unlock(); } */ void Draw() { //mutex.lock(); RealDraw(); //mutex.unlock(); } protected: virtual void RealDraw() {} // 자신의 복제본을 만드는 가상함수... // GoF's 의 디자인 패턴 중 prototype 패턴이라고 불리우는 패턴입니다. // 흔히 '가상복사 생성자'라고도 부릅니다. virtual Shape* Clone() { return new Shape(*this); } }; class Rect : public Shape { public: virtual void RealDraw() { cout << "Rect::Draw" << endl; } virtual Shape* Clone() { return new Shape(*this); } }; class Circle : public Shape { public: virtual void RealDraw() { cout << "Circle::Draw" << endl; } virtual Shape* Clone() { return new Shape(*this); } }; int main() { vector<Shape*> v; while(1) { int cmd; cin >> cmd; if (cmd == 1) v.push_back(new Rect); else if (cmd == 2) v.push_back(new Circle); else if (cmd == 8) { cout << "몇번째 도형을 복사 할까요 >> "; int k; cin >> k; //k번째 도형을 복사해서 v에 추가한다. 어떻게 해야 할까요? v.push_back( v[k]->Clone()); //다형성 } else if (cmd == 9) // 모든 도형을 그린다. { for (int i = 0; i < v.size(); i++) v[i]->Draw(); //당형성(Polymorphism) : 동일함수 호출이 상황 //(객체종류, 인자등)에 따라 다른 함수를 호출하는 것 } } }  

   모든 자식에 공통의 전체 알고리즘은 부모가 제공한다.
   하지만 변경되어야 하는 세부 알고리즘은 protected 가상함수로 제공한다.
   전체 알고리즘함수에서 세부 알고리즘 함수를 호출해서 세부알고리즘은 자식이 변경 할 수 있게 하자!

Binder의 Iinterface내에 이 디자인 패턴을 사용했다.

이 글의 모든 소스는 Android Framework 분석을 위한 C++ 강좌에 사용된 코드이며 저에겐 코드에 대해 아무런 권리도 없음을 밝힙니다.

1. 초기화 리스트(Colon Initialize)

클래스 멤버로로 상수나 참조 멤버가 있는 경우, 반드시 초기화리스트로 초기화해야 한다.

#include <iostream> using namespace std; // 주제 1. 초기화 리스트 - 51 page // 1. 개념 : 생성자 뒤에 : 을 표시하고 멤버를 초기화 하는 문법 // 2. 특징 : 진짜 초기화이다. 생성자 {} 안에서 하는 초기화는 진짜 초기화가 아니고 대입이다. // 3. 반드시 초기화리스트를 사용해야 하는 경우가 있다. // (A) 클래스의 멤버로 상수나, 참조 멤버가 있는 경우 반드시 초기화리스트로 초기화해야한다. class Point { int x; int y = 0; // error, c++은 filed initilization가 아직 지원되지 않는다. //다음 중 맞는 것은? const int c; // 1. ok const int c = 0; // 2. error public: Point( int a = 0, int b = 0 ) : x(a), y(b), c(0) // 진짜 초기화 { c = 0; // error. 이자리는 대입, 상수에 대입 불가, 대신 위의 진짜 초기화에서 해야 함. // x = a; // 대입 // y = b; } }; int main() { const int c; // error 초기화 필요 Point p(1, 2); Object a; // 1) 생성자 a = 0; //대입 2) 대입연산자 호출 // 2번 작업을 하게 된다. Object b = 0; //초기화 생성자 호출 }

만약 디폴트 생성자가 없는 객체를 멤버로 가질 때 초기화 리스트로 초기화 해야 한다.

// (B) 디폴트 생성자가 없는 객체를 멤버로 가질 때 초기화 리스트로 초기화 해야 한다. class Point { int x, y; public: Point( int a, int b ) : x(a), y(b) {} }; class Rect { Point p1; Point p2; public: Rect() : p1(0, 0), p2(0, 0) // Point가 디폴트생성자가 없으므로, 여기서 초기화 해 준다. { } }; int main() { //다음 중 에러는? Point p1; // 1. erorr. 디폴트 생성자가 없다. Point p2(1,2); // 2. ok }

주의할 점은, 초기화는 클래스의 멤버가 선언된 순서대로 초기화 된다.

참고로 생성자를 클래스 외부에 구현했을 때 초기화 리스트는 다음 줄에 표기하자.

//생성자를 클래스 내부가 아닌 외부에 구현했을 때의 초기화 리스트 모양을 알아두세요. Point::Point(int a, int b) : x(a), y(b) { }

2. 상수 함수

상수 함수가 필요한 이유

우선 다음과 같은 코드를 보자.

#include <iostream> using namespace std; // 주제 2. 상수 함수 이야기 - 69 page. 쉬워 보이지만 약간 어려움 // 1. 개념 : 모든 멤버 data를 상수 취급하는 함수 class Point { public: int x, y; Point( int a = 0, int b = 0 ) : x(a), y(b) {} void setY( int a ) { y = a; } void print() const // 뒤에 const가 붙으면 이 함수 안에서는 모든 멤버 data를 상수 취급. // 즉 값을 변경할 수 없다. { x = 0; // error. x는 상수이다. cout << x << ", " << y << endl; } }; int main() { Point p(1, 2); p.print(); }

근데 뭐 나는 const가 들어 갈 함수 안에 값을 안 바꿀거니, const 따위 필요 없다! 라고 생각하고 한번 제외하고 코드를 짜보자. 그러면 , print는 안에 아무것도 변하지 않으니 실행될 거 같지만?.. 안된다!

#include <iostream> using namespace std; // 주제 2. 상수 함수 이야기 - 69 page. 쉬워 보이지만 약간 어려움 // 1. 개념 : 모든 멤버 data를 상수 취급하는 함수 class Point { public: int x, y; Point( int a = 0, int b = 0 ) : x(a), y(b) {} void setY( int a ) { y = a; } void print() //const // 뒤에 const가 붙으면 이 함수 안에서는 모든 멤버 data를 상수 취급. // 즉 값을 변경할 수 없다. { //x = 0; // error. x는 상수이다. cout << x << ", " << y << endl; } }; int main() { const Point p(1, 2); p.x = 10; //error p.setY(10); //error p.print(); //이 표현이 되려면 print()는 상수 함수 이어야 한다. }

상수 객체는 상수 함수만 호출 할 수 있다.

그러면 뭐 난 상수랑 안 쓰겠다? 하면 될까? 다음 코드를 보자.

class Rect { int x, y, w, h; public: //int GetArea() {return w * h;} int GetArea() const {return w * h;} }; //void foo( Rect r ) // 이렇게 객체 자체를 받을 경우 메모리 낭비가 심하므로 1일차에 void foo( const Rect& r) // 이렇게 const T&로 받자고 했으니, 이럴 경우에는 const가 필요 { int n = r.GetArea(); } int main() { Rect r; int n = r.GetArea(); foo(r); }

결론은 라이브러리 제작이나 완전한 클래스를 제공할려면 const를 만들어야 한다.

간단한 룰은 값을 변하게 하는 함수라면 const가 필요 없으나, 그 외에는 const를 붙여야 한다.

3. 복사 생성자

#include <iostream> using namespace std; // 복사 생성자 이야기 58 ~ 61 // 1. 복사 생성자 : 자신의 타입으로 초기화 하는 생성자. 정확한 모양 알아두세요 // 2. 사용자가 만들지 않으면 컴파일러가 제공해 준다. // 기본 구현은 모든 멤버 data를 복사 해 준다. class Point { public: int x, y; Point() : x(0), y(0) {} // 1 Point( int a, int b ) : x(a), y(b) {} // 2 // 아래 p3용으로 사용자가 만들지 않으면 컴파일러가 아래의 복사 생성자를 제공해 줍니다. /* Point (const Point& p) : x(p.x), y(p.y) { } */ }; int main() { Point p1; // 1 번 생성자 호출 Point p2(1, 2); // 2 번 생성자 호출 Point p3(p2); // Point( Point )의 생성자가 필요하다. cout << p3.x << endl; }

다음의 코드를 실행하면 결과가 어떻게 나올까?

#include <iostream> using namespace std; // 주제 3-2. 복사 생성자가 호출되는 3가지 경우 - 59 pages class Point { public: Point() { cout << "생성자1" << endl;} Point( int a, int b ) { cout << "생성자2" << endl;} Point(const Point& ) { cout << "복사생성자" << endl;} ~Point() { cout << "소멸자" << endl;} }; void foo( Point p ) // Point p = p1; ==> Point p(p1) { cout << "foo" << endl; } int main() { cout << "start" << endl; Point p1(1, 2); cout << "AAA" << endl; foo(p1); cout << "BBB" << endl; }

결과는 다음과 같다.

 start
 생성자2
 AAA
 복사생성자 - p
 foo
 소멸자 - p
 BBB
 소멸자

여기서 다시 성능향상을 위해서 다음과 같이 수정하자.

//void foo( Point p ) // Point p = p1; ==> Point p(p1) void foo( const Point& p ) // 전에 말했듯이 성능향상을 위해, const T&를 사용하자 // 결과적으로 복사생성자 및 소멸자의 사용까지 줄일 수 있다. { cout << "foo" << endl; }

다음 코드의 결과를 예측해 보자.

class Point { public: Point() { cout << "생성자1" << endl;} Point( int a, int b ) { cout << "생성자2" << endl;} Point(const Point& ) { cout << "복사생성자" << endl;} ~Point() { cout << "소멸자" << endl;} }; Point foo() { Point p2(1, 2); cout << "foo" << endl; return p2; // 임시객체를 리턴 } int main() { cout << "start" << endl; Point p1; cout << "AAA" << endl; p1 = foo(); cout << "BBB" << endl; }

결과는 다음과 같다.

 start
 생성자1 - p1
 AAA
 생성자2 - p2
 foo
 복사생성자 - 임시객체
 소멸자 - p2
 소멸자 - 임시객체
 BBB
 소멸자

다시 성능 향상을 위해 임시객체에 대한 작업을 하려고 하지만, 예전과 달리 이번에는 전역객체가 아닌 지역객체를 리턴함으로, 다음과 같이 하면 안된다. (지역변수등을 리턴할 때, 참조를 쓰면 안된다.)

대신 RVO를 써서, 다음과 같이 바꾸면 된다.

Point foo() { // Point p2(1, 2); // cout << "foo" << endl; // return p2; // 임시객체를 리턴 //먼저 하고 싶은 일을 하고 cout << "foo" << endl; //되도록이면 객체를 만들면서 리턴하자. RVO(return value Optimazation)기술 return Point(1, 2); //리턴용 객체 1개만 생성된다. }

한가지 주의할 점은, 만약에 우리가 복사생성자를 다음과 같이 만들었다고 치자(성능은 잠시 접어두고)

class Point { public: Point() { cout << "생성자1" << endl;} Point( int a, int b ) { cout << "생성자2" << endl;} //Point(const Point& ) { cout << "복사생성자" << endl;} ~Point() { cout << "소멸자" << endl;} //아래처럼 복사 생성자를 만들어도 될까? // error. 복사 생성자가 무한히 호출되는 표현!!! Point( Point p ) { } // ok 하지만 p가 변경되지 않는다는 것을 보장하기 위해 const 추가 Point( Point& p ) { } }; int main() { Point p1(1, 2); Point p2(p1); // }

복사 생성자가 인자로 디폴트를 넘기는 이게 또 복사 생성자를 부르고 하는 무한 반복 코드가 되서 컴파일 에러가 난다.

복사 생성자는 또 디폴트 복사 생성자에 대한 문제점이 있는 해결책은 다음의 4가지이다.

    (A) 깊은 복사    - 가장 널리 알려진 기술. 하지만 별로 좋지 않다.   

    (B) 참조 계수    - 가장 많이 사용하고, 가장 좋은 기술
    (C) 소유권 이전 - 많이 사용하고 있진 않지만 swap등을 만들 때 좋다.
                             STL의 auto_ptr<>이 이 기술 사용
    (D) 복사 금지

우선 기본적으로 얕은 복사 때문에 생기는 문제의 코드다.

// 얕은 복사의 문제점 class Cat { char* name; int age; public: Cat( char* n, int a ) : age(a) { name = new char[strlen(n) + 1]; strcpy( name, n ); } ~Cat() { delete[] name; } }; int main() { Cat c1("NABI", 10); Cat c2(c1); // runtime error발생 }

깊은 복사 (성능의 문제가 있다)

class Cat { char* name; int age; public: // 60 page 중간 Cat( const Cat& c) : age(c.age) // 포인터가 아닌 멤버를 그대로 복사 { name = new char[strlen(c.name) + 1]; //포인터 멤버는 메모리 할당 후 strcpy( name, c.name ); // 메모리 자체를 통째로 복사! } Cat( char* n, int a ) : age(a) { name = new char[strlen(n) + 1]; strcpy( name, n ); } ~Cat() { delete[] name; } }; int main() { Cat c1("NABI", 10); Cat c2(c1); }

참조계수(Referecen Counting)

// 참조계수 기법. - 가장 주용한 기술 .. - 안드로이드의 모든 객체의 원리! class Cat { char* name; int age; int* ref; static int ref // 이렇게 하면 안된다. 반드시 동적 메모리 할당을 해야 한다. public: Cat( char* n, int a ) : age(a) { name = new char[strlen(n) + 1]; strcpy( name, n ); ref = new int(1); //? } // 참조 계수 기반의 복사 생성자 Cat( const Cat& c ) : name(c.name), age(c.age), ref(c.ref) { ++(*ref); } ~Cat() { if ( --(*ref) == 0) { delete[] name; delete ref; } } }; int main() { Cat c1("NABI", 10); Cat c2(c1); }

소유권 이전 (살짝 헷갈리는 부분)

// 소유권 이전 class Cat { char* name; int age; public: Cat( Cat& c ) // 주의 const가 없다! : name(c.name), age(c.age) { c.name = 0; c.age = 0; } ~Cat() { delete[] name; } }; int main() { Cat c1("NABI", 10); Cat c2(c1); }

복사 금지

// 복사 금지 : private영역에 복사 생성자를 선언만 한다. // 60 page 아래쪽에 있습니다. // 이 기술은 의외로 오픈소스등에서 많이 볼 수 있습니다. class Cat { char* name; int age; // private 복사 생성자 //Cat( const Cat& c) {} //밑의 foo에서 복사하는 걸 에러 내기 위해서 Cat( const Cat& c); 로 선언만 한다. public: void foo() { Cat c1("AA", 20); Cat c2(c1); //이것도 에러나게 하자. //private 복사 생성자를 구현하지 말고 선언만 한다. } Cat( char* n, int a ) : age(a) { name = new char[strlen(n) + 1]; strcpy( name, n ); } ~Cat() { delete[] name; } }; 

4. 싱글톤

오직 한개의 객체만을 만드는 디자인 패턴

우선 기본적인 코드를 보자.

// 66 page -- Effective-C++의 저자인 scott mayer가 제안한 방식 class Cursor { private: Cursor() {} Cursor( const Cursor&); //복사 금지 void operator=(const Cursor&); //대입 금지 public: // 오직 한개의 객체만 만들 수 있게 하는 멤버 함수 // static 멤버 함수로 static Cursor& GetInstance() { static Cursor instance; return instance; } }; int main() { //Cursor c1, c2; Cursor& c1 = Cursor::GetInstance(); Cursor& c2 = Cursor::GetInstance(); Cursor c3(c1); // 임의로 복사 생성자가 호출 cout << &c1 << endl; cout << &c2 << endl; }

이번엔 객체를 힙으로 만들자.

// 객체를 힙에 만드는 싱글톤 class Cursor { private: Cursor() {} Cursor( const Cursor&); //복사 금지 void operator=(const Cursor&); //대입 금지 static Cursor* instance; public: // 오직 한개의 객체만 만들 수 있게 하는 멤버 함수 // static 멤버 함수로 static Cursor* GetInstance() { if (instance == 0) instance = new Cursor; return instance; } }; //static 멤버 변수는 외부 초기화 필요.. Cursor* Cursor::instance = 0; int main() { Cursor* p1 = Cursor::GetInstance(); Cursor* p2 = Cursor::GetInstance(); cout << p1 << endl; cout << p2 << endl; } 

만약 우리가 Cursor말고도 KeyBoard라는 클래스를 똑같이 만들고 싶다면, 다음과 같이 코드 자동 생성을 작성해 보자.

// 매크로를 사용해서 싱글톤을 만드는 기법 #define DECLARE_SINGLETONE( classname ) private: classname(){} \ classname( const classname&); \ void operator=(const classname&); \ static classname* instance; \ public: \ static classname* GetInstance(); #define IMPLEMENT_SINGLETONE( classname ) classname* classname::instance = 0; \ classname* classname::GetInstance() \ { \ if (instance == 0) instance = new classname; \ return instance; \ } class KeyBoard { DECLARE_SINGLETONE(KeyBoard) }; IMPLEMENT_SINGLETONE(KeyBoard) // 객체를 힙에 만드는 싱글톤 class Cursor { private: Cursor() {} Cursor( const Cursor&); //복사 금지 void operator=(const Cursor&); //대입 금지 static Cursor* instance; public: // 오직 한개의 객체만 만들 수 있게 하는 멤버 함수 // static 멤버 함수로 static Cursor* GetInstance() { if (instance == 0) instance = new Cursor; return instance; } }; //static 멤버 변수는 외부 초기화 필요.. Cursor* Cursor::instance = 0; int main() { Cursor* p1 = Cursor::GetInstance(); Cursor* p2 = Cursor::GetInstance(); cout << p1 << endl; cout << p2 << endl; } 

아쉽게도 안드로이드에서는 템플릿을 응용한 기술 + 상속 기술을 사용한다. (템플릿이 조금 어렵게 구현된다) 이런한 기술을 mix in template이라고 한다.

// 안드로이드의 싱글톤 기술 template<typename T> class Singletone { protected: Singletone() {} Singletone( const Singletone&); //복사 금지 void operator=(const Singletone&); //대입 금지 static T* instance; public: // 오직 한개의 객체만 만들 수 있게 하는 멤버 함수 // static 멤버 함수로 static T* GetInstance() { if (instance == 0) instance = new T; return instance; } }; //static 멤버 변수는 외부 초기화 필요.. template<typename T> T* Singletone<T>::instance = 0; class KeyBoard : public Singletone<KeyBoard> // mix in template { }; // Car 클래스를 싱글톤으로 만들어보세요 class Car : public Singletone<Car> { }; int main() { KeyBoard* p = KeyBoard::GetInstance(); cout << p<< endl; } 

5. This

기본적인 this의 사용법이다.  여기서 cout또한 this를 이용한 것을 볼 수 있다.

p1, p2처럼 2개의 Point를 생성하면, 각 멤버 data는 객체마다 존재하지만, 코드는 공유를 한다. 그럼 어떻게 멤버 함수가 불리울 때, 어느 객체인지 알 수 있을까?

#include <iostream> using namespace std; // this 이야기 - 63 page // 1. this : 멤버 함수를 호출할때 사용한 객체의 주소. // 2. 멤버임을 명확히 할 때 사용 // 3. this를 리턴하는 함수 : 멤버 함수를 연속적으로 호출 할 수 있다. // *this를 리턴할 때는 임시객체를 막아야 한다. => 참조 리턴 // 4. this의 정확한 개념.. - C++ 멤버 함수의 원리!! class Point { int x; int y; public: void Set( int a, int b ) // void set( Point* const this, int a, int b) { this->x = a; this->y = b; } static void foo() { x = 0; // this->x = 0; error. static 함수는 this가 추가되지 않으므로 // 멤버에 접근할 수 없다. } }; int main() { Point::foo(); //객체 없이 호출. this가 추가되지 않는다. Point p1, p2; p1.Set(1,2); // 컴파일 시, Set(&p1, 1, 2) 형태로 변한다. }

위와 같이 컴파일 시에는 객체에 대한 인자를 넘길 수 있는 형태로 변환된다.  추가적으로 static의 경우 this가 필요치 않고, 사용할 수 없다.

6. 멤버 함수 포인터

#include <iostream> #include <Windows.h> using namespace std; // 멤버 함수와 함수 포인터 - 73 ~ 74 page // 1. 일반 함수 포인터에 멤버 함수의 주소를 담을 수 없다. // 2. 일반 함수 포인터에 static 멤버 함수의 주소를 담을 수 있다. class Dialog { public: void Close() // void Close( Dialog* const this) { cout << "Dialog::Close" << endl; } }; void foo() { cout << "foo" << endl; } int main() { void(*f1)() = &foo; // ok void(*f2)() = &Dialog::Close; // error지만 Close가 static이면 된다. } 

#include <iostream> #include <Windows.h> using namespace std; // c의 코드 void SetTimer( int second, void(*f)()) { while(1) { foo(); Sleep( second * 1000); } } void foo() { cout << "foo" << endl; } int main() { SetTimer(1, foo); // 1초에 한번 foo를 호출해 달라 }

#include <Windows.h> #include <iostream> using namespace std; //스레드를 클래스로 래핑하는 기술 - 아주 많이 사용합니다. 대부분의 오픈소스가 사용. // 안드로이드에도 이 기술을 사용합니다. class Thread { public: void Start(){ CreateThread( 0, 0, _threadMain, this, 0, 0 );} // 1. 아래 함수가 static이어야 되는 이유를 정확히 알아야 합니다. // 멤버 함수가 아닌 일반 함수를 넘거야 함으로, static unsigned long __stdcall _threadMain(void* p) { Thread* pThis = static_cast<Thread*>(p); // 될까? void* => 다른 타입 원래 c코드 : Thread* pThis = (Thread*)p; //main(); // 다시 가상 함수를 호출한다. this->main()으로 컴파일 되어야 한다. pThis->main(); } virtual void main() {} }; // 실제 위 라이브러리 사용자는 아래처럼 하게 된다. class MyThread : public Thread { public: virtual void main() { cout << "MyThread main" << endl; } }; //---------------------------------------------------------- int main() { MyThread t; t.Start(); } /* //기존 스레드 생성 코드 unsigned long __stdcall foo( void* p ) { return 0; } int main() { CreateThread( 0, 0, foo, (void*)10, 0, 0); } */ 

7. 연산자 재정의

#include <iostream> using namespace std; // 연산자 재정의 개념 - 104 ~ 105 // 1. + 도 함수로 만들 수 있다. => operator+( Complex, Complex) class Complex { int real; int image; public: Complex(int a, int b) : real(a), image(b) {} // 멤버 함수로 만든 +함수 Complex operator+(const Complex& c1) { return Complex(c1.real + real, c1.image + image); } // friend, 멤버 함수가 아니더라도 private멤버에 접근할 수 있게 한다. //friend Complex operator+(const Complex& c1, const Complex& c2); }; /* //멤버 함수가 아니고 friend로 접근한 경우 Complex operator+(const Complex& c1, const Complex& c2 ) { return Complex( c1.real + c2.real, c1.image + c2.image); } */ int main() { Complex c1(1,1); Complex c2(2,2); // 다음 중 가장 보기 좋은 코드는? 3번 //Complex c3 = Add(c1, c2); // 1 //Complex c4 = c1.Add(c2); // 2 Complex c5 = c1 + c2; // 3 operator+(c1, c2) 가 있으면 된다. // operator+(c1,c2) 라고 해석하기도 하고, // c1.operator+(c2) 라고 해석하기도 한다. } 

위의 코드에서 보면, 멤버 함수와 일반 함수의 용도에 따라 약간 다른 컴파일 결과가 나오는데,

일반 함수 vs 멤버 함수는 쉽게 생각해서, 연산의 결과로 멤버가 바뀔 거면(private이면) 일반함수에 접근이 불가능하기 때문에 멤버 함수로 하는게 좋고, 아닐 경우, 일반 함수로 하면 좋겠다. 

증감연산도 보자.

#include <iostream> using namespace std; // 증가 감소 연산자 재정의 - 108 page, 반복자등을 만들 때 사용 class Int32 { int value; public: inline Int32( int n = 0 ) : value(n) {} void print() { cout << value << endl; } // 전위형 ++ Int32 operator++() { ++value; return *this; } // 후위형 ++ => 사용되지 않지만 전위형과 구별하기 위해 int 인자 사용 Int32 operator++( int ) { Int32 tmp = *this; ++value; return tmp; } }; int main() { int n = 3; ++++n; // ok cout << n << endl; // 5 Int32 n2 = 3; ++++n2; // ++(++n2) => ( n2.operator++() ).operator++() n2.print(); //? }

우리가 만든 Int32도 당연히 ++가 잘 동작해야 한다. 하지만 오동작을 하는 것을 볼 수 있다( 5가 나오는 대신 4)

이를 수정하려면, 참조리턴을 해야 한다.

// 전위형 ++ ==> 연속적인 동작을 위해 참조리턴을 해야 한다. Int32& operator++() { ++value; return *this; }

마찬가지로 후위형 또한 다음과 같이 할 경우가 문제 생기는데,

이를 수정하려면, 다음과 같이 한다.

// 후위형 ++ => 사용되지 않지만 전위형과 구별하기 위해 int 인자 사용 // 상수 객체 리턴의 의미가 어렵습니다. 잘 생각해보세요 const Int32 operator++( int ) { Int32 tmp = *this; ++value; return tmp; }

한번 보면, (n2.operator++(int))는 Int32 n2가 상수가 아니기에 const Int32 operator++를 부르는데 문제가 없으나, 이를 통해 리턴되는 녀석은 상수(const)이다. 그럼 다시 (n2.operator++(int)).operator++(int)를 부르라고 하면, %상수 객체는 상수 함수만을 부를 수 있다%, 상수라서 부를 수 없다.

그리고 성능 향샹을 위해 전위형은 inline으로, 후의형은 다시 전위형을 호출하게 하자.

// 전위형 ++ ==> 연속적인 동작을 위해 참조리턴을 해야 한다. inline Int32& operator++() { ++value; return *this; } // 후위형 ++ => 사용되지 않지만 전위형과 구별하기 위해 int 인자 사용 // 상수 객체 리턴의 의미가 어렵습니다. 잘 생각해보세요 const Int32 operator++( int ) { Int32 tmp = *this; //++value; ++(*this); // 후위형은 다시 전위형을 호출하게 하자! return tmp; }

이걸로 보면 전위형이 후위형보다 성능이 좋다는 걸 알 수 있다.

for(int i = 0; i < 10; i++) 보다 for(int i = 0; i < 10; ++i)가 좋다는 말이다. 그러나 역시 똑똑한 우리의 컴파일러는 컴파일 시 이를 최적화 해 주므로 가독성을 위해 i++을 써도 된다.

8 스마트 포인터

스마트 포인터를 설명하기 위한 기본 코드를 보자.

#include <iostream> using namespace std; // 스마트 포인터 이야기 - 126 ~ 127 - 아주 중요한 개념! class Car { public: void Go() { cout << "Car Go" << endl; } ~Car() { cout << "Car 파괴" << endl; } }; int main() { Car * p = new Car; p->Go(); delete p; }

변형을 조금 가해서 코드가 조금 어려워 진다.

#include <iostream> using namespace std; // 스마트 포인터 이야기 - 126 ~ 127 - 아주 중요한 개념! class Car { public: void Go() { cout << "Car Go" << endl; } ~Car() { cout << "Car 파괴" << endl; } }; // 스마트 포인터 : 객체가 다른 객체의 포인터 역활을 하는 것 class sptr { Car* m_ptr; public: sptr( Car* p = 0 ) : m_ptr(p) {} Car* operator->() {return m_ptr;} }; int main() { sptr p = new Car; //? p->Go(); //? // Car * p = new Car; // p->Go(); // delete p; }

sptr p를 보면.. sptr은 포인터가 아니고, sptr 타입인데, p->Go()를 보면 포인터같고 Car타입 같다.. >_<

sptr 안에는 Car* 포인터가 존재하고 sptr p = new Car 는 결구 sptr p(new Car)와 같다.

p->Go()의 경우 위에 정의된  operator->()에 따른다.

이것이 스마트 포인터라고 불리우는데, 이는 포인터가 아닌 객체(다른 객체의 포인터 역활을 한다.)이며, 스마트 포인터의 장점은 생성/복사/대입/소멸의 모든 과정을 사용자가 정의 할 수 있다는 것이다.

아래는 template을 써서 위의 sptr을 일반화한 코드이다.

template<typename T> class sptr { T* m_ptr; public: sptr( T* p = 0 ) : m_ptr(p) {} ~sptr() {delete m_ptr;} T* operator->() {return m_ptr;} T& operator*() {return *m_ptr; } };

스마트 포인터와 참조계수에 대해서 알아보자.

#include <iostream> using namespace std; // 스마트 포인터와 참조 계수 class Car {}; template<typename T> class sptr { T* m_ptr; int* ref; public: sptr( T* p = 0 ) : m_ptr(p) { ref = new int(1); } sptr( const sptr& s ) : m_ptr(s.m_ptr), ref(s.ref) { ++(*ref); } ~sptr() { if ( --(*ref) == 0 ) { delete m_ptr; delete ref; } } T* operator->() {return m_ptr;} T& operator*() {return *m_ptr; } }; int main() { sptr<Car> p1 = new Car; sptr<Car> p2 = p1; // sptr<Car> p2(p1) }

그러나 스마트포인터는 레퍼런스카운터에 대한 포인터 때문에 오버헤드가 있다. 그럼 레퍼런스를 객체에 두어보자.

// 참조 계수를 스마트포인터가 아닌 객체가 관리하게 하자! class Car { int mCount; public: Car() : mCount(1) {} void incStrong() { ++mCount; } void decStrong() { if ( --mCount == 1) // 주의 1일때 파괴! delete this; } ~Car() { cout << "Car 파괴" << endl; } }; int main() { Car* p1 = new Car; p1->incStrong(); // 객체를 만들면 무조건 한번 호출하기로 하자! //Car* p2 = p1; p1->decStrong(); }

마지막으로 안드로이드에서 쓰는 방식을 따라서 써 본 코드이다.

#include <iostream> using namespace std; // 안드로이드의 모든 클래스의 최상위 부모 클래스 class RefBase { int mCount; public: RefBase() : mCount(1) {} virtual ~RefBase() {} // 가상 소멸자 .. 내일 상속 시간에.. void incStrong() { ++mCount; } void decStrong() { if (--mCount == 1 ) // 주의 1일때 파괴 delete this; } }; // 모든 클래스는 반드시 RefBase의 자식이어야 한다. class Car : public RefBase { public: void Go() { cout << "Car Go" << endl; } ~Car() { cout << "Car 파괴" << endl; } }; //안드로이드의 스마트 포인터인 sp를 봅시다 // sp 역활 : 해당 객체의 incStrong(), decStrong() 함수를 자동으로 호출하기 위해 만든 것 template<typename T> class sp { T* m_ptr; public: T* operator->() { return m_ptr;} T& operator*() { return *m_ptr;} sp( T* p = 0 ) : m_ptr(p) { if ( m_ptr != 0 ) m_ptr->incStrong(); // 일단 증가하고 시작! } sp( const sp& s) : m_ptr(s.m_ptr) { if (m_ptr != 0) m_ptr->incStrong(); } ~sp() { if (m_ptr != 0) m_ptr->decStrong(); //이 함수에서 참조 계수가 1이면 파괴해 준다. } }; int main() { sp<Car> p1 = new Car; sp<Car> p2 = p1; sp<Car> p3 = p1; sp<Car> p4 = p1; }

안드로이드는 객체가 만들어지면 레퍼런스 카운터가 1이 되고, 스마트 포인터로 가리키면 2가 된다.(보통 0에서 시작해서 스마트 포인터가 가리키면 1이된다).

9. 반복자

#include <iostream> using namespace std; //이제 싱글 링크드 리스트를 만들어 봅시다. template<typename T> struct Node { T data; Node* next; Node( T a, Node* n ) : data(a), next(n) {} }; template<typename T> class slist_iterator { Node<T>* current; public: slist_iterator(Node<T>* p = 0) : current(p) {} //xfind로 보내려면 ++, !=, * 연산이 되어야 한다. slist_iterator& operator++() { // current = current->next; return *this; } T& operator*() { return current->data;} bool operator!=( const slist_iterator& s) { return current != s.current; } bool operator==( const slist_iterator& s) { return current == s.current; } }; template<typename T> class slist { Node<T>* head; public: slist() : head(0) {} void push_front( const T& a ) { head = new Node<T>( a, head ); } // 모든 컨테이너는 자신의 시작과 마지막 다음 요소를 가리키는 스마트 포인터를 // 리턴하기로 약속하자 slist_iterator<T> begin() { return slist_iterator<T>(head); } slist_iterator<T> end() { return slist_iterator<T>(0); } }; int main() { slist<int> s; s.push_front(10); s.push_front(20); s.push_front(30); s.push_front(40); // 이순간의 메모리 그림이 130 page에 있습니다. // slist_iterator<int> p2 = xfind( s.begin(), s.end(), 20); //복사해오세요 // cout << *p2 << endl; // 20 slist_iterator<int> p = s.begin(); while ( p != s.end() ) { cout << *p << endl; ++p; } }