code cat

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; } }

아래 내용은 Android Framework 분석을 위한 C++ 강의를 정리한 내용으로 사용된 모든 소스는 강의에서 나옴을 밝힙니다.

개발환경:

Visual Studio 2010 Express

참고하기에 좋은 문서/책:

문법: Effectiv c++

template c++ template programming

디자인 패턴 : GoF's 디자인 패턴

visual c++ 개발환경에서 기본적인 빌드/실행: 

build                  : F7

build + execute   : ctrl + F5

1. 헬로 월드

#include <iostream.h> // 1988년 표준화 이전 헤더 #include <iostream> // 1988 표준화 이후 헤더 using namespace std; int main() { int a = 10; printf("hello\n"); //c의 표준 출력. stdio.h cout << "hello" << endl; // c++ 표준 출력 = cout 사용. iostream cout << a << endl; //endl => '\n'의 의미입니다. cout.operator<<(a); // cout << a 와 동일한 의미.. // 즉 cout은 객체입니다. cout << endl; endl( cout ); // 위 줄과 동일합니다. endl은 함수입니다. return 0; }

Visual Studio 2010 Express에서 리소스 부분의 .cpp 파일을 클릭해서 빌드에서 제외 하면 컴파일을 안 시키고 다른 소스를 계속 추가해서 실험해 볼 수 있음.

2. 함수 오버로딩

console에서 컴파일을 할 때, 리눅스의 경우 gcc를 사용하지만, 윈도우는 cl.exe를 사용하며 다음과 같이 컴파일 한다.

cl filename.cpp

cl filename.cpp /FAs  //assembly 소스를 만들어 달라고 요청

이제 오버로딩을 보자.(asm파일을 쉽게 보기 위해, iostream은 제외했다)

asm파일을 열어보면, 오버로딩 된 함수에 대한 이름이 각기 다른 것을 알 수 있다. (함수오버로딩의 결과물)

