嵌套模板和構造

Question

編輯： 請注意，我在這裏最終目的不是具有一流的工作，僅僅是學習更多有關模板:-)

假設你有一個實現載體的模板類：

template <typename T> 
class Vector 
{ 
    public: 
     Vector(size_t dim) { 
      dimension = dim; 
      elements = new T[dim]; 
     } 
     /* Here more stuff, like operator[] etc... */ 
    private: 
     size_t dimension; 
     T * elements; 
} 

並且假設你想用它構建一個矩陣。矩陣僅僅是向量的載體，因此可以設計如下：

template <typename T> 
class Matrix : public Vector<Vector<T> > 
{ 
    /*...*/ 
} 

這裏來麻煩：在構造函數中我需要提供行和列作爲參數傳遞給內部的載體。它應該是這樣的

template <typename T> 
Matrix<T>::Matrix (size_t ncols, size_t nrows) 
     : Vector<Vector<T> > /* Here I need to specify size for both 
           * internal and external vectors */ 
{ 
} 

很明顯，我不能寫Vector<Vector<T>(nrows)>(ncols)，但這就是我所需要的！

一個可能的解決方案將包括在模板中大小：

template <typename T, size_t N> 
class Vector 
{ 
    public: 
     Vector() { 
      elements = new T[N]; 
     } 
     /* Here more stuff, like operator[] etc... */ 
    private: 
     T * elements; 
} 

因此，我將不再需要構造函數的參數，但是這也迫使我寫的是一個到處模板（由exmample笨拙的代碼，每個函數使用一個Vector應被聲明爲

template <typename T, size_t N> 
void foo (Vector<T,N> &vec) {...} 

你有更好的辦法呢？

編輯：

作爲解決方案，我從Fooz先生和chubsdad的帖子中獲得靈感。這就是我解決問題的方法：

/* The RowAccess class is just an array wrapper which raises an exception 
* if you go out of bounds */ 
template <typename T> 
class RowAccess 
{ 
    public: 

     RowAccess (T * values, unsigned cols) : values(vals), cols(c) {} 

     T & operator[] (unsigned i) throw (MatrixError) { 
      if (i < cols) return values[i]; 
      else throw MatrixError("Column out of bound"); 
     } 

    private: 
     T * values; 
     unsigned cols; 
}; 

template <typename T> 
class Matrix 
{ 
    public: 
     Matrix (unsigned rows, unsigned cols) {...} 
     virtual ~Matrix() {...} 

     RowAccess<T> operator[] (unsigned row) { 
      if (row < rows) return RowAccess<T>(values + cols * row, cols); 
      else throw MatrixError("Row out of boundary"); 
     } 

    private: 
     unsigned rows; 
     unsigned cols; 
     T * values; 
}; 

非常感謝大家！

Answer 1

這不是你問的問題，但是矩陣可能更好地實現爲單個線性向量，您可以在其中提供執行索引的高級訪問方法（例如elmLoc = row * ncols + col ）。這樣你就不需要創建和初始化矢量矢量。你也不需要擔心不小心有一些不同大小的內部向量。我曾經使用的所有密集矩陣實現都使用單個線性向量作爲底層實現。

Answer 2

這取決於你對Vector（和Matrix）類的期望。

要麼你想在運行時確定大小，在這種情況下，我會建議添加一個resize()函數，這將允許你在構造函數中調整Vector的大小。

template <typename T> 
class Vector 
{ 
    public: 
     Vector(size_t dim) { 
      dimension = dim; 
      elements = new T[dim]; 
     } 
     Vector() : dimension(0), elements(0) {} // you need default constructor 
     void resize(size_t dim) { // note: this could be implemented a lot better 
      T* new_elements=new T[dim]; 
      for(int i=0; i<dim && i<dimension; i++) 
      new_elements[i]=elements[i]; 
      delete [] elements; 
      elements=new_elements; dimension=dim; 
     } 
     /* Here more stuff, like operator[] etc... */ 
    private: 
     size_t dimension; 
     T * elements; 
} 

然後你會調整你的Vectors在一個循環中Matrix構造。

如果你想在編譯時確定你的向量或矩陣的大小，最好的辦法可能是按照你的建議使用模板非類型參數。

Answer 3

使用投放新的這樣的（埋在uninitialized_fill調用後面）

template <typename T> 
class Vector 
{ 
    public: 
     Vector(size_t dim, T const& c = T()) { 
      dimension = dim; 
      elements = 
       static_cast<T*>(operator new(sizeof(T) * dim)); 
      std::uninitialized_fill(elements, elements + dim, c); 
     } 
     /* Here more stuff, like operator[] etc... */ 
    private: 
     size_t dimension; 
     T * elements; 
}; 

然後就可以調用與Matrix::Vector(ncols, Vector<T>(nrows))構造函數（你不需要重複的外部矢量的說法，因爲Vector指因爲你從外部向量繼承了，所以你需要確保在析構函數中執行operator delete(elements)之前手動調用析構函數。

您可能還想將矢量作爲成員嵌入，我可能會更喜歡此矢量，因爲我想象不一定所有外部矢量的操作對矩陣都有意義。然後初始化看起來像m(ncols, Vector<T>(nrows))。

---

應當指出的是，std::vector也可用於本

template <typename T> 
class Vector 
{ 
    public: 
     Vector(size_t dim, T const& c = T()):elements(dim, c) 
     { } 
    private: 
     std::vector<T> elements; 
}; 

這是實現，一個簡單而安全的方式，你會得到自動內存管理。

Answer 4

從OO的角度來說，我會投票表決Matrix和vector之間有「有」關係。矩陣有向量，而不是矩陣「是」向量，這意味着矩陣不應該從向量派生。

編輯1：一個小的更正。 「這意味着Matrix不應該從Vector中」公開「。私人繼承可能仍然很好。