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

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

错误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）。感谢您的帮助。

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

模板c ++的模板

2 个答案: