c++ - 模板c++的模板

    #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;
    }

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


  错误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（const unsigned int size）
。
感谢您的所有帮助。

最佳答案

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

它确实定义了一个名为add的方法，所以也许您打算调用它？即array_of_arrays.add(0, da);代替array_of_arrays[0] = da;。

但是，简单地在类中定义operator[]可能更惯用。