C++ Template 활용(Android쪽 코드)

// intro1day.cpp : Defines the entry point for the console application.

//

//#include "stdafx.h"

#include <iostream>

using namespace std;

#if 0

//int_cast만드는 연습(interface cast와 비슷, 최상위 class에는 pure virtual 함수로 작성해서 

//하위 class에서 강제로 toInt를 만들게 한다면 interface_cast가 될 것

class Test

{

public:

//Test 클래스는 int값을 하나 꺼낼 수 있다고 가정해 봅시다.

static int toInt() {return 10;}

};

template<typename T> int int_cast(T obj)

{

return T::toInt();

}

int main()

{

//int n = Test::toInt();

Test t;

int n = int_cast<Test>(t);

printf("%d",n);

}

#endif

#if 0

//1. 함수템플릿

//    - T가 결정되어서 함수가 되는 과정을 인스턴스화 라고 한다.

//      암시적/명시적 인스턴스화가 있다.

template<typename T> T Max(T a, T b)

{

return a < b ? b: a;

}

int main()

{

cout << Max(1,3) << endl; // int Max(int, int) 버전의 함수를 생성

cout << Max(3.4, 2.1) << endl; // doudle Max(double, double) 버전의 함수를 생성

cout << Max<int> (65, 'B') << endl; //함수템플릿의 T를 명시적으로 지정하는 방법.

return 0;

}

#endif

#if 0

//클래스 템플릿..!!

template<typename T> class complex

{

T real;

T image;

publid:

complex(T a = 0, T b = 0): real(a), image(b) {}

//복사생성자

//U가 T로 변환된다면 complex<U>도complex<T>로 변환되어야 한다. - template복사생성자 필요

template<typename U> complex( const complex<U>&c )

{

real = c.real;

image = c.image;

}

template<typename U> friend class complex;

};

itn main()

{

complex<int> c1(1,2);

complex<int> c2 = c1;

complex<double> c3 = c1; //뭘까요? ..

}

#endif

#if 0 // 이거 앞으로 잘 활용할 수 있을 것 같은데 dkim

//Mix in template - 안드로이드에서 자주 사용하는 기법.

template<typename T>

class A

{

public:

void foo() { static_cast<T*>(this)->goo();} //T는 내 자식일것임 자기 자신(this)를 자기 자식으로 casting함 결국 자식께 부르게 됨

void goo() {cout << "A::goo" << endl;} //1 가상함수는 자식이 재정의하면 자식꺼를 부르게 해주자

//가상함수를 너무 많이 쓰면 성능 저하의 원인이다 그래서 가상함수 빼고 해 보겠음

// template를 이용해서 가상함수를 사용해야 할 것을 해결함 속도 증가

};

//부모가 template이고 그 템플릿이자로 현재 클래스의 이름을 보내는 기술..

// Mix in Template이라고 부른다. 여러가지 활용이 가능한데.. 아래의 경우는 비가상함수를

// 가상함수 처럼 동작하게 하는 기술이다.

class B :public A<B>

{

public:

void goo() { cout << "B::goo" << endl;} //2

};

int main()

{

B b;

b.foo(); // 1? 2?

}

#endif

#if 0 // wow~ dkim

// Mix in template 2 - 안드로이드에서 자주 사용하는 기법.

template<typename T> 

class A

{

protected:

~A() {cout << "~A()" << endl;}

void foo() {cout << "A::foo" << endl;}

public:

void clean()

{

delete static_cast<T*>(this);

}

};

class B: public A<B>

{

public:

~B() {cout << "~B()" << endl;}

virtual void foo() {cout << "B::foo" << endl;}

};

int main()

{

A<B>* p = new B; 

//virtual이 없는 foo라면부모 객체로 자식instance를 가리킬 때는 C++에서는 foo부르면 부모께 불림(메모리 안보고 타입만봄(정적언어 complile time)

//실행할 때 메모리를 보고 결정하라고 하는게 virtual이라는 keyword임

//그래서 foo에 virtual을 붙이면 자식꺼 부름

//p->foo();

//delete p; //이건? 소멸자가 항상 virtual이어야 하는 이유임

//그런데 virtual은 느리니까 virtual 빼고 protected로 만들면?

//부모 소멸자가 protected니까 error가 나는데 

// 이제 B의 소멸자를 호출하기 위해 꼭 캐스팅해서 사용하자. 불편하지만 제대로 호출된다.!

//delete static_cast<B*>(p); //이렇게 하니까 잘 되긴 하지만 불편하다.

//그래서 clean을 만들어보자

p->clean(); //가상함수 테이블이 없어진 가벼운 객체가 만들어졌으므로 이제 쉽게 쓰자

}

