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"

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

아키텍쳐 별로 tag를 만들어서 분석 시 좀 더 편하게 분석 하는 방법이 있는데, (뭐 물론 아키텍쳐별로 파일 다 지우고 하겠다면 안 말린다)

1. tag 생서시에는

make tags ARCH=<architecture name>

2. cscope 생성시에는

make cscope ARCH=<architecture name>

물론 <architecture name>은 그냥 아키텍쳐 이름만 써주면 된다. 예를 들어 arm을 분석한다면,

make cscope ARCH=arm

이렇게 해 주면 된다.

1. Apache 2.0 라이센스를 다운 받는다. (링크)

2. NOTICE 에서 [] 안의 부분을 고친다.

3. 오리지널 copyright은 건들지 말고 냅두고, 코드에서 수정 부분이 있다면, 수정했다고 언급한다.(예 modified by CodeCat) 

4. 위의 NOTICE 를 아파치 라이센스가 적용되는 모든 파일에 커맨트형태로 넣는다.  

5. LICENSE 파일(1에서 다운받은) 과 NOTICE 파일(2에서 바꾼)을 프로젝트의 맨 위(root 폴더)에 넣는다.

다음의 글은 아래의 출처에서 가져왔음을 밝힌다.

출처:http://www.ibm.com/developerworks/kr/library/l-anatomy-ext4/

Linux 커널이 새롭게 발표될 때마다 몇 가지 뛰어난 기능이 포함되어 있듯이 이번 12월에 발표된 2.6.28 릴리스에도 우수한 기능이 포함되어 있다. 이 릴리스는 현재 개발 작업이 한창 진행 중인 Btrfs와 같은 여러 가지 우수한 기능 중에서 안정적인 ext4 파일 시스템이 최초로 적용된 릴리스이다. 이 차세대 Extended File System에서는 확장성과 신뢰성이 향상되었으며 뛰어난 새 기능도 추가되었다. Ext4는 1TB 디스크를 최대 백만 개까지 사용할 수 있는 파일 시스템으로 확장할 수 있다.

Extended File System의 약사

Linux를 지원하는 최초의 파일 시스템은 Minix 파일 시스템이었지만 이 파일 시스템에는 몇 가지 심각한 성능 문제가 있었기 때문에 Extended File System이라는 파일 시스템이 Linux를 위해 특별히 개발되었다. Remy Card가 설계한 첫 번째 Extended File System(ext)은 1992년 4월에 Linux에 채택되었다. ext 파일 시스템은 0.96c 커널에 구현된 VFS(Virtual File System) 스위치를 최초로 사용했으며 최대 2GB 크기의 파일 시스템을 지원했다.

두 번째 Extended File System(ext2) 또한 Remy Card가 구현했으며 1993년 1월에 발표되었다. 이 파일 시스템은 Berkeley FFS(Fast File System)와 같은 당시의 다른 파일 시스템의 발전된 아이디어를 채택했다. Ext2에서는 지원되는 파일 시스템의 크기가 2TB로 확장되었으며 2.6 커널에서는 ext2 파일 시스템의 최대 크기가 32TB로 확장되었다.

세 번째 Extended File System(ext3)은 일부 경쟁 파일 시스템에 비해 성능이 떨어지기는 했지만 Linux 파일 시스템의 맥락에서는 크게 발전한 모습을 보여 준 파일 시스템이다. ext3 파일 시스템에서는 예기치 않게 시스템이 중단되었을 때 파일 시스템의 신뢰성을 높여 주는 저널링 개념이 도입되었다. Silicon Graphics의 XFS 및 IBM® JFS(Journaled File System)와 같은 경쟁 파일 시스템의 성능이 더 좋기는 했지만 ext3은 이미 ext2를 사용하고 있는 시스템에서 직접 업그레이드할 수 있는 기능을 지원했다. Ext3은 2001년 11월에 발표되었으며 Stephen Tweedie가 구현했다.