; Listing generated by Microsoft (R) Optimizing Compiler Version 16.00.30319.01 TITLE D:\Andy\20120423\0423\함수오버로딩.cpp .686P .XMM include listing.inc .model flat INCLUDELIB LIBCMT INCLUDELIB OLDNAMES PUBLIC ?square@@YAHH@Z ; square ; Function compile flags: /Odtp ; File d:\andy\20120423\0423\함수오버로딩.cpp _TEXT SEGMENT _a$ = 8 ; size = 4 ?square@@YAHH@Z PROC ; square ; 12 : { push ebp mov ebp, esp ; 13 : return a * a; mov eax, DWORD PTR _a$[ebp] imul eax, DWORD PTR _a$[ebp] ; 14 : } pop ebp ret 0 ?square@@YAHH@Z ENDP ; square _TEXT ENDS PUBLIC ?square@@YANN@Z ; square EXTRN __fltused:DWORD ; Function compile flags: /Odtp _TEXT SEGMENT _d$ = 8 ; size = 8 ?square@@YANN@Z PROC ; square ; 17 : { push ebp mov ebp, esp ; 18 : return d * d; fld QWORD PTR _d$[ebp] fmul QWORD PTR _d$[ebp] ; 19 : } pop ebp ret 0 ?square@@YANN@Z ENDP ; square _TEXT ENDS PUBLIC __real@400a666666666666 PUBLIC _main ; COMDAT __real@400a666666666666 CONST SEGMENT __real@400a666666666666 DQ 0400a666666666666r ; 3.3 ; Function compile flags: /Odtp CONST ENDS _TEXT SEGMENT _d$ = -16 ; size = 8 _n$ = -4 ; size = 4 _main PROC ; 22 : { push ebp mov ebp, esp sub esp, 16 ; 00000010H ; 23 : int n = square(3); // square_int(3) push 3 call ?square@@YAHH@Z ; square add esp, 4 mov DWORD PTR _n$[ebp], eax ; 24 : double d = square(3.3); sub esp, 8 fld QWORD PTR __real@400a666666666666 fstp QWORD PTR [esp] call ?square@@YANN@Z ; square add esp, 8 fstp QWORD PTR _d$[ebp] ; 25 : ; 26 : //cout << n << endl; ; 27 : //cout << d << endl; ; 28 : } xor eax, eax mov esp, ebp pop ebp ret 0 _main ENDP _TEXT ENDS END

보다시피 int 인자를 가진 함수는 ?square@@YYHH@Z 이고, double 인자를 가진 함수는 ?square@@YANN@Z라고 보인다.

그럼 다음과 같이 하면 어떨까?

// a.h 의 내용 int square(int ); // a.c 의 내용 int square( int a ) { return a * a; } //함수 오버로딩2.cpp 의 내용 #include "a.h" int main() { square(3); }

컴파일 시에는 각기 컴파일을 한 뒤 링크 과정을 거침으로, c와 c++의 혼합 컴파일 시, c에 정의된 함수는 오버로딩을 지원하지 않는 관계로 name mangling(컴파일 시 같은 오버로딩함수들의 이름을 다른 심볼 이름으로 교체)현상이 없고, 이로 인해 cpp파일의 컴파일 후, 링킹 과정에서 위에서 본 바와 같이 ?sqaure형식의 심볼이름을 찾으려다 못 찾아서 에러가 난다.

이를 해결하기 위해선, 함수 앞에 extern "c"를 붙여 주면 된다.

그러나, 만약 오버로딩함수2.cpp를 c로 변형한다면 역시나 에러가 난다. 이는 extern "C"는 cpp에서만 지원하기 때문이다.

// 변형된 a.h의 내용 // extern "C" : C++ 컴파일러에게 특정 심볼 (변수 이름, 함수이름)을 c처럼 컴파일 해달라는 지시어.. // 모든 C++ 컴파일러는 __cplusplus라는 매크로를 정의하고 있습니다. #ifdef __cplusplus extern "C" { #endif int square(int ); #ifdef __cplusplus } #endif // 결론 c/c++ 에서 모두 사용가능한 라이브러리를 구축할 때는 // 1. 라이브러리 자체는 .c로 해서 name mangling을 막아야 한다. // 2. 헤더는 위처럼 조건부 컴파일을 통해서 라이브러리 사용자가 // c/c++ 모두에서 사용할 수 있게 한다.

cpp에서는 ifdef __cplusplus내의 모든 함수에 extern "C"가 붙고 c의 경우 제거된다.

결론은, header파일에 __cplusplus 라는 매크로를 쓰고, c나 cpp에서 부르면 된다. 

우리가 자주 쓰는 stdio.h에서도 이와 같은 매크로가 있어서 우리가 c 이던  c++ 이던, 상관하지 않고 쓸 수 있다.

추가적으로 overloading 된 함수를 찾는 순서는 다음과 같다.

1. Exactly matching.                        인자와 정확히 들어 맞는 type이 있는 함수를 먼저 찾는다.

2. Promotion.                                  인자가 변환될 때 data의 손실이 없는 타입을 가진 함수가 있는지 찾는다.

3. Standard Conversion                   암시적인 변환이 가능한 타입을 가진 함수를 찾는다.

4. user defined conversion operator  사용자가 만든 변환 연산자가 있으면 변환 후, 함수를 호출한다.

5. '...'                                           가변인자를 갖는 함수는 type에 무관하므로 이를 호출한다.

3. 인라인함수

//#include <iostream> //using namespace std; //주제 2. C와 다른 C++ 함수 특징 - 인라인 함수 21 ~ 22 page // 1. 함수 호출의 원리 : 마지막 인자부터 스택에 넣고 함수로 jmp // 2. 인라인 함수 : 진짜 호출이 아니라 기계어 코드를 통째로 치환하는 것. // 3. 장점 : 빠르다. // 단점 : 목적 코드의 크기가 커진다 ==>> 함수 크기가 작다면 오히려 // 목적 코드의 크기는 줄어든다. // 4. 인라인 치환을 위한 컴파일러 옵션이 필요. VC는 ==> cl a.cpp /Ob1 // 5. 인라인과 함수 포인터 이야기 int Add( int a, int b ) { return a + b; } inline int Add2( int a, int b ) { return a + b; } int main() { int n = Add( 1, 2 ); // push 2 // push 1 // call Add => 물론 C++이라면 mangling됩니다. int n2 = Add2( 1, 2 ); // 이 순간 이 위치에 Add2의 기계어 코드로 치환. }

위의 코드를 console에서 컴파일 할 경우, 그냥 하면 inline이 컴파일러에 의해 무시된다.  제대로 할려면 다음과 같이 해보자.

cl.exe fileName.cpp /Ob1 /FAs  // 인라인을 쓰겠다고 컴파일러에게 알려준다. 그럼 이렇게 생성된 asm파일을 보면,

; Listing generated by Microsoft (R) Optimizing Compiler Version 16.00.30319.01 TITLE D:\Andy\20120423\0423\인라인함수.cpp .686P .XMM include listing.inc .model flat INCLUDELIB LIBCMT INCLUDELIB OLDNAMES PUBLIC ?Add@@YAHHH@Z ; Add ; Function compile flags: /Odtp ; File d:\andy\20120423\0423\인라인함수.cpp _TEXT SEGMENT _a$ = 8 ; size = 4 _b$ = 12 ; size = 4 ?Add@@YAHHH@Z PROC ; Add ; 11 : { push ebp mov ebp, esp ; 12 : return a + b; mov eax, DWORD PTR _a$[ebp] add eax, DWORD PTR _b$[ebp] ; 13 : } pop ebp ret 0 ?Add@@YAHHH@Z ENDP ; Add _TEXT ENDS PUBLIC _main ; Function compile flags: /Odtp _TEXT SEGMENT _n2$ = -8 ; size = 4 _n$ = -4 ; size = 4 _main PROC ; 21 : { push ebp mov ebp, esp sub esp, 8 ; 22 : int n = Add( 1, 2 ); // push 2 push 2 push 1 call ?Add@@YAHHH@Z ; Add add esp, 8 mov DWORD PTR _n$[ebp], eax ; 23 : // push 1 ; 24 : // call Add => 물론 C++이라면 mangling됩니다. ; 25 : int n2 = Add2( 1, 2 ); // 이 순간 이 위치에 Add2의 기계어 코드로 치환. mov eax, 1 add eax, 2 mov DWORD PTR _n2$[ebp], eax ; 26 : } xor eax, eax mov esp, ebp pop ebp ret 0 _main ENDP _TEXT ENDS END

우리가 일반적으로 inline을 쓸 경우, 속도가 빨라지나 obj 파일이 커질거라고 생각하나, 간단한 inline함수의 경우 오히려 크기가 작아진다.(asm파일을 참조하라)

console이 아닌 Visual C++ IDE에서 컴파일 시, debug옵션이면 inline을 거부하나, release일 경우 inline옵션으로 컴파일 되어 진다.

inline함수를 쓸 때 주의해야 할 점이 있다. 다음을 보자.

//b.h의 내용 void foo(); // 일반적으로 헤더에는 함수의 선언을 하게 되지만, // 인라인 함수의 경우에는 헤더에 구현부를 작성하게 된다. //void goo(); inline void goo() {} //b.cpp 의 내용 void foo() {} //inline void goo() {} //인라인함수2.cpp의 내용 #include "b.h" //주제 2-2. 인라인 함수와 linkage... int main() { foo(); goo(); }

보통 헤더파일에 선언을 하고, 소스파일에서 구현을 하기 때문에, 인라인함수도 그런 식으로 한다면? 빌드 에러난다.  왜냐면, 인라인 함수에 대한 치환은 컴파일러가 담당하므로, 컴파일시, 인라인 함수에 대한 정의가 완전하게 나와야 한다.  즉 인라인 함수에 대한 정의가 치환 시점 전에 있거나, include되는 헤더파일 안에 있어야 한다.  다시 말하면, inline함수는 internel linkage를 갖는다.

참고로,

internal linkage : 임의의 심볼이 선언된 컴파일 단위(파일)에서만 사용가능.  internal linkage는 주로 헤더에 만든다.

예) static 전역변수, 인라인 함수, 매크로 상수/함수, 함수/클래스 템플릿, 구조체

external linkage : 임의의 심볼의 프로젝트내의 모든 컴파일 단위에서 사용가능

예) 전역변수, 일반함수

