int main()

{

	int *temp;

	temp=new int[10];

	temp=new int(temp,10)[30];

	delete []temp;

	return 0;

}

#include <cstring> 



struct TestClass

{

    TestClass()                     : i(new int())          {}

    TestClass(int v)                : i(new int(v))         {}

    TestClass(const TestClass& a)   : i(new int(*(a.i)))    {}

    ~TestClass()                                            { delete i; }

    

    TestClass& operator =(const TestClass& rhs)

    {

        if(this != &rhs)

        {

            delete this->i;

            this->i = new int(*rhs.i);

         }

        return *this;

    }

private:

    int *i;

};



int main(void)

{

    TestClass   a(5);

    TestClass   b;

    b = a;                          //  正当

    

    TestClass   *c = new TestClass;

    std::memcpy(c, &a, sizeof(TestClass));

    delete c;                       //  この deleteの結果・・・

    

    return 0;

} 

>    TestClass& operator =(const TestClass& rhs)

>    {

>        if(this != &rhs)

>        {

>            delete this->i;

>            this->i = new int(*rhs.i);

>         }

>        return *this;

>    }

#include <cstdlib>

#include <cstdio>



class foo

{

private:

    int val_;

public:

    foo (int val = 0) : val_(val)

    {

        std::printf("%p : foo.ctor\n", reinterpret_cast<void*>(this));

    }

    ~foo ()

    {

        std::printf("%p : foo.dtor\n", reinterpret_cast<void*>(this));

    }

};



void * operator new[] (std::size_t size)

{

    void * p = std::malloc(size);

    std::printf("%p : op.new[] (%u)\n", p, static_cast<unsigned>(size));

    return p;

}



void operator delete[] (void * ptr)

{

    std::printf("%p : op.delete[]\n", ptr);

    std::free(ptr);

}



int main ()

{

    foo * p = new foo[1];

    std::printf("%p : new[] result\n", reinterpret_cast<void *>(p));

    delete[] p;

    return 0;

}

003A5BE0 : op.new[] (8)

003A5BE4 : foo.ctor

003A5BE4 : new[] result

003A5BE4 : foo.dtor

003A5BE0 : op.delete[]

A::A()

{

  func();  // ← ここで発生した例外を catch せず、呼び出し元にそのまま伝播するという意味？

}

#include <iostream>



class A

{

public :

    A() {

        p1 = NULL;

        p2 = NULL;

        p1 = new unsigned int[1024 * 1024];

        //if (p1 == NULL) { //本当はこちらが正しいが、あえてエラーということにさせる

        if (p1 != NULL) {

            goto err;

        }

        p2 = new unsigned int[1024 * 1024];

        if (p2 == NULL) {

            goto err;

        }

        return ;



err :

        delete[] p2;

        delete[] p1;

        throw "out of memory";

        return ;

    }

    ~A() {

        delete[] p2;

        delete[] p1;

    }

private :

    unsigned int* p1;

    unsigned int* p2;

};



int main()

{

    try {

        A* a = new A();

        delete a;

    } catch (const char* p) {

        std::cout << p << std::endl;

    }

    return 0;

}

A::A()

try

  : p1(0), p2(0)

{

  p1 = new unsigned int[1024*1024];

  p2 = new unsigned int[1024*1024];

}

catch (...)

{

  delete[] p1;

  delete[] p2;

  throw;

}

class A

{

public:

  A() : v1(1024*1024, 0), v2(1024*1024, 0) {}

private:

  std::vector<unsigned int> v1;

  std::vector<unsigned int> v2;

};

#include <iostream>



class A

{

public :

    A() {

        p1 = NULL;

        p2 = NULL;

        try {

            p1 = new unsigned int[1024 * 1024];

            p2 = new unsigned int[1024 * 1024];

        } catch (std::bad_alloc) {

            delete[] p2;

            delete[] p1;

            throw "out of memory";

        }

    }

    ~A() {

        delete[] p2;

        delete[] p1;

    }

private :

    unsigned int* p1;

    unsigned int* p2;

};



int main()

{

    try {

        A* a = new A();

        delete a;

    } catch (const char* p) {

        std::cout << p << std::endl;

    }

    return 0;

}

template<class InputIterator>

  vector(InputIterator first, InputIterator last, const Allocator& a = Allocator());

explicit vector(size_type n, const value_type& value = T(),

                             const Allocator& a = Allocator()); 

char* p = NULL;



p = new char[10]; // 1

p = new char[5];  // 2



delete[] p;

> typedef struct{

>         double x,y;

>         int status,counter;

>         int shot [11][15];

> } BODY_player_t;



これは、x, y, status, counter, そしてshotというメンバーを持つ

構造体に、BODY_player_tという別名を付けている、という意味です。

これ以降は、くだんの構造体をBODY_player_t型として扱えるようになります。



> BODY_player_t Player;



これが、BODY_player_t型の変数Playerの定義です。