현재, 네 번째 Extended File System(ext4)이 발표되었다. Ext4에는 성능, 확장성 및 신뢰성을 향상시킨 수많은 새 기능이 도입되었다. 가장 눈에 띄는 특징은 ext4가 1EB(exabyte)의 파일 시스템을 지원한다는 것이다. Ext4는 ext3를 유지 관리해 온 Theodore Tso가 이끄는 개발자 팀에 의해 구현되어 2.6.19 커널에 채택되었다. 그리고 지금은 2.6.28 커널에 이르러 안정적인 상태로 유지되고 있다(2008년 12월 현재).

Ext4에는 다양한 경쟁 파일 시스템의 유용한 개념이 적용되었다. 예를 들어, 익스텐트를 사용하여 블록을 관리하는 방법은 JFS에서 구현했으며 또 다른 블록 관련 기능인 지연된 할당은 XFS와 Sun Microsystems의 ZFS에서 구현했다.

새로운 ext4 파일 시스템에서는 혁신적으로 개선된 다양한 기능을 볼 수 있다. 새롭게 추가된 기능, 현재 파일 시스템의 한계를 뛰어 넘은 우수한 확장성, 오류에 효과적으로 대응할 수 있는 신뢰성 및 뛰어난 성능에 이르기까지 파일 시스템의 모든 부분에서 개선된 사항을 발견할 수 있다.

기능성

Ext4에는 새 기능이 매우 많이 포함되어 있기는 하지만 그 중에서도 가장 중요한 특징은 이전 버전인 ext3과의 쌍방 호환성이며 앞으로 더 높은 성능을 제공하게 될 미래의 Linux 시스템을 내다보고 시간 소인의 기능도 향상되었다.

이전 버전 및 후속 버전과의 호환성

ext3은 오늘날 Linux에서 가장 많이 사용되고 있는 파일 시스템 중 하나이기 때문에 ext4로의 마이그레이션은 큰 어려움 없이 쉽게 수행할 수 있어야 한다. 이를 위해 ext4는 쌍방 호환성을 고려하여 설계되었다(그림 1 참조). Ext4는 ext3 파일 시스템을 ext4 파일 시스템으로 마운트할 수 있도록 후속 버전으로의 호환성을 제공한다. ext4를 충분히 활용하려면 파일 시스템 마이그레이션을 수행하여 새로운 ext4 형식으로 변환한 후 사용해야 한다. ext4 파일 시스템을 ext3로도 마운트할 수 있기는(이전 버전과의 호환성) 하지만 ext4 파일 시스템에서 익스텐트(성능 섹션 참조)를 사용하지 않는 경우에만 가능하다.

그림 1. ext4의 쌍방 호환성

이러한 호환성 특징 외에도 ext3 파일 시스템을 ext4로 마이그레이션하는 작업을 점차적으로 수행할 수 있다. 즉, 옮기지 않은 기존 파일을 기존 ext3 형식으로 유지하면서 새 파일(또는 복사한 기존 파일)을 새로운 ext4 데이터 구조로 관리할 수 있다. 이러한 방법을 통해 온라인으로 ext3 파일 시스템을 ext4 파일 시스템으로 마이그레이션할 수 있다.

시간 소인 정밀도 및 범위 향상

놀랍게도 ext4 이전의 Extended File System에서는 초 단위의 시간 소인을 사용하고 있다. 이 시간 소인은 많은 설정에서 효과적으로 사용되었지만 프로세서의 처리 속도가 빨라지고 통합 기능(멀티 코어 프로세서)이 향상되었을 뿐만 아니라 고성능 컴퓨팅과 같은 다른 애플리케이션 도메인에서 Linux가 사용되면서 그 한계가 드러나고 있다. Ext4의 시간 소인은 기본적으로 나노초 LSB로 확장되어 후속 버전과의 호환성을 보장한다. 또한 두 개의 추가 비트를 통해 시간 범위도 500년 이후까지 사용할 수 있도록 확장되었다.