예제)

template<typename T> T square(T a){return a * a;}    internal linkage

int a;                                                                     다른 파일에서 extern int a;라고 선언 후 접근 가능

static int b;                                                             다른 파일에서 접근 불가.

const int c = 0;                                                       .c에서는 external

                                                                            .cpp에서는 internal

#define    MAX 10                                                   internal linkage

struct People {};

4. 함수 템플릿

c의 경우 필요시 코드 생성 기술을 다음과 같이 활용한다.

// 동일한 코드가 반복된다면 코드 생성 기술을 활용하자. // c: 매크로 기술, 단점 : 전처리기가 처리 - 안정성이 떨어진다. // 컴파일러는 컴파일시 Max(1,2)에서 int가 필요한 사실을 알지만 // 전처리기는 모른다. #define MAKE_MAX( T ) T Max(T a, T b) {return a < b ? b : a; } MAKE_MAX(int) MAKE_MAX(double)

C++에서는 함수 tempalte을 써서 컴파일러가 처리할 수 있다.

// C++ 언어 : 함수 template - 컴파일러가 처리 template<typename T> T Max( T a, T b ) { return a < b ? b : a; } //필요한 만큼 생성함 Max(1 , 2); Max(1.2, 3.2);

반면에 template은 잘못 사용하면, 다음과 같은 결과가 생긴다.

