C ++でのVectorの実装

Question

私は最近、プログラミング演習としてSTLVectorの実装を作成しました。プログラムはコンパイルされますが、次のような奇妙なエラーが表示されます。

terminate called after throwing an instance of 'std::bad_alloc'
  what():  std::bad_alloc

私はこれまでこのエラーを思いついたことがなく、正しく機能させるために実装内で正確に何を変更する必要があるのか​​わかりません。

誰かが私のコードを調べて、この特定のケースで何かが間違っていると飛び出すかどうかを確認できますか？申し訳ありませんが、具体的には言えません。どこを見ればよいかわかりません。よろしくお願いします。

#include <iostream>
#include <string>
#include <cassert>
#include <algorithm>

using namespace std;

template <class T>
class Vector
{
public:

   typedef T * iterator;

   Vector();
   Vector(unsigned int size);
   Vector(unsigned int size, const T & initial);
   Vector(const Vector<T> & v);      
   ~Vector();

   unsigned int capacity() const;
   unsigned int size() const;
   bool empty() const;
   iterator begin();
   iterator end();
   T & front();
   T & back();
   void Push_back(const T & value); 
   void pop_back();  

   void reserve(unsigned int capacity);   
   void resize(unsigned int size);   

   T & operator[](unsigned int index);  
   Vector<T> & operator=(const Vector<T> &);

private:
   unsigned int my_size;
   unsigned int my_capacity;
   T * buffer;
};

// Your code goes here ...
template<class T>
Vector<T>::Vector()
{
    my_capacity = 0;
    my_size = 0;
    buffer = 0;
}

template<class T>
Vector<T>::Vector(const Vector<T> & v)
{
    my_size = v.my_size;
    my_capacity = v.my_capacity;
    buffer = new T[my_size];  
    for (int i = 0; i < my_size; i++)
        buffer[i] = v.buffer[i];  
}

template<class T>
Vector<T>::Vector(unsigned int size)
{
    my_capacity = size;
    my_size = size;
    buffer = new T[size];
}

template<class T>
Vector<T>::Vector(unsigned int size, const T & initial)
{
    my_size-size;
    my_capacity = size;
    buffer = new T [size];
    for (int i = 0; i < size; i++)
        buffer[i] = initial;
        T();
}

template<class T>
Vector<T> & Vector<T>::operator = (const Vector<T> & v)
{
    delete[ ] buffer;
    my_size = v.my_size;
    my_capacity = v.my_capacity;
    buffer = new T [my_size];
    for (int i = 0; i < my_size; i++)
        buffer[i] = v.buffer[i];
    return *this;
}

template<class T>
typename Vector<T>::iterator Vector<T>::begin()
{
    return buffer;
}

template<class T>
typename Vector<T>::iterator Vector<T>::end()
{
    return buffer + size();
}

template<class T>
T& Vector<T>::Vector<T>::front()
{
    return buffer[0];
}

template<class T>
T& Vector<T>::Vector<T>::back()
{
    return buffer[size - 1];
}

template<class T>
void Vector<T>::Push_back(const T & v)
{
    if (my_size >= my_capacity)
    reserve(my_capacity +5);
    buffer [my_size++] = v;
}

template<class T>
void Vector<T>::pop_back()
{
    my_size--;
}

template<class T>
void Vector<T>::reserve(unsigned int capacity)
{
    if(buffer == 0)
    {
        my_size = 0;
        my_capacity = 0;
    }    
    T * buffer = new T [capacity];
    assert(buffer);
    copy (buffer, buffer + my_size, buffer);
    my_capacity = capacity;
    delete[] buffer;
    buffer = buffer;

}

template<class T>
unsigned int Vector<T>::size()const//
{
    return my_size;
}

template<class T>
void Vector<T>::resize(unsigned int size)
{
    reserve(size);
    size = size;
}

template<class T>
T& Vector<T>::operator[](unsigned int index)
{
    return buffer[index];
}  

template<class T>
unsigned int Vector<T>::capacity()const
{
    return my_capacity;
}

template<class T>
Vector<T>::~Vector()
{
    delete[]buffer;
}