확장성

업그레이드할 파일 시스템의 가장 중요한 특성 중 하나는 증가하는 수요에 대응할 수 있는 확장성이다. 여러 가지 방법으로 확장성을 강화한 Ext4는 ext3 한계를 극복하고 파일 시스템 메타데이터 관리를 위한 토대를 새롭게 마련하였다.

파일 시스템 제한 확장

ext4의 첫 번째 가시적인 차이점은 파일 시스템 볼륨, 파일 크기 및 서브디렉토리 제한에 대한 지원이 향상되었다는 것이다. Ext4는 최대 1EB(1000PB)의 파일 시스템을 지원한다. 오늘날 적용되고 있는 표준에 따르면 많은 용량처럼 보이기는 하지만 스토리지 사용량이 지속적으로 늘어나고 있다는 점을 감안하면 ext4가 미래를 염두에 두고 개발되었음을 명확히 알 수 있다. ext4에서 허용되는 최대 파일 크기는 16TB(4KB 블록 가정)이며, 이는 ext3의 최대 파일 크기의 8배에 해당한다.

마지막으로 ext4에서는 서브디렉토리 제한도 32KB 디렉토리 깊이에서 거의 무한대로 확장되었다. 이러한 확장이 무리한 확장으로 보인다면 1EB의 스토리지를 사용하는 파일 시스템의 계층 구조를 생각해 봐야 한다. 디렉토리 인덱싱도 해시된 B 트리 형태의 구조로 최적화되었다. 따라서 제한이 크게 확장되었음에도 불구하고 ext4에서는 매우 빠른 조회가 가능하다.

익스텐트

ext3의 주요 단점 중 하나는 할당 방법에 있었다. 여유 공간에 대한 비트 맵을 통해 파일이 할당되었는데 이 방법은 빠르지도 않고 확장성도 좋지 않았다. Ext3의 형식은 작은 파일에 매우 효율적이지만 큰 파일에는 비효율적이다. Ext4에서는 할당 기능을 향상시키고 더욱 효율적인 스토리지 구조를 지원하기 위해 ext3의 메커니즘을 익스텐트로 대체했다. 익스텐트는 연속되는 블록 시퀀스를 나타낸다. 이처럼 익스텐트를 사용하게 되면 블록의 저장 위치에 대한 정보를 유지하는 대신 연속 블록으로 구성된 긴 목록의 저장 위치에 대한 정보가 유지되기 때문에 저장되는 전체 메타데이터의 용량이 줄어든다.

ext4의 익스텐트는 계층화된 접근 방법을 통해 작은 파일을 효율적으로 나타내며 익스텐트 트리를 사용하여 대용량 파일을 효율적으로 나타낸다. 예를 들어, 단일 ext4 inode에는 4개의 익스텐트를 참조할 수 있는 공간이 있으며, 이 경우 각 익스텐트는 연속 블록 세트를 나타낸다. 대용량 파일(조각화된 파일 포함)의 경우, inode는 인덱스 노드를 참조할 수 있으며, 각각의 인덱스 노드는 여러 익스텐트를 참조하는 리프 노드를 참조할 수 있다. 이 고정 깊이 익스텐트 트리는 대용량 스파스 파일에 대한 효과적인 표현 스키마를 제공한다. 또한 노드에는 파일 시스템 손상을 방지하기 위한 자동 검사 메커니즘이 있다.

성능

새 파일 시스템을 측정하는 데 사용되는 가장 중요한 속성 중 하나는 기본 성능이다. 성능은 가장 어려운 분야 중 하나이다. 왜냐하면 파일 시스템의 용량이 커지고 신뢰성에 대한 기대가 높아질수록 성능 저하가 발생할 수 있기 때문이다. 하지만 ext4는 확장성과 신뢰성을 제공하는 동시에 성능 향상을 위한 여러 가지 향상된 기능도 제공한다.

