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

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의 사용자정의 함수도 추가했다. 

 

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

#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*) }

위와 같이 우리가 만든 함수들도 기존 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)은 다음의 두 종류가 있다.

static binding(early binding)	컴파일러가 컴파일시간에 결정. 원리는 포인터 타입으로 호출  c++, c#
dynamic binding(late binding)	컴파일러가 컴파일시 메모리 조사하는 코드를 생성.  실행시 메모리에 어떤 객체가 있는지 조사해서 호출  java, objective-c, c++(virtual), c#(virtual)

 

관련된 코드는 아래를 참조하자.
#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내에 이 디자인 패턴을 사용했다.