cdeclog

#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에 할당 되었으므로 
        // 해제가 필요없습니다. 
        // 이 함수가 끝나면 자동으로 스택에서 
        // 제거 됩니다.   

}