파일 레벨 사전 할당

데이터베이스 또는 컨텐츠 스트리밍과 같은 특정 애플리케이션에서는 드라이브에 대한 순차 블록 읽기 최적화를 사용하고 블록에 대한 읽기 명령 비율을 최대화하기 위해 연속 블록에 저장되는 파일을 사용한다. 연속 블록 세그먼트를 제공할 수 있는 익스텐트 외에도 과거에 XFS에서 구현되었던 대로 매우 큰 연속 블록 섹션을 원하는 크기로 사전 할당하는 매우 강력한 방법도 있다. Ext4에서는 지정된 크기의 파일을 사전 할당 및 초기화하는 새로운 시스템 호출을 통해 이 기술이 구현되었다. 그런 다음 필요한 데이터를 기록한 후 데이터에 대한 제한적인 읽기 성능을 제공할 수 있다.

블록 할당 지연

할당 지연은 파일 크기를 기반으로 하는 또 하나의 최적화 방법이다. 이 성능 최적화 방법은 블록을 디스크에 강제로 기록할 때까지 디스크의 물리적 블록을 할당하지 않고 기다린다. 이 최적화 방법의 핵심은 디스크에 기록할 필요가 있을 때까지 물리적 블록의 할당이 지연되기 때문에 더 많은 블록을 연속 블록에 할당 및 기록할 수 있다는 것이다. 이 방법은 파일 시스템에서 작업이 자동으로 수행된다는 점을 제외하면 지속적인 사전 할당과 유사하다. 하지만 파일 크기가 미리 알려져 있는 경우에는 지속적인 사전 할당이 가장 효과적인 방법이다.

멀티 블록 할당

최적화를 위해 향상된 마지막 기능은 ext4의 블록 할당자이다. 이 최적화 방법 또한 연속 블록과 관련되어 있다. ext3의 경우 블록 할당자는 한 번에 하나의 블록을 할당하는 방식으로 작동한다. 여러 개의 블록이 필요한 경우 연속 데이터를 연속되지 않은 블록에서 찾을 수 있었다. Ext4에서는 디스크에 연속되어 있을 수 있도록 여러 블록을 동시에 할당하는 블록 할당자를 사용하여 이 문제를 해결했다. 이전 최적화와 마찬가지로 이 최적화에서도 순차 읽기 최적화를 위해 디스크에서 최적화할 관련 데이터를 수집한다.

멀티 블록 할당의 또 다른 특징은 블록을 할당하는 데 필요한 처리 리소스의 용량에서 찾아볼 수 있다. 한 번에 하나의 블록만을 할당하는 가장 단순한 형태의 방법을 사용하는 ext3의 경우에는 블록 할당을 수행하기 위해 블록마다 한 번의 호출이 필요했다. 하지만 여러 블록을 동시에 할당하는 경우에는 블록 할당자에 대한 호출 횟수가 많이 줄어들기 때문에 할당 속도가 빨라지고 필요한 처리 리소스의 양도 줄어든다.

신뢰성

ext4에서는 파일 시스템이 매우 큰 크기로 확장될 수 있기 때문에 신뢰성에 대한 관심도 당연히 커질 것이다. Ext4에는 이러한 우려를 해소할 수 있는 여러 가지 자동 보호 및 자동 복구 메커니즘이 마련되어 있다.

파일 시스템 저널에 대한 체크섬 검사

ext3과 마찬가지로 ext4도 저널링 파일 시스템이다. 저널링은 저널(디스크의 연속된 영역에 있는 전용 순환 로그)을 통해 파일 시스템의 변경 사항을 기록하는 프로세스이다. 그런 다음 로그에 기록된 변경 사항에 따라 물리적 스토리지에 실제 변경 사항이 적용된다. 이 방법을 사용하면 좀 더 안정적으로 변경 사항을 구현할 수 있으며 작업 중에 시스템 오류 또는 전원 문제가 발생하더라도 일관성을 유지할 수 있다. 결과적으로 파일 시스템의 손상 가능성이 줄어드는 효과를 얻을 수 있다.