int main()
{  

   Vector<int> v;

   v.reserve(2);
   assert(v.capacity() == 2);

   Vector<string> v1(2);
   assert(v1.capacity() == 2);
   assert(v1.size() == 2);
   assert(v1[0] == "");
   assert(v1[1] == "");

   v1[0] = "hi";
   assert(v1[0] == "hi");

   Vector<int> v2(2, 7);
   assert(v2[1] == 7);

   Vector<int> v10(v2);
   assert(v10[1] == 7);

   Vector<string> v3(2, "hello");
   assert(v3.size() == 2);
   assert(v3.capacity() == 2);
   assert(v3[0] == "hello");
   assert(v3[1] == "hello");

   v3.resize(1);
   assert(v3.size() == 1);
   assert(v3[0] == "hello");

   Vector<string> v4 = v3;
   assert(v4.size() == 1);
   assert(v4[0] == v3[0]);
   v3[0] = "test";
   assert(v4[0] != v3[0]);  
   assert(v4[0] == "hello");

   v3.pop_back();
   assert(v3.size() == 0);

   Vector<int> v5(7, 9);
   Vector<int>::iterator it = v5.begin();
   while (it != v5.end())
   {
      assert(*it == 9);
      ++it;
   }

   Vector<int> v6;
   v6.Push_back(100);
   assert(v6.size() == 1);
   assert(v6[0] == 100);
   v6.Push_back(101);
   assert(v6.size() == 2);
   assert(v6[0] == 100);
   v6.Push_back(101);

   cout << "SUCCESS\n";
}

Answer 1

ソースから更新された完全なソースコードは次のとおりです。

    #pragma once


//using namespace std;

template <class T>
class  Vector
{
public:

    typedef T * iterator;

    Vector();
    Vector(unsigned int size);
    Vector(unsigned int size, const T & initial);
    Vector(const Vector<T> & v);      
    ~Vector();

    unsigned int capacity() const;
    unsigned int size() const;
    bool empty() const;
    iterator begin();
    iterator end();
    T & front();
    T & back();
    void Push_back(const T & value); 
    void pop_back();  

    void reserve(unsigned int capacity);   
    void resize(unsigned int size);   

    T & operator[](unsigned int index);  
    Vector<T> & operator=(const Vector<T> &);
    void clear();
private:
    unsigned int my_size;
    unsigned int my_capacity;
    T * buffer;
};

// Your code goes here ...
template<class T>
Vector<T>::Vector()
{
    my_capacity = 0;
    my_size = 0;
    buffer = 0;
}

template<class T>
Vector<T>::Vector(const Vector<T> & v)
{
    my_size = v.my_size;
    my_capacity = v.my_capacity;
    buffer = new T[my_size];  
    for (unsigned int i = 0; i < my_size; i++)
        buffer[i] = v.buffer[i];  
}

template<class T>
Vector<T>::Vector(unsigned int size)
{
    my_capacity = size;
    my_size = size;
    buffer = new T[size];
}

template<class T>
Vector<T>::Vector(unsigned int size, const T & initial)
{
    my_size = size;
    my_capacity = size;
    buffer = new T [size];
    for (unsigned int i = 0; i < size; i++)
        buffer[i] = initial;
    //T();
}

template<class T>
Vector<T> & Vector<T>::operator = (const Vector<T> & v)
{
    delete[ ] buffer;
    my_size = v.my_size;
    my_capacity = v.my_capacity;
    buffer = new T [my_size];
    for (unsigned int i = 0; i < my_size; i++)
        buffer[i] = v.buffer[i];
    return *this;
}

template<class T>
typename Vector<T>::iterator Vector<T>::begin()
{
    return buffer;
}

template<class T>
typename Vector<T>::iterator Vector<T>::end()
{
    return buffer + size();
}

template<class T>
T& Vector<T>::front()
{
    return buffer[0];
}

template<class T>
T& Vector<T>::back()
{
    return buffer[my_size - 1];
}

template<class T>
void Vector<T>::Push_back(const T & v)
{
    if (my_size >= my_capacity)
        reserve(my_capacity +5);
    buffer [my_size++] = v;
}

template<class T>
void Vector<T>::pop_back()
{
    my_size--;
}

template<class T>
void Vector<T>::reserve(unsigned int capacity)
{
    if(buffer == 0)
    {
        my_size = 0;
        my_capacity = 0;
    }    
    T * Newbuffer = new T [capacity];
    //assert(Newbuffer);
    unsigned int l_Size = capacity < my_size ? capacity : my_size;
    //copy (buffer, buffer + l_Size, Newbuffer);

    for (unsigned int i = 0; i < l_Size; i++)
        Newbuffer[i] = buffer[i];

    my_capacity = capacity;
    delete[] buffer;
    buffer = Newbuffer;
}

template<class T>
unsigned int Vector<T>::size()const//
{
    return my_size;
}

template<class T>
void Vector<T>::resize(unsigned int size)
{
    reserve(size);
    my_size = size;
}

template<class T>
T& Vector<T>::operator[](unsigned int index)
{
    return buffer[index];
}  

template<class T>
unsigned int Vector<T>::capacity()const
{
    return my_capacity;
}

template<class T>
Vector<T>::~Vector()
{
    delete[ ] buffer;
}
template <class T>
void Vector<T>::clear()
{
    my_capacity = 0;
    my_size = 0;
    buffer = 0;
}

Answer 2

