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

이 글의 모든 소스는 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 }

 

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

class Point { int x, y; public: Point( int a, int b ) : y(0), x(y) {} // x는 제대로 초기화 되지 않는다. }; int main() { Point p(0, 0); cout << p.x << endl; cout << p.y << endl; }

 

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

//생성자를 클래스 내부가 아닌 외부에 구현했을 때의 초기화 리스트 모양을 알아두세요. 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
 소멸자

 

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

Point& foo() { Point p2(1, 2); cout << "foo" << endl; return p2; // 임시객체를 리턴 }

 

대신 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를 이용한 것을 볼 수 있다.

#include <iostream> using namespace std; // this 이야기 - 63 page // 1. this : 멤버 함수를 호출할때 사용한 객체의 주소. // 2. 멤버임을 명확히 할 때 사용 // 3. this를 리턴하는 함수 : 멤버 함수를 연속적으로 호출 할 수 있다. // *this를 리턴할 때는 임시객체를 막아야 한다. => 참조 리턴 class Point { int x; int y; public: void Set( int x, int y ) { this->x = x; this->y = y; } void foo() { cout << this << endl; } Point* goo() { return this; } Point& hoo() { return *this; } }; int main() { Point p1, p2; p1.foo(); cout << &p1 << endl; p1.goo()->goo()->goo(); p1.hoo().hoo().hoo(); // cout << "A" << "B" << "C" }

 

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 main() { int n = 3; n++++; // error Int32 n2 = 3; n2++++; // error 나와야 한다. (n2.operator++(int)).operator++(int) }

 

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

// 후위형 ++ => 사용되지 않지만 전위형과 구별하기 위해 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; // 요소를 저장하는 것 => collection 또는 컨테이너라고 합니다. // list, 배열, vector, stack 등이 있습니다. // 이런 클래스에는 반복자라는 개념이 있습니다. // step 1. Generic 알고리즘 만들기 // 버전 3. 검색 대상 타입의 일반화 - template 도입 // 검색구간 : [first, last) 사이의 부분 임의타입의 배열, NULL로 끝날 필요 없다 // last는 검색에 포함 안됨 // 구간의 표현 : 일반 포인터, 스마트포인터도 가능(단, ++, !=, * 연산이 가능해야 한다.) // 구간의 이동 : 전위형 ++ // 실패의 전달 : last 리턴 // 아래 함수의 문제점 // 1. 검색 구간의 타입과 검색 요소의 타입이 연관된다. - double 배열에서 int를 찾을 수 없다. // 2. T* 라고 표현하면 진짜 포인텀나 사용가능하다. 스마트 포인터를 사용할 수 없다. //template<typename T> T* xstrchr( T* first, T* last, T c) template<typename T1, typename T2> T1 xfind( T1 first, T1 last, T2 c) // 수정된 코드 { while( first != last && *first != c) ++first; return first// != last ? first : 0; } int main() { double x[10] = {1,2,3,4,5,6,7,8,9,10}; double* p = xfind(x, x+10, 5.0); cout << *p << endl; } /* // 버전 2. 검색 구간의 일반화 - 부분 문자열 검색이 가능하게 // 검색구간 : [first, last) 사이의 부분 문자열, NULL로 끝날 필요 없다 // last는 검색에 포함 안됨 // 구간의 표현 : 일반 포인터 // 구간의 이동 : 전위형 ++ // 실패의 전달 : null pointer(0) 리턴 char* xstrchr(char* first, char* last, char c) { while( first != last && *first != c) ++first; return first != last ? first : 0; } int main() { char* s = "abcdefg"; char* p = xstrchr( s, s+5, 'c'); cout << *p << endl; } */ /* // 검색구간 : NULL로 끝나는 문자열, NULL은 검색에 포함안됨.. // 구간의 표현 : 일반 포인터 // 구간의 이동 : 전위형 ++ // 실패의 전달 : null pointer(0) 리턴 char* xstrchr(char* s, char c) { while( *s != 0 && *s != c) ++s; return *s == c ? s : 0; } int main() { char* s = "abcdefg"; char* p = xstrchr( s, 'c'); cout << *p << 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 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; } }