cdeclog

#ifndef __PROP_H__BY_CDECL__ 
#define __PROP_H__BY_CDECL__ 

namespace Glass {

class IYES {};
class YES : public IYES {};
class NO {};

template <class T, class Parent, class ReadWrite = YES>
    class Prop
{
public:
    typedef Prop<T, Parent> this_type;
    typedef T (Parent::*get_fun)();
    typedef void (Parent::*set_fun)(const T&);

    Prop() : getf_(NULL), setf_(NULL), parent_(NULL) {}

    void SetParent(Parent *p) {
        parent_ = p;
    }

    void Set(set_fun f) {
        ReadWrite yn;
        IYES *p = &yn; // 읽기전용일때 이함수를 사용하면 컴파일 에러 !! 

        setf_ = f;
    }

    void Get(get_fun f) {
        getf_ = f;
    }

    T operator=(const T &value) {
        ReadWrite yn;
        IYES *p = &yn; // 읽기전용일때 이함수를 사용하면 컴파일 에러 !! 

        if (!setf_) {
            throw exception();
        }

        (parent_->*setf_)(value);
        return value;
    }

    T operator=(this_type &type) {
        return operator=(static_cast<T>(type));
    }

    operator T() {
        if (!getf_) {
            throw exception();
        }

        return (parent_->*getf_)();
    }

private:
    Parent *parent_;
    get_fun getf_;
    set_fun setf_;

};


} // namespace Glass 

#endif // __PROP_H__BY_CDECL__ 



#include <iostream>
#include <string>
using namespace std;


class AA
{
public:
    AA() {
        Str.SetParent(this);
        Str.Set(&AA::setStr);
        Str.Get(&AA::getStr);
    }

    void setStr(const string &str)
    {
        cout << "setStr" << endl;
        str_ = str;
    }

    string getStr()
    {
        cout << "getStr" << endl;
        return str_;
    }

    Glass::Prop<string, AA> Str;
    string str_;
};


int main()
{
    AA a;
    a.Str = "cdecl ";

}

#include <iostream>
#include <string>
using namespace std;

#include <windows.h>
#include <boost/pool/pool.hpp>

class VM
{
public:
    void* operator new(size_t s)
    {
        return bpool.malloc();
    }

    void operator delete(void *p)
    {
        bpool.free(p);
    }

private:
    char sz[100];

private:
    static boost::pool<> bpool;
};

boost::pool<> VM::bpool(sizeof(VM));


class NVM
{
private:
    char sz[100];
};


template <class Ty>
DWORD PoolingTest()
{
    enum { COUNT = 1000, LOOP = 500 };

    DWORD dw = GetTickCount();
    Ty *pArr[LOOP];

    int i, j;
    for (i = 0; i < COUNT; ++i) {
        for (j = 0; j < LOOP; ++j) {
            pArr[j] = new Ty();
        }
        for (j = 0; j < LOOP; ++j) {
            delete pArr[j];
        }
    }

    return GetTickCount() - dw;
}


int main()
{
    cout << "pooling: " << PoolingTest<VM>() << endl;
    cout << "normal: " << PoolingTest<NVM>() << endl;

    cout << "END" << endl;
    cin.get();
    return 0;
}

OOP는 능숙되지 않은 프로그램머에게 나쁜프로그램을 못하게 하는 것이다 #

최소 완전한 class를 만들어라 #

• 생성
  
• 소멸
  
• 복사및 대입
  
• 상속
  
  
  

생성 #

class Item
{
public:
   Item();  // 디폴트생성자 - 구현생략 
};

소멸 #

복사및 대입 #

상속 #

class Interface
{
public:
        virtual void MemberFunction() = 0;        // 순수가상함수 
        virtual ~Interface() {}
};

Resource Acquisition Is Initialization #

#include <stdexcept>
#include <iostream>
using namespace std;

int main()
{
        try {
                // 실패한다면 std::bad_alloc 예외 발생 
                int *p = new int[10000000];

                // 구식 컴파일러라면 이 조건에 .. 
                if (!p) {
                        cout << "bad alloc error : old version " << endl;
                        return -1;
                }
        }
       catch (std::bad_alloc &e) {
                cout << "bad alloc error " << endl;
        }
        catch (...) {
                cout << "unknown error " << endl;
        }
}

void* operator new(std::size_t size, const std::nothrow_t&) throw();
void* operator new[](std::size_t size, const std::nothrow_t&) throw();

#include <new>
#include <stdexcept>
#include <iostream>
using namespace std;

int main()
{
        try {
                int *p = new(nothrow) int[10000000];
                if (!p) {
                        cout << "bad alloc error : old version " << endl;
                        return -1;
                }
        }
        catch (std::bad_alloc &e) {
                cout << "bad alloc error " << endl;
        }
        catch (...) {
                cout << "unknown error " << endl;
        }
}

#include <iostream>
using namespace std;

class Item
{
public:
        Item() { cout << "ctor" << endl; }
        virtual ~Item() { cout << "dtor" << endl; }
};

