模板c++模板

Question

    #include <iostream>

    using namespace std;
    template <typename T>
    class DynamicArray
    {
        T *array;
        unsigned int elements;
        unsigned int size;


    public:
        void expand_array(int extra_size)
        {
            T *new_array= new T[size + extra_size];
            //copy integers from old array
            memcpy(new_array,array,elements*sizeof(T));
            //make 0 the integers from new part of the array
            memset(new_array + size, 0, extra_size * sizeof(T));
            delete [] array;
            array = new_array;
            size += extra_size;
        }
        //constructors
        DynamicArray()
        {
            array = new T[8];
            elements = 0;
            size = 8;
            memset(array,0,size*sizeof(T));
        }
        DynamicArray(const unsigned int  size)
        {
            array= new T[size];
        }
        virtual ~DynamicArray()
        {
            delete [] array;
        }
        void add(T new_element)
        {
            if(elements>=size)
                    expand_array(8);
            array[elements++] = new_element;
        }
        int get (const unsigned int index) const
        {
            if(index< elements)
                    return array[index];
            return -1;
        }
        void add(const unsigned int index, T new_element)
        {
            if(index>size)
                expand_array(index- size +1);
            array[index] = new_element;
            elements = index +1;

        }
        DynamicArray &operator=(DynamicArray &ab)
        {
            elements=ab.elements;
            size=ab.size;
            if (this == &ab)
                return *this;
            delete array;
            if(ab.array)
            {
                array= new T[size];
                memcpy(array,ab.array,elements*sizeof(T));
            }
            else
            {
                array=0;
            }
            return *this;
        }
        DynamicArray(const DynamicArray& source)
        {
            elements=ab.elements;
            size=ab.size;
            if(ab.array)
            {
                array= new T[size];
                memcpy(array,ab.array,elements*sizeof(T));
            }
            else
            {
                array=0;
            }
        }

    };



    int main()
    {
        DynamicArray<int> da(2);
        DynamicArray<int> db(2);

        DynamicArray< DynamicArray<int> > array_of_arrays(2);

        array_of_arrays[0] = da;/ 
        //array_of_arrays[1] = db;
        /*
        da[0]=5;
        da[1]=2;
        db[0]=3;
        db[1]=4;
        cout<<array_of_arrays[0][0]<<endl;
        */
        system("color 0C");
        system("pause");
        return 0;
    }

我需要帮助来理解为什么这会给我一个错误：

error C2676:二进制“[”：“DynamicArray<T>”未定义此运算符或转换为预定义运算符可接受的类型

我加了这个

          T& operator[](unsigned int index)//important to provide this operator
                {
                    if (index > size)
                     {
                            expand_array(index-size);
                    }
                    return array[index];
                }

但是，在运行时，我得到了无效的分配大小错误，我试着尝试一下，并想出问题就在这个区域的某个地方。

                    if(ab.array)
            {
                array= new T[size];
                memcpy(array,ab.array,elements*sizeof(T));
            }

但我不知道为什么会这样。有什么想法吗？

谢谢，我想出来了:其中一个属性在构造函数DynamicArray()中没有被初始化为一个正确的值。谢谢你的帮助。

Answer 1

此错误与模板无关。问题是在[]上使用array_of_arrays运算符。但是，DynamicArray类没有定义operator[]。

它所定义的是一个名为add的方法，所以您可能打算调用它吗？也就是说，array_of_arrays.add(0, da);而不是array_of_arrays[0] = da;。

但是，简单地在类上定义operator[]可能更有习性。

Answer 2

DynamicArray不定义下标运算符。

这通常如下所示：

T& operator[] (unsigned int index)
{
    if (index > size)
    {
        // Handle error
    }
    return array[index];
}