web-dev-qa-db-ja.com

オブジェクトの配列を動的に割り当てる

これは一種の初心者の質問ですが、私は長い間C++をやっていないので、ここに行きます...

動的に割り当てられた配列を含むクラスがあります

_class A
{
    int* myArray;
    A()
    {
        myArray = 0;
    }
    A(int size)
    {
        myArray = new int[size];
    }
    ~A()
    {
        // Note that as per MikeB's helpful style critique, no need to check against 0.
        delete [] myArray;
    }
}
_

しかし今、これらのクラスの動的に割り当てられた配列を作成したいと思います。現在のコードは次のとおりです。

_A* arrayOfAs = new A[5];
for (int i = 0; i < 5; ++i)
{
    arrayOfAs[i] = A(3);
}
_

しかし、これはひどく爆発します。 （A(3)呼び出しで）作成された新しいAオブジェクトは、forループの繰り返しが終了すると破壊されるため、内部myArrayはAインスタンスは_delete []_- edを取得します。

だから私は私の構文がひどく間違っているに違いないと思う？私は過剰に思われるいくつかの修正があると思いますが、私は避けたいと思っています：

  • Aのコピーコンストラクターを作成します。
  • _vector<int>_と_vector<A>_を使用しているので、これについて心配する必要はありません。
  • arrayOfAsをAオブジェクトの配列にする代わりに、_A*_ポインターの配列にします。

これは、内部の動的割り当てを持つものの配列を動的に割り当てようとするときに実際に機能する構文がある初心者向けのものだと思います。

（また、私がC++をやってからしばらく経ちましたので、スタイルの批評家も高く評価しています。）

将来の視聴者向けの更新：以下の回答はすべて非常に役立ちます。サンプルコードと便利な「4のルール」のため、Martinのものは受け入れられますが、それらをすべて読むことをお勧めします。いくつかは、何が間違っているかを簡潔に説明したものであり、一部はvectorsが良い方法である理由と理由を正しく指摘しています。

c++memory-managementpointersdestructorcopy-constructor
54
Domenic

コンテナを構築するために、標準コンテナの1つ（std :: vectorなど）を使用したいことは明らかです。しかし、これは、オブジェクトにRAWポインターが含まれている場合に考慮する必要があることの完璧な例です。

オブジェクトにRAWポインターがある場合は、3のルール（C++ 11の5のルール）を覚えておく必要があります。

  • コンストラクタ
  • デストラクタ
  • コンストラクタをコピー
  • 割り当て演算子
  • コンストラクターの移動（C++ 11）
  • 移動の割り当て（C++ 11）

これは、定義されていない場合、コンパイラがこれらのメソッドの独自のバージョンを生成するためです（以下を参照）。コンパイラーが生成したバージョンは、RAWポインターを処理する場合に必ずしも有用ではありません。

コピーコンストラクターを修正するのは困難です（強力な例外保証を提供したい場合は簡単ではありません）。代入演算子は、コピーおよびスワップイディオムを内部で使用できるため、コピーコンストラクターの観点から定義できます。

整数の配列へのポインターを含むクラスの絶対最小値の詳細については、以下を参照してください。

正しく取得するのは簡単ではないことがわかっているため、整数の配列へのポインターではなく、std :: vectorの使用を検討する必要があります。このベクターは使いやすく（拡張も）、例外に関連するすべての問題をカバーします。次のクラスを以下のAの定義と比較します。

class A
{ 
    std::vector<int>   mArray;
    public:
        A(){}
        A(size_t s) :mArray(s)  {}
};

あなたの問題を見て：

A* arrayOfAs = new A[5];
for (int i = 0; i < 5; ++i)
{
    // As you surmised the problem is on this line.
    arrayOfAs[i] = A(3);

    // What is happening:
    // 1) A(3) Build your A object (fine)
    // 2) A::operator=(A const&) is called to assign the value
    //    onto the result of the array access. Because you did
    //    not define this operator the compiler generated one is
    //    used.
}

コンパイラによって生成された代入演算子は、ほぼすべての状況で問題ありませんが、RAWポインターが使用されている場合は注意が必要です。あなたの場合、それが原因で問題を引き起こしています 浅いコピー 問題。最終的に、同じメモリへのポインタを含む2つのオブジェクトになりました。 A(3)がループの終わりに範囲外になると、ポインターでdelete []を呼び出します。したがって、（配列内の）他のオブジェクトには、次のメモリーへのポインターが含まれます。システムに返されました。

コンパイラが生成したコピーコンストラクター;メンバーコピーコンストラクターを使用して各メンバー変数をコピーします。ポインターの場合、これは単にポインター値がソースオブジェクトから宛先オブジェクトにコピーされることを意味します（したがって、浅いコピー）。

コンパイラーが生成した代入演算子;そのメンバー割り当て演算子を使用して、各メンバー変数をコピーします。ポインターの場合、これは単にポインター値がソースオブジェクトから宛先オブジェクトにコピーされることを意味します（したがって、浅いコピー）。

したがって、ポインターを含むクラスの最小値：

class A
{
    size_t     mSize;
    int*       mArray;
    public:
         // Simple constructor/destructor are obvious.
         A(size_t s = 0) {mSize=s;mArray = new int[mSize];}
        ~A()             {delete [] mArray;}