// template 은 잘못 사용하면 목적코드가 아주 커지게 됩니다. // "Code Bloat"라고 합니다. short s1 = 1, s2 = 2; Max( s1, s2 ); // 1. Max(short, short)생성 <- 답 // 2. Max(int, int)로도 충분하니까 Max(int)사용

한편 다음과 같은 경우는 어떨까?

cout << Max( 'A', 65) << endl; // 1. T가 int // 2. T가 char // 3. 에러 cout << Max<int>('A', 65) << endl; // ok T가 int가 된다. 

T가 결정되어서 함수 템플릿이 진짜 함수가 되는 과정: "인스턴스화"라고 하고 "명시적 인스턴스화" 와 "암시적 인스턴스화"가 있다.

이렇게 위와 같이 <int>로 프로그래머가 정한 것을 명시적 인스턴스화 라고 한다.

암시적 인스턴스는 컴파일시 컴파일러에 의해 결정되는 것을 말한다.

5. 캐스팅

한마디로 C에서의 캐스팅은 위험하다.  물불 안 가리고 캐스팅을 하기 때문이다.  자세한 내용은 밑의 소스 코드를 참조하자.

#include <iostream> using namespace std; // 주제 4. C++ explicit casting - 안드로이드 소스에 아주 많이 나옵니다. // 1. C의 캐스팅은 비 이성적(unresonable)이다. 아주 위험하다. // 2. 그래서 C++에서는 4개의 캐스팅 연산자를 만들었다. // (A) static_cast : // (B) reinterpret_cast : // (C) const_cast : // (D) dynamic_cast : RTTI, 상속 때 설명 int main() { const int c = 0; int n2 = 10; const int* p2 = &n2; //int* p3 = p2; //error ... int* = const int*이므로. int* p3 = const_cast<int*>(p2); //이럴 때 const_cast를 사용한다. int* p = &c; //될까? 암시적으로 에러! // 하지만 명시적 캐스팅은 된다. 혼란스러워 진다. int* p = (int*)&c; int* p = static_cast<int*>*&c); //error int* p = reinterpret_cast<int*>(&c) // erorr. 거의 되지만 상수를 제거할 수 없다.. int* p = const_cast<int*>(&c); //ok 객체의 상수서을 제거할 때 사용 // 단 int*에 담을 수 있었지만 값을 변경하는 코드는 사용하지 말아야 한다. // 사용시 undefined 현상 발생 *p = 20; cout << c << endl; // 0 } /* int main() { double d = 3.4; int n = d; //암시적 변화 허용, 단 warning은 나올 수 있다. int n = static_cast<int>(d); //ok //double* p = &n; //암시적 변화이 허용되지 않는다. 포인터끼리의 암시적 변환은 불가능 //double* p = (double*)&n; //명시적 변환을 사용하면 된다. // 코드에서는 우선 static_cast로 쓰고, 문제가 생길 시, 확인 후 // 정말 필요한 코드일때만 reinterpret_cat 사용 double* p = static_cast<double*>(&n); // error. 위험하다. double* p = reinterpret_cast<double*>(&n); // ok. 대부분 성공 *p = 2.1; //잘못된 메모리를 침범하게 된다. } */

