1

このクラスは中間課題用です。ベクトルのように機能する動的配列です。問題は、新しいインデックスが配列に追加されたときにデストラクタが呼び出されると (プログラムの終了時に)、プログラムが例外をスローし、dgbheap.c というファイルを取得することです。デストラクタでのみオリジンを削除すると発生します。

DynamicArray.h

    #ifndef DYNAMICARRAY_H
#define DYNAMICARRAY_H
    #include <new>
    #include <cstdlib>
    using namespace std;

    template <class T>
    class DynamicArray
    {
        private:
            T *origin;
            T *allocator;
            int size;
            int current;


        public:
            DynamicArray();
            DynamicArray(int);
            DynamicArray(const DynamicArray&);
            ~DynamicArray();
            void add(int);
            void empty();
            void remove(int);
            int getSize();
            T &operator[](const int&);
            const T operator=(const DynamicArray&);
            void put(T&);
            void put(T);
    };
    template <class T>
    DynamicArray<T>::DynamicArray()
    {
        origin = new T[5];
        allocator = NULL;
        size = 5;
        current = 0;
    }

    template <class T>
    DynamicArray<T>::DynamicArray(int s)
    {
        size = s;

        try
        {
            origin = new T[s];
            allocator = NULL;
            current = 0;
        }
        catch(bad_alloc)
        {
            cout << "Error: Bad memery allocation\n";
            exit(EXIT_FAILURE);
        }
    }

    template <class T>
    DynamicArray<T>::DynamicArray(const DynamicArray& obj)
    {
        empty();
        for(int counter = 0; counter < obj.size - 1; counter++)
        {
            origin[counter] = obj.origin[counter];
        }
    }

    template <class T>
    DynamicArray<T>::~DynamicArray()
    {
        delete [] origin;
        delete [] allocator;
    }

    template <class T>
    void DynamicArray<T>::add(int size)
    {
        allocator = new T[size];
        for(int counter = 0; counter < this-> size - 1; counter++)
        {
            allocator[counter] = origin[counter];
        }
        delete [] origin;
        origin = new T[size];
        this->size = this->size + size;

        for(int counter = 0; counter < this->size - 1; counter++)
        {
            origin[counter] = allocator[counter];
        }
        allocator = NULL;
    }


    template <class T>
    void DynamicArray<T>::empty()
    {
        if(size >= 0)
            delete [] origin;
    }




    template <class T>
    int DynamicArray<T>::getSize()
    {
        return size;
    }

    template <class T>
    T &DynamicArray<T>::operator[](const int &index)
    {
        return origin[index];
    }


    template <class T>
    const T DynamicArray<T>::operator=(const DynamicArray &obj)
    {
        size = obj.size;
        delete [] origin;

        origin = new T[size];

        for(int counter = 0; counter < size; counter++)
            *(origin + counter) = *(obj.origin + counter);

        return *origin;
    }

    template <class T>
    void DynamicArray<T>::put(T &obj)
    {
        if(current == size - 1)
        {

            add(1);
            origin[size - 1] = obj;
            ++current; 
        }
        else
        {
            origin[current] = obj;
            ++current;
        }
    }

    template <class T>
    void DynamicArray<T>::put(T obj)
    {
        if(current > size - 1)
        {

            add(1);
            origin[size - 1] = obj;
            ++current; 
        }
        else
        {
            origin[current] = obj;
            ++current;
        }
    }


    template <class T>
    void DynamicArray<T>::remove(int location)
    {
        allocator = new T[size - 1];
        int skipper = 0;

        for(int counter = 0; counter < size - 1; counter++, skipper++)
        {
            if(counter != location)
                allocator[counter] = origin[skipper]
            else if(counter == location)
            {
                ++skipper;
                allocator[counter] = origin[skipper]
                continue;
            }
        }
    }


    #endif // !DYNAMICARRAY_H

main.cpp

    #include <iostream>
    #include <string>
    #include "DynamicArray.h"

    using namespace std;

    int main()
    {
        DynamicArray<int> a(5);
        a.put(21);
        a.put(22);
        a.put(30);
        a.put(58);
        a.put(87);
        a.put(87);

        cout << a[0] << endl;
        cout << a[1] << endl;
        cout << a[2] << endl;
        cout << a.getSize() << endl;

        system("pause");
        return 0;
    }
4

2 に答える 2

1

コピー コンストラクターが初期化されていませんorigin。次のようになります。

template <class T>
DynamicArray<T>::DynamicArray(const DynamicArray& obj)
  : origin(new T[obj.size]),
    size(obj.size),
    allocator(NULL),
    current(obj.current)
{
    for(int counter = 0; counter < obj.size; counter++)
    {
        origin[counter] = obj.origin[counter];
    }
}

あなたの方法にも注意してくださいempty()：

template <class T>
void DynamicArray<T>::empty()
{
    delete [] origin;
    origin = NULL;
    size = 0;
}
于 2012-10-08T00:39:49.513 に答える
1

問題は次のとおりです。

テンプレート void DynamicArray::add(int サイズ);

同じ名前の this->size と引数 size を持つサイズ変数を混同しています

修正されたメンバー関数は次のとおりです。

template <class T>
void DynamicArray<T>::add(int size)
{
  allocator = new T[this->size]; // was just 'size', needs to be old size
  for(int counter = 0; counter < this->size - 1; counter++)
  {
    allocator[counter] = origin[counter];
  }
  delete [] origin;
  this->size = this->size + size; // was down one line
  origin = new T[this->size]; // was 'size'. ie old size, not new size set in line above

  for(int counter = 0; counter < this->size - 1; counter++)
  {
    origin[counter] = allocator[counter];
  }
  allocator = NULL;
}
于 2012-10-08T00:51:13.390 に答える