code cat

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. 생성자 정리

우선 이게 되는지는 나도 정확히 모르겠으나, 될 거 같다. 안될 이유가 있는가??

그냥 대놓고 startx하면 Xauthority 가 없다 이런 에러가 날 것이다.

우선 기본적으로 ssh -X 계정이름@호스트이름으로 접속해 보자.

접속되고 나면 Xwrapper.config를 바꿔야 하는데, /etc/X11/Xwrapper.config는 다음과 같이 3가지 값을 가질 수 있다.
    root
    anybody
    console
allowed_users=anybody로 값을 바꾸자.

그 후 만약 startx 하고 돌렸는데,

    "Server is already active for display 0"

하고 나오면 당연히 서버가 display 0을 쓰고 있을 것이다.

그래서 startx -- :1로 display 1으로 실행시킨다. 나중에 돌리다 보면 필요하겠지만, display 1로 실행시킨 녀석을 죽일라면

    rm -rf /tmp/.X1-lock

을 사용하자.

그런데 이제는 "Failed to load module "fglrx" 가 나온다.

(==) Log file: "/var/log/Xorg.1.log", Time: Mon Apr 16 20:22:59 2012
(==) Using system config directory "/usr/share/X11/xorg.conf.d"
(EE) Failed to load module "fglrx" (module does not exist, 0)

그럼 다음과 같이 해보자.

    sudo dpkg-reconfigure -phigh xserver-xorg

그리고 다시 start -- :1을 실행. 여기서 display 1이 안될 수도 있으니, 위에 말한 rm -rf /tmp/.X1-lock을 사용하고 다시 해보자.

이번엔 이렇게 나온다.
_XSERVTransSocketINETCreateListener: ...SocketCreateListener() failed
_XSERVTransMakeAllCOTSServerListeners: server already running


Fatal server error:
Cannot establish any listening sockets - Make sure an X server isn't already running

이 경우, 위에서 lockfile을 날려서거나, lock file을 만들지 않는 어떤 넘이 벌써 포트로 listening 중이기 때문이다.
이럴 땐 이렇게 해보자.

netstat -ln

여기서 무슨 값을 봐야 하나면, x서버는 6000대의 포트 + display 값로 listening을 한다. 그러니 6001을 보자.

      netstat -ln | grep "6001"

여기서 막혔는데 좀 더 봐야겠다.