//---------------------------------------------

출처: http://ikpil.com/262

static_cast 는 C 스타일 캐스트와 똑같은 의미와 형변환 능력을 가지고 있는, 기본적인 캐스트 연산자입니다. C 스타일의 그것과 구실이 똑같다 보니 받는 제약도 똑같습니다. 예를 들어,struct 를 int 타입으로 바꾼다든지 double을 포인터 타입으로 바꾸는 일은 이것으로 할 수 없습니다. 게다가, static_cast 는 표현식이 원래 가지고 있는 상수성(constness)을 떼어버리지도 못합니다. 이런 일을 하는 캐스트 연산자인 const_cast 가 따로 있는 것을 보면 짐작할 수있지요.
나머지 세 가지의 C++ 캐스트 연산자는 좀 더 구체적인 목적을 위해 만들어졌습니다. const_cast는 표현식의 상수성이나 휘발성(volatileness)을 없애는 데에 사용합니다. 이 연산자가 쓰여진 소스를 만나면, 아, 이 개발자는 const 나 volatile로 선언한 변수라든지 이런 타입의 값을 내는 표현식에서 이런 특성만 바꾸고 싶어하는구나 라고 생각하면 되겠습니다. 이러한 프로그래머의 의도는 컴파일러에 의해서 더욱 확실해집니다. 즉, 상수성이나 휘발성을 제거하는 것 이외의용도로 const_cast 를 쓰면 통하지 않습니다.

구체적인 용도를 가진 C++ 캐스트 연산자 두 번째는 dynamic_cast 입니다. 이 연산자는 상속
계층 관계를 가로지르거나 하향시킨 클래스 타입으로 안전하게 캐스팅할 때 사용합니다. 말하자
면, dynamic_cast 는 기본 클래스의 객체에 대한 포인터나 참조자의 타입을 파생(derived) 클래
스, 혹은 형제(sibling) 클래스의 타입으로 변환해 준다는 것입니다3). 캐스팅의 실패는 널 포인터
(포인터를 캐스팅할 때)나 예외(참조자를 캐스팅할 때)를 보고 판별할 수 있습니다

네 가지 C++ 캐스트 연산자의 마지막은 reinterpret_cast 입니다. 이 연산자가 적용된 후의변환 결과는 거의 항상 컴파일러에 따라 다르게 정의되어 있습니다. 따라서, 이 연산자가 쓰인소스는 직접 이식이 불가능합니다.
reinterpret_cast 의 가장 흔한 용도는 함수 포인터 타입을 서로 바꾸는 것입니다. 예를 들어, 어떤 특정한 타입의 함수 포인터를 배열로 만들어 놓았다고 가정합시다.
typedef void (*FuncPt r) ( ) ; // FuncPtr 은 인자를 받지 않고
/ / void를 반환하는 함수에 대한
/ / 포인터입니다.

FuncPtr funcPtrArray[10]; // funcPtrArray는 10개의 FuncPtr로 만들어진 배열입니다.
이때 다음의 함수에 대한 포인터를 funcPtrArray에 넣어야 할 피치 못할 사정이 생겼습니다.
int doSomething();
간단할 것 같지만 캐스팅을 하지 않으면 절대로 안 됩니다. 왜냐하면 doSomething은 funcPtrArray에 넣기에는 타입이 맞지 않기 때문입니다. 이 배열에 들어가는 함수는 void를 반환하지만, doSomething은 i nt 를 반환하지 않습니까?
funcPtrArray[ 0 ] = &doSomething ; / / 에러입니다! 타입불일치이군요.
reinterpret_cast 를 쓰면 컴파일러에게 이 일을 강제로 시킬 수 있습니다.
funcPtrArray[ 0 ] = / / 이것은 컴파일됩니다.
reinterpret_cast <FuncPtr> (&doSomething) ;