reserve関数を修正する必要があることに加えて、copy-constructorとcopy-assignment-operatorには興味深い問題があります。

Vector<T> t1 = t2;

これにより、t1の容量はt2の容量（変数）と等しくなりますが、t1の実際の容量はt2のサイズになります。したがって、copy-constructor/Assignment-operatorの後で要素をベクトルにプッシュし始めると、バッファオーバーランの問題が発生します。

あなたはそれをに変更する必要があります

template<class T>
Vector<T>::Vector(const Vector<T> & v)
{
    my_size = v.my_size;
    my_capacity = v.my_capacity;
    buffer = new T[my_capacity];
    memcpy(buffer, v.buffer, my_size * sizeof(T));  
}

または（小さい配列にサイズ変更できるようにする場合）

template<class T>
Vector<T>::Vector(const Vector<T> & v)
{
    my_size = v.my_size;
    my_capacity = v.my_size;
    buffer = new T[my_size];
    memcpy(buffer, v.buffer, my_size * sizeof(T));  
}

Answer 3

多分それはこのタイプミスですか？

Vector<T>::Vector(unsigned int size, const T & initial)
{
    my_size-size; 

Answer 4

あなたの「予備」は壊れています。ローカルバッファに別の変数名を使用します。

Answer 5

このコードは私のためにコンパイルされませんでした。 Clangは、114行目（back（）の実装）が「size」が呼び出されることを期待していると不満を漏らしました。

この行は「returnbuffer [size（）-1];」を意図したものだと思います。

また、このコンストラクターの実装に関する警告も表示します。templateVector :: Vector（unsigned int size、const T＆initial）

最初の行はおそらく「my_size = size;」であるはずでした。 （このコンストラクターの）最後の行はおそらく削除する必要があります。

次に、209行目でアサーションに失敗します。assert（v3.size（）== 1）;

これによりかなりの数のワームが開かれますが、明らかな問題は次の行のresize（）にあります： "size = size;"これはおそらく「my_size = size;」を意味します。

この変更により、231行目から呼び出されたPush_back（）にある121行目でクラッシュします "v6.Push_back（100）;"

これはreserve（）の問題のために失敗しています。メンバー変数と同じ名前のローカル変数「バッファ」を作成しています。名前をtemp_bufferに変更しましょう。注：実行時エラーをassert（）しないでください。 assert（）は論理エラー用です。このassert（）は失敗することはありません。 newは0を返すことはありません。代わりにスローします。

Reserved（）で明らかな修正を行った後（他の問題があります）、main（）のlin3 208から呼び出されたresize（）からの呼び出しでreserve（）のcopy（）でクラッシュしています。 "v3.resize（ 1）; "。

容量を減らしているときに、リザーブが実際に新しいバッファを割り当てていることがわかります。これは、パフォーマンスの低下と信頼性の低下の両方です（メモリ割り当てが失敗する可能性があります）。しかし、それでもクラッシュしてはならないので、明らかな設計上の欠陥に対処せずにクラッシュを防止しようとします。

コンテナに存在するすべてのアイテムを新しく割り当てられた配列にコピーしているため、クラッシュが発生しています。これは、容量を増やす必要がある場合にのみこれを行う場合は正しいでしょうが、この場合、新しい容量が保持できるよりも多くのアイテムがあります。 my_sizeがその値より大きい場合、コードはmy_sizeを新しい容量に設定する必要があります。

これで、テストコードは「SUCCESS」を報告します。

ただし、このコードにはまだ多くの問題があります。

最大の問題の1つは、割り当てられた配列で初期化されていないメモリを使用していないことです。これを行うことは、std :: vectorの標準で要求されており、パフォーマンスと信頼性の両方の利点があります。しかし、それはコードを複雑にするので、これは明らかに知的運動であるために私たちが一緒に暮らすことができる近道かもしれません。

コンストラクター：初期化構文を使用してデータメンバーを初期化します。

コピーコンストラクターと初期値からのコンストラクターを使用すると、ループした割り当てのいずれかが例外をスローした場合に、割り当てられた配列をリークします。

代入演算子は、「my_size」ではなく「my_capacity」サイズの新しいバッファーを割り当てる必要がありますが、右側のオブジェクトのサイズが「this」オブジェクトより大きくない場合は、次のようにすべきではないという明らかな最適化があります。まったく割り当てます。

代入演算子で新しい配列の割り当てに失敗した場合は、すでにバッファーが削除されているため、最終的に（Vectorオブジェクトが破棄されたときに）バッファーが二重に削除され、その前にすべての地獄が崩壊する可能性があります。

Push_back（）では、標準のパフォーマンス保証をサポートするために、既存の容量の一定の割合で容量を増やす必要があります。たとえば、「reserve（my_capacity * 1.5）;」のようになります。