模板的模板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; 
    }

我需要理解的幫助，爲什麼這給了我一個錯誤：模板的模板C++

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

某處10

但我不知道爲什麼這樣。任何想法？

謝謝我明白了：其中一個屬性並未初始化爲構造函數 DynamicArray（const unsigned int size）之一的適當值。感謝您的幫助。

來源

2012-02-12 user1203499

似乎相當明確向我，'array_of_arrays（2）'是*不*數組，這是一個'DynamicArray'不定義'[]'運營商。 – 2012-02-12 02:04:00

wtf @「binary'['' – 2012-02-12 02:09:16

@Lightness：'[]'是一個*二元運算符，雖然不是真正的*中綴*運算符，因爲參數出現在括號內。 – 2012-02-12 02:54:55

該錯誤與模板無關。問題是您在array_of_arrays上使用[]運算符。但是DynamicArray類沒有定義operator[]。

它的真正定義是一個名爲add方法，所以也許你的意思是調用呢？即array_of_arrays.add(0, da);而不是array_of_arrays[0] = da;。

但是它可能會更地道簡單地在你的類中定義operator[]。

來源

2012-02-12 02:03:44 sepp2k

DynamicArray沒有定義標運算符。

這通常是這樣的：

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

來源

2012-02-12 02:11:21 Johnsyweb

模板的模板C++

回答

相關問題