#endif

#if 0 

//상속과 upcasting(부모포인터로 자식 객체를 담을 수 있다)

// * 이런 장점을 활용하여 동종을 저장하는 컬렉션을 만들 수 있다.

//      그리고 동종(동일부모자식)을 처리하는 함수를 만들 수 잇다.

// * 모든 자식의 공통의 특징은 부모에 있어야 한다.

// * 

#include <vector> //STL vector .. 안드로이드에서도 있습니다.

//도형 편집기를 만들어 보자. - 아주 많은 개념이 등장합니다 꼭 알아두세요..

// 1. 각 도형의 특징을 관리하는 타입을 만들어보자

// 2. 동일 부모가 있다면 모든 도형을 묶을 수 있지 않을까???

// 3. 모든 자식은 공통의 기능은 반드시 부모로 부터 제공되어야 한다.

// 4. 자식이 재정의 하게 되는 함수는 반드시 가상함수로 하자.

// 5. OCP 이론 

//    다형성이 좋은 점은 나중에 기능(class)가 추가되어도 이 code는 수정할 필요가 없음

//    객체지향의 원칙 중 OCP : Open Close Principle : 기능 추가에 열려 있고(open), 코드 수정에 닫혀(Close)있어야 한다는 이론(Principle)

// 6. 

class Shape

{

public:

// template method : 변하지 않는 전체적인 알고리즘은 부모가 public 비 가상함수로 만들고

//                   변해야 하는 세부 알고리즘은 자식이 prottected가상함수로 재정의 하도록 하는 디자인

void Draw() //자식에게 재정의하지 못하게 하면 좋겠지만 C++은 그런 기능은 없고, 최소한 virtual은 빼자

{

//Mutex.Lock();

OnDraw();

//Mutex.Unlock();

}

public:

virtual void OnDraw() = 0; //pure virtual func.. 자식이 반드시 만들어야함(강제)

                          //이런 디자인 기법을 template Method라고 부른다.

};

class Rect : public Shape

{

protected :

virtual void OnDraw() {cout << "Rect::Draw" << endl;}

};

class Circle : public Shape

{

protected: //RealDraw를 직접 부르면 Mutex를 못쓰니까 못쓰게 막자(private는 자기네들끼리도 못하게 하니까 protected로)

virtual void RealDraw() {cout << "Circle::Draw" << endl;}

};

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 == 9)

{

for(int i = 0; i < v.size(); i++)

v[i]->Draw(); //다형성 , 동일 함수 호출 표현식이 상황에 따라 다른 함수를 호출함

}

}

}

#endif

#if 0

#include "List.h" /// froyo/framework/base/include/utils에 sp, RefBase, list, vector등이 있습니다.

using namespace android; //안드로이드의 모든 클래스는 이 안에 있습니다.

// 요즘 C++의 콜렉션 클래스(뭔가를 저장하는 클래스)를 이해하려면 반복자를 알아야 합니다.

int main()

{

List<int> st;

st.push_back(10);

st.push_back(20);

st.push_back(30);

st.push_front(40);

st.insert(++st.begin(), 100);

List<int>::iterator p = st.begin(); // p는 st의 처음을 가리키는 포인터 역할을 함

List<int>::iterator p1 = st.end(); //st의 마지막을 가리키는 포인터

while(p != st.end())

{

cout << *p << endl;

++p;

}

//마지막 요소 제거하기

st.erase(--p1); //st의 마지막을 가리키는 포인터

p = st.begin();

//while(p != st.end())

//{

// cout << *p << endl;

// ++p;

//}

}

#endif

//1. 부분전문화 개념

/*

//primary template

template<typename T> class Stack

{

};

//부분 전문화

template<typename T> class Stack<T*>

{

};

//전문화 버전

template<typename T> class Stack<char*>

{

};

int main()

{

Stack<int> s1;

Stack<int*> s2;

Stack<char*> s3;

}

*/

//안드로이드가 사용하는 가장 복잡한 template기술 - traits 기술

