Шаблона шаблон 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: binary '[' : ' DynamicArray<T> ' does not define this operator or a conversion to a type acceptable to the predefined operator

я добавил этот

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

но subequently я получил недопустимую ошибку размера выделения во время выполнения. Я пытаюсь попробовать и понять, что проблема где-то в этой области

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