지나간 삶

#include <queue>       // Q 또는우선순위Q를사용.

                       // 내부적으로 사용 할 container의 헤더도include 해야 한다.

#include <functional>

template<typename T, typename Cont = vector<T>, typename Pred = less<T> >

class priority_queue

{

        Pred f; // 조건자함수 객체생성

public:

        void foo()

        {

               // 크기비교가 필요하다면

               bool b = f(1, 2);

        }

};

// 절대값으로 크기를 비교하는 함수객체

template<typename T> struct abs_less

{

        bool operator()( T a, T b )

        {

               return abs(a) < abs(b);

        }

};

void main()

{

// greater<int> 는 템플릿 인자를 넘기기 때문에 타입을 넘긴다. 즉, () 를 쓰지 않는다.!!!

// 결국 단위전략의 크기 비교객체를 다양하게 활용 할 수 있다.

        // 디폴트로 vector를 사용.
        priority_queue<int, vector<int>, abs_less<int> > pq;
 

        pq.push(10);

        pq.push(20);

        pq.push(-50);

        pq.push(40);

        pq.push(30);

        cout << pq.top() << endl;
}

// 어답터 디자인패턴 기존의 있던 것을 이름만 바꿔서 새롭게 구성.

// Container 어답터

// list가있다. 그런데stack이필요하다.

template<typename T, typename Cont = deque<T> > class stack

{

        Cont st;

public:

        void push( T a ) { st.push_back(a); }

        void pop()       { st.pop_back(); }

        T&   top()       { return st.back(); }

};

#include <stack>

void main()

{

        stack<int, list<int> > st;

        stack<int> s; 

}

// std::rel_ops 이름 공간안에는 아래 함수가 있다.

// < 와 == 연산자를 정의해두면 다른연산자를 지원할 수 있다.!!!!!!!!!!

template<typename T> bool operator>( const T& a, const T& b)

{

        return !( a == b || a < b );

}

struct Point

{

        int x;

        int y;

public:

        Point( int a = 0, int b = 0 ) : x(a), y(b) {}

        bool operator==( const Point& p ) const

        {

               return true;

        }

        bool operator<( const Point& p ) const       // less than

        {

               return true;

        }

};

void main()

{

        Point p1, p2;

        bool b = p1 > p2;      // greater than

}

// STL의 string이 가지고 있는 단위전략패턴의 개념

// STL의 string은 문자열의 비교를 위해 단위전략클래스를 사용하고 있다.

// 사용자가 만들어서 전달할수도있다.

struct my_traits : public char_traits<char>

{

        // 두문자가 같은 지를 비교하기 위해 아래함수를 호출한다.

        static bool eq(char c1, char c2)
        {
               return toupper(c1) == toupper(c2);
        }

        static bool lt(char c1, char c2)
        {
               return toupper(c1) < toupper(c2);
        }

        static int  compare( const char* s1, const char* s2, size_t n )

        {

               return memicmp( s1, s2, n );

        }

        // 그 외의 몇개의 함수를 더 제공해야 한다.

        // 하지만 상속 받았으므로 부모 것을 그냥 사용 할 수도 있다.

};

typedef basic_string<char, my_traits, allocator<char> > ci_string;

void main()

{

        // 템플릿 인자를 사용하는 단위전략, 함수 단위전략보다 다양한 작업가능.

        // 또, 컴파일시간에 결정되므로 오버헤드도 줄인다.

        // basic_string<char, my_traits, allocator<char> > s1 = "AA"; 
        // 유니코드, 단위전략, 할당

        ci_string s1 = "hello";

        ci_string s2 = "HELLO";

        //string s1 = "hello";

        //string s2 = "HELLO";

        if( s1 == s2 )

        {

               cout << "same" << endl;

        }

        else

        {

               cout << "NotSame" << endl;

        }

}

class Animal

{

public:

        virtual void Cry() {}  // 1

};

class Dog : public Animal

{

public:

        virtual void Cry() {}  // 2

};

template<typename T> void foo( T a )  // Cry라는함수가없다면에러가나온다.

{

        a.Cry();       // 다형성-> 컴파일타임에결정된다. ( type을알고있다. )

}

void foo( Animal* p )  // Animal의자식들만받는다.

{

        p->Cry();      // 1 ? 2 다형성-> 실행시간다형성( 메모리를찾아간다. )

}

vector, deque, list 는 다음과 같은 생성자를 갖는다.
 

vector<int> v1;
vector<int> v2(5);
vector<int> v3( 5, 5 );                 // 5개를5로초기화
vecotr<int> v4( v3.begin(), v3.end() ); // v3의끝과처음으로초기화
vector<int> v5( v4 );                   // v4로초기화

** 사용자 정의 type을 Sequence Container에 넣으려면

1. 기본 생성자가 반드시 정의되어 있어야 한다.
2. 복사 생성자도 명시적으로든 묵시적으로든 반드시 존재해야 한다.
3. 일부 generic 알고리즘에서 원소들간의 상등관계나 대소 관계를 필요로 하기 때문에
   == 연산자와 < 연산자를 정의해 두는 것이 좋다.

// Allocator의개념...

// 메모리 할당만 책임을 지는 클래스를 설계한다.

template<typename T> class allocator

{

public:

        T* allocate( size_t sz )

        {

        }

        void deallocate( void* p )

        {

        }

};

// 단위전략기반의 설계: 한가지한가지의 정책을 template 인자로 전달할수 있게하는 기법.!!

template<typename T, typename Alloc = allocator<T> > class vector

{

        T* buf;

        Alloc alloc;           // 메모리할당기객체.

public:

        void push_front( T a )

        {

               // 메모리할당이 필요하게 되었다. !!

               // 어떤 방법으로 할당을 하는게 최고일까?
               // new ? malloc ? object pooling

               int* p = (int*)alloc.allocate();

        }

};

// 메모리 할당전략을 바꾸고 싶을때 내가 만든 클래스로 전달하게 해준다.!!!

// 기본할당자 allocator 를 가로챌수 있게 된다.

template<typename T> class myallocator

{

public:

        T* allocate( size_t sz )

        {

        }

        void deallocate( void* p )

        {

        }

};

void main()

{

        vector<int, myallocator<int> > v;

}

// reverse_iterator 덕에 알고리즘의 능력이 2배가 된다.

void main()

{

        string s1 = "hello";

        string s2 = "abcde";

        copy( s1.begin(), s1.end(), s2.rbegin() );

        cout << s2 << endl;    //'olleh'

        vector<int> v(5);

        v[0] = 1;

        v[1] = 2;

        v[2] = 3;

        v[3] = 4;

        v[4] = 5;

        vector<int>::reverse_iterator p = v.rbegin();  // 주의rbegin

        cout << *p << endl;

        ++p;

        cout << *p << endl;

}

// 어떤 container가 가진 type을 알고 싶을 때가 있다.

// 이 문제를 해결하기 위한 STL은 아래의 기법을 사용하고 있다.

template<typename T> class vector

{

public:

        typedef T value_type;

        typedef T* pointer;

        typedef T& reference;

        typedef const T* const_pointer;

};

template<typename T> void foo( T a )

{

        // typeof( a[0] ) n = a[0]; // 다른 언어에서 지원하는 언어 C#

        // a에서 첫번째 요소를 꺼내고 싶다.

        typename T::value_type n = a.front();

}

void main()

{

        vector<double> v(5);

        v[0] = 3.4;

        foo( v );

}