저널링을 사용하더라도 올바르지 않은 항목이 저널에 있다면 손상 가능성은 여전히 존재한다. 이 문제를 해결하기 위해 ext4에서는 저널에 대한 체크섬 기능을 구현하여 올바른 변경 사항만 기본 파일 시스템에 적용되도록 보장한다. 참고자료 섹션에서 ext4의 중요한 기능인 저널링에 대한 추가 참고자료를 볼 수 있다.

Ext4는 사용자의 필요에 따라 여러 가지 모드의 저널링을 지원한다. 예를 들어, ext4는 메타데이터만 저널링되는 모드(Writeback 모드), 메타데이터가 저널링된 후 저널을 바탕으로 메타데이터가 기록될 때 데이터가 기록되는 모드(Ordered 모드) 및 메타데이터와 데이터가 모두 저널링되는 모드(가장 안정적인 Journal 모드)를 지원한다. Journal 모드는 파일 시스템의 일관성을 보장하는 가장 좋은 방법이기는 하지만 모든 데이터가 저널을 통과하기 때문에 가장 느린 방법이기도 하다.

온라인 조각 모음

ext4에는 파일 시스템 내의 조각을 줄여 주는 기능(순차 블록 할당을 위한 익스텐트)이 통합되어 있기는 하지만 파일 시스템을 장기간 사용할 경우에는 어느 정도의 조각이 발생하는 것은 피할 수가 없다. 이 문제를 해결하여 성능을 향상시키기 위해 파일 시스템 및 개별 파일에 대한 조각 모음을 수행하는 온라인 조각 모음 도구가 제공된다. 온라인 조각 모음 도구는 인접한 익스텐트를 참조하는 새 ext4 inode에 파일을 복사하는 단순한 도구이다.

온라인 조각 모음의 또 다른 특징은 파일 시스템 검사(fsck)에 필요한 시간이 짧다는 것이다. Ext4에서는 inode 테이블에 있는 블록 그룹 중 사용되지 않고 있는 블록 그룹이 구별되기 때문에 fsck는 해당 블록 그룹 전체를 생략하여 빠르게 검사 프로세스를 수행할 수 있다. 파일 시스템의 크기가 증가하게 되면 필연적으로 내부 손상이 발생하기 마련이며 이러한 문제를 해결하기 위해 운영 체제는 파일 시스템에 대한 유효성 검증을 수행한다. 그리고 이러한 유효성 검증을 통해 ext4가 전반적으로 높은 신뢰성을 갖추고 있음을 알 수 있다.

미래의 모습

Extended File System은 분명 1992년에 처음 발표된 ext부터 2008년의 ext4에 이르기까지 Linux 내에서 길고도 의미 있는 역사를 가지고 있다. Linux를 위해 특별히 설계된 첫 번째 파일 시스템이면서 가장 효율적이고, 안정적이며 강력한 파일 시스템 중 하나였음을 입증해 보였다. XFS, JFS, Reiser 및 IRON 결함 허용 파일 시스템 기술 등의 다른 새 파일 시스템의 아이디어도 통합되어 있는 Ext4는 파일 시스템 관련 리서치에서 꾸준한 발전을 보여 주고 있다. 앞으로 개발될 ext5의 모습을 예측하기에는 너무 앞선 감이 있지만 엔터프라이즈 환경을 대비한 Linux 시스템을 이끌게 될 것이라는 점만은 분명하다.

참고자료

교육