         // Copy constructor needs more work
         A(A const& copy)
         {
             mSize  = copy.mSize;
             mArray = new int[copy.mSize];

             // Don't need to worry about copying integers.
             // But if the object has a copy constructor then
             // it would also need to worry about throws from the copy constructor.
             std::copy(&copy.mArray[0],&copy.mArray[c.mSize],mArray);

         }

         // Define assignment operator in terms of the copy constructor
         // Modified: There is a slight twist to the copy swap idiom, that you can
         //           Remove the manual copy made by passing the rhs by value thus
         //           providing an implicit copy generated by the compiler.
         A& operator=(A rhs) // Pass by value (thus generating a copy)
         {
             rhs.swap(*this); // Now swap data with the copy.
                              // The rhs parameter will delete the array when it
                              // goes out of scope at the end of the function
             return *this;
         }
         void swap(A& s) noexcept
         {
             using std::swap;
             swap(this.mArray,s.mArray);
             swap(this.mSize ,s.mSize);
         }

         // C++11
         A(A&& src) noexcept
             : mSize(0)
             , mArray(NULL)
         {
             src.swap(*this);
         }
         A& operator=(A&& src) noexcept
         {
             src.swap(*this);     // You are moving the state of the src object
                                  // into this one. The state of the src object
                                  // after the move must be valid but indeterminate.
                                  //
                                  // The easiest way to do this is to swap the states
                                  // of the two objects.
                                  //
                                  // Note: Doing any operation on src after a move 
                                  // is risky (apart from destroy) until you put it 
                                  // into a specific state. Your object should have
                                  // appropriate methods for this.
                                  // 
                                  // Example: Assignment (operator = should work).
                                  //          std::vector() has clear() which sets
                                  //          a specific state without needing to
                                  //          know the current state.
             return *this;
         }   
 }
119
Martin York

Std :: vector：のようなものを使用することをお勧めします

typedef std::vector<int> A;
typedef std::vector<A> AS;

STLのわずかな過剰には何の問題もありません。自転車を再発明する代わりに、アプリの特定の機能の実装により多くの時間を費やすことができます。

10
IMil

Aオブジェクトのコンストラクターは、別のオブジェクトを動的に割り当て、その動的に割り当てられたオブジェクトへのポインターを生のポインターに格納します。

そのシナリオでは、must独自のコピーコンストラクター、代入演算子、およびデストラクターを定義します。コンパイラが生成したものは正しく動作しません。 （これは「ビッグ3の法則」の帰結です。デストラクタ、代入演算子、コピーコンストラクタのいずれかを持つクラスには、通常3つすべてが必要です）。

独自のデストラクタを定義しました（そして、コピーコンストラクタを作成することについて言及しました）が、3つのうちの他の2つを定義する必要があります。

別の方法は、動的に割り当てられたint[]へのポインタを、これらのことを処理する他のオブジェクトに格納することです。 vector<int>（前述）またはboost::shared_array<>のようなもの。

これを煮詰めるには、RAIIを最大限に活用するために、可能な限り生のポインターを扱うことは避けてください。

そして、他のスタイルの批評を求めたので、マイナーなものは、生のポインターを削除するとき、deleteを呼び出す前に0をチェックする必要がないことです-deleteは何もしないことでそのケースを処理しますチェックでコードを乱雑にする必要はありません。

6
Michael Burr

  1. オブジェクトにデフォルトまたはコピーのコンストラクターがある場合にのみ、オブジェクトの配列または共通コンテナーを使用します。

  2. それ以外の場合はポインターを保存します（またはスマートポインターですが、この場合はいくつかの問題が発生する可能性があります）。

PS：常に独自のデフォルトを定義し、コンストラクタをコピーしないと、自動生成が使用されます

4
noonex

SetSizeメソッドがないのはなぜですか。

A* arrayOfAs = new A[5];
for (int i = 0; i < 5; ++i)
{
    arrayOfAs[i].SetSize(3);
}

私は「コピー」が好きですが、この場合、デフォルトのコンストラクターは実際には何もしていません。 SetSizeは、元のm_array（存在する場合）からデータをコピーできます。これを行うには、クラス内に配列のサイズを保存する必要があります。
OR
SetSizeは、元のm_arrayを削除できます。

void SetSize(unsigned int p_newSize)
{
    //I don't care if it's null because delete is smart enough to deal with that.
    delete myArray;
    myArray = new int[p_newSize];
    ASSERT(myArray);
}
2
baash05

次のような割り当て演算子が必要です。

arrayOfAs[i] = A(3);

正常に機能します。

2
Jim Buck

new演算子の配置機能を使用して、オブジェクトを所定の場所に作成し、コピーを回避できます。

配置（3）：void * operator new（std :: size_t size、void * ptr）noexcept;

単にptrを返します（ストレージは割り当てられません）。ただし、関数がnew-expressionによって呼び出された場合、適切な初期化が実行されることに注意してください（クラスオブジェクトの場合、これには既定のコンストラクターの呼び出しが含まれます）。

私は次を提案します：

A* arrayOfAs = new A[5]; //Allocate a block of memory for 5 objects
for (int i = 0; i < 5; ++i)
{
    //Do not allocate memory,
    //initialize an object in memory address provided by the pointer
    new (&arrayOfAs[i]) A(3);
}
1
Saman Barghi