如何將多個模板傳遞到一類

Question

我有需要傳遞給它的兩個獨立的模板類：

template <typename T> 
class AwesomeClass 
{ 
    TList *theList; 
    typename list <T>::iterator theiterator; 

    public: 
    template <typename TList> 
    AwesomeClass(TList &list) 
    { 
    theList = &list; 
    }; 
} 

正如你可能知道它本質上提供的包裝爲STL（我必須這樣做這條路）。理想情況下，我不希望通過在對象的聲明像這樣通過兩個模板：

typedef AwesomeClass<int, BaseClass<int> > BaseClassIteratorInt; 

以及與此寧願脫身：

typedef BaseClass<int> ListFromBaseClassInt; 
typedef AwesomeClass<int> BaseClassIteratorInt; 
BaseClassIteratorInt newInt(ListFromBaseClassInt) 

（這是上面的代碼的意思做）

不過，我不斷收到錯誤：

error C2143: syntax error : missing ';' before '*'

對於變量從TList *的thelist。

我需要爲ctor提供TList的類型，有沒有辦法做到這一點？

額外步驟：

好吧，我現在有格式的代碼：

template <typename Container> 
class AwesomeClass 
{ 
    public: 
    typedef typename std::common_type<Container> value_type; 

    bool firstUse; 

    Container *theList; 
    typename Container::iterator theIterator; 
    explicit AwesomeClass(Container &list):theList(&list) 
    { 
    }; 
} 

這是使用common_type繞過編譯器故障而其停止生產線

typedef typename Container::value_type value_type; 

編譯由於value_type不是全局名稱空間的一部分。

但我有一個編譯器錯誤的編譯器，編譯器聲稱它需要一個';'在它之前。

任何人都可以看到什麼是錯的？

Answer 1

它聽起來像你需要一個前向聲明TList：你使用if之前聲明它，所以編譯器不知道它。

Answer 2

您需要聲明TList作爲模板參數，然後才能在其他聲明中使用它。

template <typename TList, typename T> 
class AwesomeClass { 
    TList* theList; 

    /* ... */ 
}; 

而且你不需要申報第二個模板參數T，而不是得到的類型，像這樣：

using value_type = typename TList::value_type; 

其次，你不必使用模板扣在構造函數。

// template <typename TList> // Unnecessary if the template parameter is already declared 
AwesomeClass(TList& list) { 
    theList = &list; 
} 

第三，您已將分號放在ctor之後，而不是放在類作用域的末尾。

/* ... */ 

AwesomeClass(TList& list) { 
    theList = &list; 
    }; // Unnecessary to put semicolon after function definitions. 
} // Although, you need semicolon here. 

它看起來像你希望能夠創造AwesomeClass對象時，自動推斷類型的模板參數。但是，類模板參數可以自動推算出而不是，只有函數模板可以做到這一點。

要完成模板參數的自動扣除，您可以創建一個函數，該函數返回帶有推導參數的AwesomeClass，例如，

template <typename TList> 
auto make_awesome(TList& list) -> AwesomeClass<TList, typename TList::value_type> { 
    return {list}; 
} 

編輯：

如果你想要的是一個存儲指向任何類型的std::list那麼所有你需要演繹的是元素類型的類。但是，你只能存儲指向容器的指針，而不是例如。一個指向std::vector的指針。

template <typename T> 
class AwesomeClass { 
public: 
    AwesomeClass(std::list<T>& c) { 
     c_ = &c; 
    } 
private: 
    std::list<T>* c_; 
    typename std::list<T>::iterator iter_; 
}; 

int main() { 
    typedef AwesomeClass<int> BaseClassIteratorInt; 
    BaseClassIteratorInt b{l}; 
} 

Answer 3

隨着

template <typename T, typename TList> class AwesomeClass 
class AwesomeClass 
{ 
    TList *theList; 
    typename list<T>::iterator theiterator; 

public: 
    explicit AwesomeClass(TList &list) : theList(&list) {} 
}; 

你可以做什麼在建設推斷類型是一個免費的功能：

template<typename T, typename TList> 
AwesomeClass<T, TList> make_AwesomeClass(TList& tlist) 
{ 
    return AwesomeClass<T, TList>(tlist); 
} 

調用這種方式：

auto awesomeClass = make_AwesomeClass<int>(mylist); 

Answer 4

我不t嗨，你需要兩個模板params。

template <class Container> 
class AwesomeClass { 
public: 
    // you can use this typedef to access the value type 
    typedef typename Container::value_type value_type; 
    AwesomeClass(Container &list): theList(&list) {} 
private: 
    Container *theList; 
    typename Container::iterator theiterator; 
}; 

int main() { 
    // you can use typedef if you like 
    typedef std::list<int> intList; 
    intList list{1, 2, 3}; 
    AwesomeClass<intList> newInt(list); 
}