cdeclog

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] = {};

operator->() #

">>", "<<" 연산자 겹지정 #

operator overloading #

example #

#include <iostream>
using namespace std;


class Set
{
public:
        Set() {}
        Set(const Set &s) {}
        ~Set() {}

public:
        Set& operator=(const Set &s); // 대입연산자 

        Set operator+(const Set &s) const; // 합집합 
        Set operator-(const Set &s) const; // 차집합 
        Set operator*(const Set &s) const; // 교집합 
};

Set& Set::operator=(const Set &s)
{
        if (this != &s) {
                // 대입을 합니다. 
        }
        return *this;
}

Set Set::operator+(const Set &s) const
{
        Set r;
        // 합집합 구현 ... 
        return r;
}

Set Set::operator-(const Set &s) const
{
        Set r;
        // 차집합 구현 ... 
        return r;
}

Set Set::operator*(const Set &s) const
{
        Set r;
        // 교집합 구현 ... 
        return r;
}


int main()
{
        Set a;
        Set b;

        // 합집합을 구합니다. 
        // Set c = a.operator+(b); 
        Set c = a + b;

        // 차집합을 구합니다. 
        // Set c = a.operator-(b); 
        Set d = a - b;

        // 교집합을 구합니다. 
        // Set c = a.operator*(b); 
        Set e = a * b;

        // 대입연산자를 이용합니다.   
        // a.operator=(b); 
        a = b;

}

증가연산자의 prefix와 postfix를 구분하기 #

#include <iostream>
using namespace std;

class CInt
{
public:
        CInt() {}
        ~CInt() {}

public:
        // prefix : ++CInt 
        CInt& operator++();

        // postfix : CInt++ 
        const CInt operator++(int);

private:
        int n_;
};


CInt& CInt::operator++()
{
        ++n_;
        return *this;
}

const CInt CInt::operator++(int)
{
        CInt ci(*this);
        ++(*this);

        return ci;
}


int main()
{
        CInt ci;

        ci++;
        ++ci;
}

class String
{
public:
        /* ... */

        // 변환함수 
        // 암시적으로 const char* 타입으로 변환하게 합니다. 
        operator const char*()
        {
                return pstr;
        }

private:
        char *pstr;
};


int main()
{
        String str;

        // 변환 함수가 사용됩니다. 
        const char *pstr = str;
}

#include <iostream>
using namespace std;

class String
{
public:
        String(const String &str)
        {
                pstr_ = new char[strlen(str.pstr_) + 1];
                strcpy(pstr_, str.pstr_);
        }

        explicit String(const char *pstr = NULL)
        {
                pstr_ = new char[strlen(pstr) + 1];
                strcpy(pstr_, pstr);
        }

        ~String()
        {
                delete pstr_;
        }

        String& operator=(const String &str)
        {
                if (this != &str) {
                        if (pstr_) {
                                delete pstr_;
                        }

                        pstr_ = new char[strlen(str.pstr_) + 1];
                        strcpy(pstr_, str.pstr_);
                }

                return *this;
        }

        operator const char*() const
        {
                return pstr_;
        }

private:
        char *pstr_;
};


int main()
{
        String str("AAA");

        // 컴파일 에러가 생겨야 하지만 문제없이 
        // 컴파일 됩니다. 
        // 변환함수때문에 포인터값을들 비교하는 
        // 의도하지 않은 결과가 이루어 집니다. 
        if ("AAA" == str) {
                /* ... */
        }

}

#include <iostream>
using namespace std;

class CInt
{
public:
        CInt() {}
        CInt(int n) : n_(n) {}
        ~CInt() {}

        operator int()
        {
                return n_;
        }

private:
        int n_;
};


int main()
{
        CInt Number;

        // 파라미터가 1개인 생성자인 
        // CInt(int n)에 근거하여 암시적인 
        // 형변환이 이루어 집니다.   
        Number = 34;


        // operator int()의 변환연산자를 통하여 
        // CInt객체가 int 형으로 암시적으로 형변환이 
        // 가능합니다. 
        int n = Number;
}

#include <iostream>
using namespace std;

// String 타입의 배열객체 
class StringVector
{
public:
        // 디폴트생성자   
        StringVector() {}