//----------------------------------------------

6. 레퍼런스

변수 선언을 했다고 치자.

그럼 메모리가 할당되고, 이를 만약 포인터 변수를 써서 assign했다 치자. 그럼 역시 변수를 가리키는 주소를 가지는 포인터가 메모리에 생긴다.  이와는 달리 레퍼런스의 경우, 별다른 메모리를 차지않고 기존 메모리에 대한 별명이라고 보면 된다.

#include <iostream> using namespace std; // 주제 5. 레퍼런스 변수 이야기, 교재 11 ~ 13 page // 1. 개념 : 기존 메모리에 별명(또 다른 이름) 을 부여 하는 것. // 2. int main() { int n = 10; //변수 선언=> 메모리 할당의 의미. //(크기, 저장 타입이 필요 => data type) int* p = &n; int& r = n; //기존 메모리에 대한 별명 r = 20; cout << n << endl; //20 //------------------------- //int& r2; // error 초기값이 있어야 한다. int*& rp = p; // 포인터 변수의 별명 int&* pr = &r; // 별명의 주소... error.(별명은 메모리에 주소를 차지하지 않기 때문) int(*f)(void) = main; int(&r)(void) = main; // 함수도 별명을 만들 수 있다. }

다음을 보자.

답은 다음과 같다.

foo()를 호출 했을 때, p를 리턴하는데, 이는 임시객체를 리턴한다.  그러므로, 위에 정의된 구조체에 영향을 미치지 않는다.

당연히 p.x를 출력하면, 1이 출력된다. 

한편 임시객체를 리턴할 경우, 생성자/소멸자 등이 불리우고 메모리가 잡히기 때문에 성능에 큰 영향을 미친다. 

그럼 어떻게 해야 할까?  다음과 같이 레퍼런스를 사용하면 된다.

#include <iostream> using namespace std; // 주제 5-1. 참조와 함수 리턴값 - 아주 중요합니다. struct Point { int x; int y; }; Point p = {1,2}; //Point foo() //임의의 함수가 객체를 값으로 리턴하면 임시객체가 생성된다. Point& foo() //임시 객체를 만들지 않게 한다. { return p; } int main() { foo().x = 10; // OK cout << p.x << endl; // 10 }

정리하자면,

임의의 함수가 값을 리턴하면,
     1. built in type인 경우, (ex: int foo() )       : 상수로 리턴된다.
     2. user defined type인 경우, (ex: Point foo() ) : 임시객체가 리턴된다.

어떤 함수의 리턴값이 참조라면
     1. built in type  (int& foo) : 함수 호출을 lvalue에 놓게다는 의미
         foo() = 10;
     2. user type ( Point& foo() ) : 임시객체를 제거하겠다는 의미!

참조 변수와 함수 인자

여기서 정리하고 가는 단계로 다음의 코드를 보자.

#include <iostream> using namespace std; // 주제 5-3. 참조 변수와 함수 인자 - 12 page void inc1( int a ) { ++a; } void inc2( int* p ) { ++(*p); } void inc3( int& r ) { ++r; } int main() { int x = 1, y = 1, z = 1; inc1(x); // call by value inc2(&y); // ok call by pointer inc3(z); // call by reference cout << x << endl; cout << y << endl; cout << z << endl; } 

주의할 점은 inc3(z)로 z를 패스하는데, &z를 패스하지 않도록 주의한다.

이렇게 보면 레퍼런스로 받는게 코드 복잡성에서도 나아보이고, 메모리 구조면에서도 좋아보이나, 코드 가독성 측면에서 포인터가 더 좋다.( inc3(z)를 본다면, z가 변할지 안 변할지 알아보기 힘들다. 그러나 inc2(&y)를 보면 딱 봐도 y가 변할 거라는게 보이지 않는가?)