// traits란? T가 pointer인지 아닌지, 구조체인지 아닌지 공용체인지 아닌지를 알아내는 기술

/*

template<typename T> T Max(T a, T b)

{

if(T is Pointer)

return *a < *b ? b : a;

return a < b ? b : a ;

};

int main()

{

int x = 10, y = 20;

Max(x,y);

Max(&x, &y);

}

*/

//T가 포인터인지 알아내는 기술(한마디로 컴파일러에게 물어본거)

// framework/base/include/utils/typehelpers.h

// primary template 은 FALSE리턴

template<typename T> struct trait_pointer

{

enum{value = false};

};

//부분전문화 버전은 TRUE 리턴

template<typename T> struct trait_pointer<T*>

{

enum{value = true};

};

// primary template 은 FALSE리턴

template<typename T> struct trait_array

{

enum{size = 0};

enum{value = false};

};

//부분전문화 버전은 TRUE 리턴

template<typename T, int N> struct trait_array<T[N]>

{

enum{size = N};

enum{value = true};

};

template<typename T> void foo(const T& a)

{

if(trait_array<T>::value) 

cout << "Array, " << "Size is " << trait_array<T>::size << endl;

else

cout << "not Array" << endl;

if(trait_pointer<T>::value)

cout << "Pointer" << endl;

else

cout << "not Pointer" << endl;

};

int main()

{ 

int n[] = {0,1,2};

foo(n);

}



=============================
Default 생성자 관련

class Animal

{

public:

Animal() {cout << "Animal Ctor" << endl;}

Animal(char * sz) {cout << "Animal Ctor(char)" << endl;}

};

class Dog : public Animal

{

public:

Dog() : Animal() {cout << "Dog Ctor" << endl;}

Dog(char * sz) : Animal(sz) {cout << "Dog Ctor(char)" << endl;} //Default 생성자를 이해해야 함

};

int main()

{

Animal a;

Animal a2("aa");

cout << "---------------" << endl;

Dog d1;

Dog d2("aaa");

}

 =========================================

#if 0

template<typename T> class Stack

{

public:

//다음 중 생성자로 맞는 것은?

Stack() { cout << "Stack" << endl;}   // ok...

//Stack<T>() {}                       // error

//복사생성자

Stack(const Stack& s) {} // 함수인자로는 2번이 정확한 표현이지만 이 표현도 허용

Stack(const Stack<T>& s) {} //ok

//클래스 템플릿의 멤버 함수를 외부 구현

void push(const T* a);

// 클래스 템플릿의 멤버 함수 템플릿.. 

// 예)complex만들기 complex<double> = complex<int>가 되게 하기 위해 복사생성자를 아래처럼 구현했었음

template<typename U> T foo(U a);

};

//복사생성자와 대입연산자 만들때만 이런식으로 하게 된다.  android에서는 sp에서 복사, 대입에 나옴

template<typename T> template<typename U> T Stack<T>::foo(U a)

{

}

//둘 중 어느게 맞는건가요?

template<typename T> void Stack::push(const T& a)        // error

template<typename T> void Stack<T>::push(const T& a)     // ok

{

}

#endif


=====================================================

#if 0

//템플릿 인자의 3가지 종류 

template<typename T> class List

{

};

template<typename T, int N> class Stack1

{

T buff[N];

};

template<template<typename> class C, typename T> class Stack2

{

C c; // error

c<T> c; // ok

};

int main()

{

List ss; // List는 템플릿이다

List<int> s; //List는 타입이다.

Stack1<int, 10> s2;    

Stack2<List, int> s3;

==> template인자로 들어갈 수 있는 것은 3가지 ==> 타입, 정수, 템플릿

}

#endif

================================================================ 

  

//template을 사용해서 부모가 바귀게 하는 기술.. BpInterface/BnInterface가 사용하는 기술

template<typename T, typename ThreadModel> class List : public ThreadModelList

{

public:

void push(const T&a )

{

Lock();

...

Unlock();

}

};

class MultiThread

{

public:

void Lock() {mutex.lock();}

void UnLock() {mutex.Unlock();}

};

class SingleThread

{

public:

void Lock(){}

void UnLock() {}

};

// 사용한는 방법 ------------------------

// 부모를 가져다 쓰는 순간에 결정함

List<int, MultiThread> st;

List<int, SingleThread> st; //어짜피 최적화되면 성능저하 없음

 ================================================================