執行向量時對二進制表達式的無效操作數

Question

在一個分配中，我被要求創建自己的Vector<T>,Mathvector<T>（它繼承自向量）和Polynomial類類型。 我收到以下錯誤，無法找出原因。

MathVector.h:37:32: error: invalid operands to binary expression ('mathVector<double>' and 'mathVector<double>') 
       if (this[j]>this[j+1]) 

排序函數在「mathVector.h」中，其目標是按照升序或降序排列向量。

這是 「MathVector.h」 的錯誤部分：

void sort(int index) { 
     int i,j; 
     int n=this->get_size(); 
     if (index==1) { 
      for (i=0; i<n-1; i++) 
       for (j=0; j<n-i-1; j++) { 

        if (this[j]>this[j+1]) { 
         T temp; 
         temp=this[j+1]; 
         this[j+1]=this[j]; 
         this[j]=temp; 
        } 
       } 
     } 
     else { 
      for (i=0; i<n-1; i++) 
       for (j=0; j<n-i-1; j++) { 
        if (this[j]<this[j+1]) { 
         T temp; 
         temp=this[j+1]; 
         this[j+1]=this[j]; 
         this[j]=temp; 
        } 
       } 
     } 
     return; 
    } 

這是 「vector.h」：

template<class T> 
class Vector { 
private: 
    int _size; 
    int _capacity; 
    T *_data; 

    static T *allocate(int size) { 
     return static_cast<T *>(malloc(sizeof(T) * size)); 
    } 

    static void copyRange(T *begin, T *end, T *dest) { 
     while (begin != end) { 
      new((void *) dest) T(*begin); 
      ++begin; 
      ++dest; 
     } 
    } 

    static void deleteRange(T *begin, T *end) { 
     while (begin != end) { 
      begin->~T(); 
      ++begin; 
     } 
    } 

public: 

    Vector() { 
     _size = 0; 
     _capacity = 0; 
     _data = 0; 
    } 

    ~Vector() { 
     deleteRange(_data, _data + _size); 
     free(_data); 
    } 

    Vector(const Vector &obj) { 
     this->_size = obj.get_size(); 
     this->_data = obj.get_data(); 
     this->_capacity = obj.get_capacity(); 
    } 

    void insert(const T &value) { 
     if (_size != _capacity) { 
      new((void *) (_data + _size)) T(value); 
      ++_size; 
      return; 
     } 
     int newCapacity; 
     if (_capacity == 0) { newCapacity = 1; } 
     else (newCapacity = _capacity * 2); 
     T *newData = allocate(newCapacity); 
     copyRange(_data, _data + _size, newData); 
     new((void *) (newData + _size)) T(value); 
     deleteRange(_data, _data + _size); 
     free(_data); 
     _data = newData; 
     _capacity = newCapacity; 
     ++_size; 
    } 

    void resize(int index) { 
     if (index == _capacity) { return; } 
     else if (index > _capacity) { _capacity = index; } 
     else { 
      _capacity = index; 
      if (index < _size) { 
       deleteRange(_data + index, _data + _size); 
       _size = index; 
      } 
     } 
    } 

    T &operator[](int index) { 
     T empty; 
     if ((index < 0) || (index >= _size)) { 
      cout<<"Wrong Index"; 
      return empty; 
     } 
     return _data[index]; 
    } 

    const T & 
    operator[](int index) const { 
     T empty; 
     if ((index < 0) || (index >= _size)) { 
      cout<<"Wrong Index"; 
      return empty; 
     } else return _data[index]; 
    } 

    Vector &operator=(const Vector &other) { 
     this->_size = other.get_size(); 
     this->_data = other.get_data(); 
     this->_capacity = other.get_capacity(); 
     return *this; 
    } 


    friend ostream &operator<<(ostream &os, const Vector &other) { 
     os << "Size: " << other._size << " | Capacity: " << other._capacity << " | "; 
     int i; 
     for (i = 0; i < other._size; i++) { 
      os << other[i] << ","; 
     } 
     return os; 
    } 

    T *begin() const { 
     return _data; 
    } 

    T *end() const { 
     return _data + _size; 
    } 

    int get_size() const { 
     return _size; 
    } 

    T* get_data() const { 
     return _data; 
    } 

    int get_capacity() const { 
     return _capacity; 
    } 
}; 

Answer 1

this[j]是幾乎沒有的權利要做的事。它只能是正確的，如果*this碰巧是一個數組中的子對象，並且在它之後至少有一個兄弟姐妹。 this[j]相當於*(this + j)。正如你所看到的，它在*this後取消了一個指向j兄弟的指針。

我懷疑，你打算通過調用Vector::operator[]來訪問緩衝區的元素。你可以通過首先取消指針來達到目的：(*this)[j]。