그러나 레퍼런스 인자를 쓸 일이 있는데 다음을 보자.

struct Data { int buf[10000]; }; //void foo( Data a ) // call by value : 절대 인자값을 변경하지 않을 것이라는 약속 void foo( const Data& a ) // 하지만 메모리 사용량이 2배로 증가 // const T& 를 사용하자. - 12 page 아래쪽 { } int main() { Data x = 10; //int x = 10; foo( x ); // foo는 절대로 x값을 변경하면 안된다. cout << x << endl; // 반드시 10이 나와야 한다. }

한가지 재밌는 것은, 다음의 경우다.

위에서 막 레퍼런스를 얘기했으니 2번 같겠지만, 1번이다.  int같은 경우 overhead가 크게 일어날 경우도 없고, const T&를 쓸 경우, 컴파일러가 최적화를 할 수 가 없다.

혼돈스러우니, 정리하자면,

함수가 값을 변경하지 않는다면 const T&를 사용하자.
  (A) built in type의 경우 : call by value 가 좋다.

         foo( int a )
  (B) user type 의 경우    : const T& 를 사용하자.
         foo( const Data& a )

7. Namespace

다음과 같이 코드를 짜다보면 같은 이름을 쓰고 싶은데 중복될까봐 이런 식으로 쓰게 되는 경우가 있는데,

#include <iostream> using namespace std; // 주제 6. namespace 이야기 .. -9 page void GraphicInit() { } void AudioInit() { } int main() { }

이걸 매번 확일 할 수도 없고, 그래서 사용할 수 있는게 namespace이다.

#include <iostream> using namespace std; // 주제 6. namespace 이야기 .. -9 page namespace Graphic { void Init() { } } namespace Audio { void Init() { } } int main() { Graphic::Init(); // 1. 완전한 이름을 사용한 호출 using Graphic::Init; // 2. using 선언 (declaration) Init(); // Graphic::Init()호출 using namespace Graphic; // 3. using 지시어 (directive) // Graphic안의 모든 요소를 namespace 이름없이 사용가능. }

이렇게 같은 함수 이름을 중복해서 써도, namespace만 정의 잘하면 문제 없이 쓸 수 있다.

참고로, #include <iostream.h> 에는 cout, endl이 전역공간에 있다. 그러나 <iostream>의 경우,

namespace std

{

   // cout, endl이 여기 있음.

}

와 같이 되어 있다.

한가지 더 알면 좋은 거 추가...