• "Ubuntu 9.04 Receives EXT4 Support"에서는 최신 Ubuntu 릴리스에서 ext4를 통해 얻게 된 매우 인상적인 성능 향상 결과를 볼 수 있다(JFS, XFS, ReiserFS 및 Ext3과 비교).
  
  
• ext4 kernel wiki(시스템에서 ext4를 실행하는 데 필요한 정보 제공), Fedora ext4 페이지, Kernel Newbies ext4 페이지 및 Wikipedia에서 ext4에 대한 자세한 정보를 볼 수 있다. Wikipedia의 Extended file system 페이지에서도 4가지 Extended File System(1 - 4)에 대한 정보를 볼 수 있으며, 이 페이지에서는 파일 시스템 비교 및 두 번째 Extended File System의 역사에 대한 링크를 제공한다.
  
  
• IBM Linux Technology Center에서 제공하는 "Ext4: The Next Generation of Ext2/3 Filesystem"에서 ext4에 대한 좋은 프리젠테이션을 볼 수 있다.
  
  
• Tim의 "리눅스 파일 시스템 분석"(developerWorks, 2007년 10월) 및 "리눅스 저널링 파일 시스템 분석"(developerWorks, 2008년 6월)에서 Linux 파일 시스템 및 저널링 파일 시스템에 대한 자세한 정보를 볼 수 있다.
  
  
• Softpedia에 게재된 2.6.28과 Heise online에 실린 2.6.29에서 새 커널 릴리스인 2.6.28과 2.6.29에 대한 자세한 설명을 볼 수 있다. 새 커널 릴리스인 2.6.28과 2.6.29에는 획기적으로 향상된 여러 가지 주요 기능이 있다.
  
  
• Linux: ext4 Filesystem에서 ext4의 초기 역사를 볼 수 있다. 2006년에 게재된 이 kernel trap 기사에는 ext4 파일 시스템에 대한 Theodore Tso의 초기 제안이 들어 있다.
  
  
• University of Wisconsin-Madison의 학위 논문으로 작성한 Vijayan Prabhakaran의 IRON File Systems을 읽어보자. IRON(Internal RObustNess) 기술은 디스크 드라이브에 오류가 발생하는 흥미로운 상황을 가정하고서 디스크 드라이브를 관리하는 방법을 제안한다. 특히, IRON은 저널링 방법을 통한 오류 검색 및 복구 기술을 제안한다.
  
  
• developerWorks에서 Tim Jones의 추가 기사를 볼 수 있다.
  
  
• developerWorks Linux 영역에서는 Linux 입문자를 비롯한 Linux 개발자에게 도움이 되는 여러 가지 리소스를 제공하고 있으며 가장 인기 있는 기사와 튜토리얼도 볼 수 있다.
  
  
• developerWorks에 있는 Linux 팁과 Linux 튜토리얼을 모두 볼 수 있다.
  
  
• developerWorks 기술 행사 및 웹 캐스트를 통해 최신 정보를 얻을 수 있다.
  
  

제품 및 기술 얻기

• kernel.org에서 최신 커널 릴리스를 다운로드할 수 있다.
  
  
• developerWorks에서 직접 다운로드할 수 있는 IBM 시험판 소프트웨어를 사용하여 Linux와 관련된 후속 개발 프로젝트를 구현해 볼 수 있다.
  
  

토론

• 블로그, 포럼, 팟캐스트 및 스페이스를 통해 developerWorks 커뮤니티에 참여할 수 있다.
  
  

필자소개

M. Tim Jones는 임베디드 펌웨어 아키텍트이자 Artificial Intelligence: A Systems Approach, GNU/Linux Application Programming(현재 2판), AI Application Programming(현재 2판) 및 BSD Sockets Programming from a Multilanguage Perspective의 저자이다. 정지 위성을 위한 커널 개발에서 시작해 임베디드 시스템 아키텍처와 네트워크 프로토콜 개발에 이르기까지 다양한 분야에 대한 공학 지식을 가지고 있다. 콜로라도주 롱몬트 소재의 Emulex Corp.에서 컨설턴트 엔지니어로 활약하고 있다.