3

我想使用以下构造模板化“第一”类型的 std::pair

template <typename T>
struct TPair
{
typedef std::pair <T, short> Type;
};

并创建此类对的向量。

template <typename T>
struct TPairs
{
typedef std::vector <TPair <T> > Type;
};

但是这段代码似乎被搞砸了，很不舒服：

TPair <double> ::Type my_pair (1.0, 0 ); //Create pairs
TPair <double> my_pair2 (1.0, 0 ); //Create object, needs a constructor

TPairs <double> ::Type pairs; //Create vector
TPairs <double> pairs2; //Create object

pairs.push_back(my_pair); //Need a constructor
pairs2.push_back(my_pair); //No push_back method for the structure...
....

有没有更简单舒适的解决方案？

4

4 回答 4

4

听起来你想要一个“模板别名”，它显然是用 C++11 添加到标准中的。您的情况下的语法类似于：

template <typename T>
using TPair = std::pair<T,short>;

template <typename T>
using TPairs = std::vector<TPair<T>>;

[免责声明：我没有尝试过，所以这可能是胡说八道。]

于 2012-01-22T11:34:00.843 回答
3 
template <typename T>
struct TPairs
{
  typedef std::vector <TPair <T> > Type;
};

这里有一个问题：您正在创建一个是 的向量的类型TPair<T>，这实际上不是您想要的。你想要一个 的向量TPair<T>::Type。

template <typename T>
struct TPairs
{
  typedef std::vector <typename TPair <T>::Type > Type;
};

至于您的用例，请记住您创建的这两个结构只是为了模拟模板 typedef，您根本不应该实例化它们，只需使用它们的Type成员 typedef。所以：

TPair <double> ::Type my_pair (1.0, 0 ); // Good, creates a std::pair
TPair <double> my_pair2 (1.0, 0 ); // Not good, does not create an std::pair


TPairs <double> ::Type pairs; //Good, creates a vector
TPairs <double> pairs2;       //Not good, doesn't create a vector

pairs.push_back(my_pair);   // Ok, does what you mean
pairs2.push_back(my_pair);  // Can't compile, the `TPairs` struct ins't a vector
于 2012-01-22T11:45:32.490 回答
1

为什么不简单地使用继承？例如：

template <typename T>
struct TPair : public std::pair< T, short >{};

template <typename T> 
struct TPairs : public std::vector< TPair< T > >  {};
于 2012-01-22T12:18:32.913 回答
0

如果您喜欢冒险，您可以从您想要模板化的类型继承并提供适当的构造函数。:)

#include <utility> // forward

template<class T>
struct TPair
  : public std::pair<T, short>
{
private:
  typedef std::pair<T, short> base;

public:
  template<class U>
  TPair(U&& u, short s) // forwarding ctor
    : base(std::forward<U>(u), s) {}

  TPair(TPair const& other) // copy ctor
    : base(static_cast<base const&>(other)) {}

  TPair(TPair&& other) // move ctor
    : base(static_cast<base&&>(other)) {

  // and assignment operators... I'll leave those as an exercise
};

// and the same for TVector... again, I'll leave those as an exercise. :>
于 2012-01-22T12:26:49.187 回答