namespace Graphic { struct Point { }; void Init( const Point& p ) { } } int main() { Graphic::Point p; // 1 Init(p); // 2 //퀴니그 룩업(인자기반탐색) : 함수를 찾을 때 인자가 포함된 // namespace를 자동으로 검색 }

8. OOP 개념

다음의 코드를 보자.

#include <iostream> using namespace std; // 주제 7. OOP개념 - 29 ~ 30 page // 복소수 2개의 합을 구하고 싶다. void Add( int ar, int ai, int br, int bi, //IN parameter int* sr, int* si ) //OUT parameter { *sr = ar + br; *si = ai + bi; } int main() { int xr = 1, xi = 1, yr = 2, yi = 2; int sr, si; Add( xr, xi, yr, yi, &sr, &si ); }

복소수를 리턴하기 위해 복잡하게 리턴을 하는 것보다, 구조체를 만들어 보자.

다음은 OOP개념을 익히기 위해 기본적인 C의 방법부터 코드를 수정하는 과정이다.

#include <iostream> #include <stack> // 우리가 아래 만든 스택과 비슷한 것이 이미 C++표준에 제공됨 using namespace std; int main() { stack<int> s1; s1.push(10); s1.push(20); // 20 , 10 모두 꺼내서 출력 cout << s1.top() << endl; s1.pop(); } // STL : C++ 표준라이브러리 로서, list, vector, stack등이 있습니다. // 안드로이드 : STL를 사용해도 되고, 자체적으로 vecotr와 list를 제공합니다. // 원리는 2개 모두 비슷하게 설계되어 있습니다. /* #include <iostream> using namespace std; // 스택을 만들어 보자. // 버전 8. 최적화... template<typename T> struct Stack { private: T* buff; int index; public: Stack( int sz = 10 ) { index = -1; buff = new T[sz]; } ~Stack() {delete[] buff;} void push( const T& n ) { buff[++index] = n; } // ! // pop이 제거와 리턴을 동시에 하면 최적화 할 수 없다. //T pop() { return buff[--index]; } //제거하는 함수와 리턴하는 함수를 분리하자 //리턴 전용 T& top() { return buff[index]; } //제거 전용 void pop() { --index; } }; int main() { Stack<int> s1(100), s2; // 클래스 템플릿의 객체를 생성하는 방법. s1.push(10); s1.push(20); cout << s1.top() << endl; s1.pop(); } */ /* // 버전 7. 다양한 타입을 저장할 수 있도록 하자. = template 도입 template<typename T> struct Stack { private: T* buff; int index; public: Stack( int sz = 10 ) { index = 0; buff = new T[sz]; } ~Stack() {delete[] buff;} void push( T n ) { buff[index++] = n; } T pop() { return buff[--index]; } }; int main() { Stack<int> s1(100), s2; // 클래스 템플릿의 객체를 생성하는 방법. s1.push(10); cout << s1.pop() << endl; } */ /* // 버전 6. 내부 자료구조의 변경 - 스택의 크기를 사용자가 변경할 수 있게 하자. struct Stack { private: int* buff; int index; public: Stack( int sz = 10 ) { index = 0; buff = new int[sz]; } ~Stack() {delete[] buff;} void push( int n ) { buff[index++] = n; } int pop() { return buff[--index]; } }; int main() { Stack s1(100), s2; s1.push(10); cout << s1.pop() << endl; } */ /* // 버전 5. 객체 초기화를 자동으로 - 생성자 도입 struct Stack { private: int buff[10]; int index; public: // 생성자 : 객체를 생성하면 자동으로 호출되는 함수 ! 구조체(클래스)이름과 동일한 함수. Stack() { index = 0; } void push( int n ) { buff[index++] = n; } int pop() { return buff[--index]; } }; int main() { Stack s1, s2; s1.push(10); cout << s1.pop() << endl; } */ /* // 버전 4. 외부에서는 내부 data를 알 필요 없다. // 외부의 잘못된 사용으로 객체가 불안해 지는 것을 막자. struct Stack { private: int buff[10]; int index; public: void init() { index = 0; } // 멤버 함수. 멤버 data를 바로 접근 가능 void push( int n ) { buff[index++] = n; } int pop() { return buff[--index]; } }; int main() { Stack s1, s2; s1.init(); s1.push(10); s1.index = 100; //실수했다! cout << s1.pop() << endl; } */ /* // 버전 3. 상태를 나타내는 data와 상태를 조작하는 함수를 묶어서 타입을 만들자. struct Stack { int buff[10]; int index; void init() { index = 0; } // 멤버 함수. 멤버 data를 바로 접근 가능 void push( int n ) { buff[index++] = n; } int pop() { return buff[--index]; } }; int main() { Stack s1, s2; s1.init(); s1.push(10); cout << s1.pop() << endl; } */ /* // 버전 2. stack이라는 타입을 먼저 설계하자. - 구조체 토입 struct Stack { int buff[10]; int index; }; void init( Stack* s ) { s->index = 0; } void push( Stack* s, int n ) { s->buff[s->index++] = n; } int pop( Stack* s ) { return s->buff[--s->index]; } int main() { Stack s1, s2; init(&s1); push(&s1, 10); cout << pop(&s1) << endl; } */ /* // 버전 1. C 언어의 경우 - 문제점 stack이 2개 필요하다면? int buff[10]; int index = 0; void push( int a ) { buff[index++] = a;} int pop() { return buff[index]; } // --가 앞? 뒤? int main() { push(5); push(4); cout << pop() << endl; } */

9. 생성자 정리