int main()
{
        // Item 클래스의 메모리를 확보한후 
        // 생성자를 호출해 줍니다. 
        Item *p = new Item;
        Item *arr = new Item[10];

        // Item 클래스의 소멸자를 호출한후 
        // 메모리를 해제 합니다. 
        delete p;
        delete []arr; // new의 배열은 delete[] 로 해제합니다. 


        // Item 클래스의 메모리만 확보합니다. 
        // 생성자는 호출되지 않습니다. 
        Item *p2 = (Item *p)malloc(sizeof(Item));

        // Item 클래스의 메모리만 해제합니다. 
        // 소멸자는 호출되지 않습니다. 
        // 그것이 new로 생성된 객체일지라고 ... 
        free(p2);
}

#include <iostream>
#include <string>
using namespace std;

class Custom
{
public:
        // 사용자정의 operator new 함수 
        void* operator new (size_t n)
        {
                return malloc(n);
        }

        // operator new를 정의 했다면 
        // 반드시 그에 상응하는 operator delete를 
        // 만들어 재앙을 막읍시다 
        void operator delete(void *p)
        {
                free(p);
        }

};

int main()
{
        Custom *p = new Custom();
        delete p;

}

class Creator
{
public:
        Creator() {}
};

int main()
{
        Creator c;

        // 이걸 명시적으로 하고 싶은데 불행히도 
        // 이런것은 하지 못합니다. 
        // 에러 !! 
        c.Creator();        // 생성자호출 
}

#include <iostream>
#include <string>
using namespace std;


int main()
{
        // 메모리 할당만 합니다. 
        // 생성자 호출은 안합니다. 
        string *pHeap = (string*)malloc(sizeof(string));
        // C++식 단순 메모리 할당 입니다. 
        // malloc과 같은 내용입니다.   
        // string *pHeap = (string*)operator new (sizeof(string)); 


        // 정적으로 메모리를 잡습니다. 
        // 당연히 스택에 메모리가 잡히겠죠   
        char pStack[sizeof(string)];

        // 메모리 생성은 안하고 
        // 생성된 메모리 pBuff에 string을 코드를 
        // 올려 놓고 생성자를 호출합니다. 
        new (pHeap) string("할당된메모리에 생성");

        // 스택에 string 객체를 생성합니다. 
        new (pStack) string("정적메모리에 생성");


        // 소멸자를 명시적으로 호출해 줍니다. 
        // 미리 할당된(정적이든 동적이든) 메모리에 
        // 객체만 생성하는것이기 때문에 
        // pHeap이 메모리가 해제 된다고 해도 string의 
        // 소멸자가 자동으로 호출되지 않습니다. 
        // 그러므로 소멸자를 호출 안하거나 
        // 두번이상 소멸자를 호출하는 재앙은 
        // 사용자의 책임입니다.   
        pHeap->~string();

        // 소멸자 호출   
        // pStack은 char타입의 배열이므로 
        // string* 형으로 명시적인 형변화 필요   
        reinterpret_cast<string *>(pStack)->~string();

        // pHeap의 메모리를 해제 합니다. 
        // operator new로 할당 했다면 
        // operator delete(pHeap) 
        free(pHeap);

        // pStack은 stack에 할당 되었으므로 
        // 해제가 필요없습니다. 
        // 이 함수가 끝나면 자동으로 스택에서 
        // 제거 됩니다.   

}

// 3개의 원소를 각각 1, 2, 3 으로 초기화 
int nArr[3] = { 1, 2, 3 };

// 4개의 원소를 가지는 배열 4개를 1, 2, 3, 4 로 초기화 
// 이때 배열의 개수는 4개로 자동으로 정의됨 
int nArr[] = { 1, 2, 3, 4 };

struct St {
  int a;
  int b;
};

// 구조체 St의 멤머 a, b를 각각 1, 2로 초기화 
St st = { 1, 2 };

// 구조체의 배열 초기화 
St st[2] = { { 0, 1 }, { 2, 3 } };

// 어떤값이 들어있는지 정의되지 않았음 
int nArr[3];
St st;
St st[2] ;

// 물론 배열및 구조체 변수가 아닌 일반 auto 변수도 같이 적용 
int n; // 정의되지 않음 

// 첫번째 원소에 0을 초기화 하고 나머지 2개의 원소에는 0을 적용 
int nArr[3] = { 0 };

// 첫번째와 두번째에 각각 1, 3으로 값을 초기화 하고 나머지 3개의 원소에 대해서는 0으로 초기화 한다 
int nArr[5] = { 1, 3, };

// 맨 마지막 콤마는 생략 가능 
int nArr[5] = { 1, 3 };


struct St {
  int a;
  int b;
};

// St의 a의 멤버에 2를 초기화 하고 나머지멤버인 b에 0을 초기화 
St st = { 2 };
St st = { 2, };

struct St {
  int a;
  int b;
};

// 0으로 초기화 하는 같은 내용들   
St st = { 0, 0 };
St st = { 0, };
St st = { 0 };
St st = {};

int nArr[5] = { 0, 0, 0, 0, 0 };
int nArr[5] = { 0, };
int nArr[5] = { 0 };
int nArr[5] = {};