C++下標操作符下屬類矢量

Question

所以我試圖創建一個vec類，我可以在稍後做vec數學。

工作很好，直到我開始實施它的實際程序。

類vecn：

#include <vector> 

template <typename T> 
class vecn 
{ 
public: 
    vecn() { } 
    template <typename... Args> 
    vecn(Args&&... args) 
    { 
     addtovector(args...); 
    } 

    friend std::ostream& operator<<(std::ostream& os, const vecn<T>& obj) 
    { 
     os << "{"; 
     for (auto it = obj.contents.begin(); it < obj.contents.end(); it++) { 
      os << *it; 
      if (it != obj.contents.end() -1) 
      { 
       os << ","; 
      } 
     } 
     os << "}"; 
     return os; 
    } 

    template<typename T> 
    vecn<T>& operator=(const vecn<T>& v) { 
     contents = v.contents; 
     return *this; 
    } 

    unsigned int size() const 
    { 
     return contents.size(); 
    } 

    vecn<T> operator+(const vecn<T>& v1) { 
     vecn<T> v2(); 
     for (unsigned int i = 0; i < size();i++) 
     { 
      v2[i] = v1[i] + this->contents[i]; 
     } 
     return v2; 
    } 

    T& operator[](size_t Index) 
    { 
     if (Index > contents.size() -1) 
     { 
      contents.resize(Index + 1); 
     } 
     return contents.at(Index); 
    } 

    const T& operator[](size_t Index) const 
    { 
     return contents.at(Index); 
    } 

private: 
    template <typename... Args> 
    void addtovector(T& first, Args&&... args) 
    { 
     addtovector(first); 
     addtovector(args...); 
    } 

    void addtovector(T& item) 
    { 
     contents.push_back(item); 
    } 
    std::vector<T> contents; 
}; 

我現在有點用下標操作acceing下屬矢量一個問題，無論我如何設計它，它從來沒有相當的工作。通常會導致一個

Error C2109 subscript requires array or pointer type 

從谷歌搜索錯誤，我應該返回一個指向數組的下標。我這樣做。

有什麼我失蹤了嗎？

主：

vecn<int> v(1,2); 
vecn<int> b(3, 4, 5); 
std::cout << v + b; 

預期輸出：

{4,6,5} 

Answer 1

GCC告訴我到底什麼是錯的：

error: declaration of template parameter ‘T’ shadows template parameter 

（你的賦值運算符）

然後：

warning: pointer to a function used in arithmetic [-Wpointer-arith] 
     v2[i] = v1[i] + this->contents[i]; 

（你聲明v2爲返回vecn<T>功能，刪除括號）

最後，解決您的operator+，因爲它會嘗試訪問和空v2向量的元素訪問超出範圍v1和this->contents的較小者，如果它們的大小不相等的話。

---

在我看來，你已經寫了很多不必要的代碼這麼簡單的事情。你不需要addtovector，只是擴大了參數包，如：

contents{std::forward<Args>(args)...} 

在成員初始化列表

。您根本不需要定義operator=，因此請將其留給編譯器。並嘗試implement operator+ in terms of operator+=。

Answer 2

儘管所有其他的事情你有一個相當令人毛骨悚然的東西在你的代碼

if (Index > contents.size() -1) 

你永遠也不會用算術運算代替邏輯運算符的正確選擇！ std :: vector <> .size（）返回size_t（大多數系統上的無符號長整數），只有你自制的size（）返回int，它不應該是因爲在負數中沒有意義。

現在0-1不會產生一個負值，0表示size_t，但是某種東西huuuge：18446744073709551615（0xffffffffffffffff）。

與大小

所以（）= 0

if (Index > contents.size() -1) 

永遠不會是真實的，你的VEC不會增長，因爲你想，對獲得VEC [0]。只需使用

if (Index >= contents.size()) 

這正是你的意思。

Answer 3

可能你的問題是你使用vecn<T> v2();而不是vecn<T> v2;，但你的解決方案還有其他不好的事情。下面是一些重構：

template <typename T> 
class vecn { 
public: 
    vecn() {} 
    template <typename... Args> 
    vecn(Args&&... args) 
    { 
     addToVector(args...); 
    } 

    friend std::ostream& operator<<(std::ostream& os, const vecn<T>& obj) 
    { 
     os << "{"; 
     for (auto it = obj.contents.begin(); it < obj.contents.end(); it++) { 
      os << *it; 
      if (it != obj.contents.end() - 1) 
       os << ","; 
     } 
     os << "}"; 
     return os; 
    } 

    // you don't need this 
    // template<typename T> 

    // also whole method is unnecessary 
    // vecn<T>& operator=(const vecn<T>& v) 
    // { 
    //  contents = v.contents; 
    //  return *this; 
    // } 

    // use size_t 
    /*unsigned int*/ size_t size() const 
    { 
     return contents.size(); 
    } 

    vecn<T> operator+(const vecn<T>& other) const 
    { 
     vecn<T> result; 
     size_t resultSize = std::max(other.size(), size()); 
     result.contents.reserve(resultSize); 

     for (size_t i = 0; i < resultSize; ++i) { 
      T value = {}; 
      if (i < other.size()) 
       value += other.contents[i]; 
      if (i < size()) 
       value += contents[i]; 

      result.contents.push_back(value); 
     } 

     return result; 
    } 

    T& operator[](size_t index) 
    { 
     return contents.at(index); 
    } 

    const T& operator[](size_t index) const 
    { 
     return contents.at(index); 
    } 

private: 
    template <typename... Args> 
    void addToVector(T& first, Args&&... args) 
    { 
     addToVector(first); 
     addToVector(args...); 
    } 

    void addToVector(T& item) 
    { 
     contents.push_back(item); 
    } 
    std::vector<T> contents; 
};