        // n개의 String형의 배열 객체를 생성합니다. 
        explicit StringVector(int n) {}

        ~StringVector() {}
};


int main()
{
        StringVector vec;

        // 이것은 아무의미가 없습니다. 
        // 컴파일러에 의해 막아줘야 합니다. 
        // 이때 사용하는 것이 
        // explicit 키워드 입니다. 
        // 아래의 문장은 컴파일러에 의해 에러를 보고 할것 입니다. 
        vec = 34;
}

#include <string>
using std::string;

template <class T>
T Add(T tp1, T tp2)
{
        return tp1 + tp2;
}

int main()
{
        int n = Add(5, 2);
        string str1 = "C";
        string str2 = "++";
        string str = Add(str1, str2);
}

template <class T>
T Add(T tp1, T tp2)
{
        return tp1 + tp2;
}

int Add(int tp1, int tp2)
{
        return tp1 + tp2;
}

std::string Add(std::string tp1, std::string tp2)
{
        return tp1 + tp2;
}

class NoOperator {};

int main()
{
        NoOperator Op1;
        NoOperator Op2;

        // 에러입니다. 
        // NoOperator는 operator+() 제공하지 않습니다. 
        Add(Op1, Op2);
}

#include <string>
using std::string;

template <class T>
class TWrapper
{
public:
        T& GetRefValue()
        {
                return tp_;
        }

private:
        T tp_;
};


int main()
{
        TWrapper<int> Int;
        TWrapper<string> String;
}

class TWrapper
{
public:
        int& GetRefValue()
        {
                return tp_;
        }

private:
        int tp_;
};

class TWrapper
{
public:
        string& GetRefValue()
        {
                return tp_;
        }

private:
        string tp_;
};

template <class T>
T Add(T tp1, T tp2)
{
        return tp1 + tp2;
}

int main()
{
        const char *sz = Add("C", "++");
}

const char* Add(const char* tp1, const char* tp2)
{
        return tp1 + tp2;
}

template <class T>
T Add(T tp1, T tp2)
{
        return tp1 + tp2;
}

template <>
const char* Add(const char* p1, const char* p2)
{
        static char sz[1024] = {0, };
        strcpy(sz, p1);
        strcat(sz, p2);
        return sz;
}


int main()
{
        // template Add 함수 버전을 사용합니다. 
        int n = Add(3, 2);

        // const char* 특화버전 Add 함수를 사용합니다. 
        const char* p = Add("C", "++");
}

template <class T>
class TWrapper
{
public:
        T& GetRefValue()
        {
                return tp_;
        }

private:
        T tp_;
};


// const char* 타입에 대해서는 인스턴스를 못만들게 하기위해 
// 아래와 같은 템플릿 클래스의 전문화를 만듭니다. 
template <>
class TWrapper<const char*>
{
private:
        TWrapper() {}; // private 생성자입니다. 
};


int main()
{
        // 성공입니다. 
        TWrapper<int> Int;

        // 에러입니다. 
        // 위의 const char* 의 클래스전문화가 
        // const char* 인스턴스생성을 막아줍니다. 
        // 기특하기도 하쥐 -_- 
        TWrapper<const char*> CharP;
}

class Adder
{
public:
        template <class T>
        T Add(const T& t1, const T& t2)
        {
                return t1 + t2;
        }
};


int main()
{
        Adder adder;
        int n = adder.Add(3, 4);
        double d = adder.Add(5.3, 2.3);
}

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


template <class T>
class Any
{
public:
        string GetType()
        {
                return "class Any";
        }
};


template <class T>
class Any<T *>
{
public:
        string GetType()
        {
                return "class Any<T *>";
        }
};

template <class T>
class Any<const T>
{
public:
        string GetType()
        {
                return "class Any<const T>";
        }
};


template <class T>
class Any<const T*>
{
public:
        string GetType()
        {
                return "class Any<const T*>";
        }
};


int main()
{
        Any<int> A1;
        cout << A1.GetType() << endl;

        Any<int *> A2;
        cout << A2.GetType() << endl;

        Any<const int> A4;
        cout << A4.GetType() << endl;

        Any<const int *> A5;
        cout << A5.GetType() << endl;
}

결과:
class Any
class Any<T *>
class Any<const T>
class Any<const T*>