C++ tuple\u大小和tuple中的固有类？

我有以下代码：

class TR_AgentInfo : public tuple<
                              long long,         //AgentId
                              string,         //AgentIp
                              >
{
public:
TR_AgentInfo() {}
TR_AgentInfo(
  const long long& AgentId,
  const string& AgentIp,
   )
{
    get<0>(*this) = AgentId;
    get<1>(*this) = AgentIp;
}

long long getAgentId() const { return get<0>(*this); }
void setAgentId(const long long& AgentId) { get<0>(*this) = AgentId; }

string getAgentIp() const { return get<1>(*this); }
void setAgentIp(const string& AgentIp) { get<1>(*this) = AgentIp; }
};

class TR\u AgentInfo:公共元组<
long long，//AgentId
字符串，//AgentIp
>
{
公众：
TR_AgentInfo（）{}
TR_AgentInfo(
康斯特朗和阿根蒂德，
常量字符串和代理提示，
)
{
get（*this）=AgentId；
获取（*此）=提示；
}
long getAgentId（）常量{return get（*this）；}
void setAgentId（const long&AgentId）{get（*this）=AgentId；}
字符串getAgentIp（）常量{return get（*this）；}
void setAgentIp（const string&AgentIp）{get（*this）=AgentIp；}
};

现在我想使用以下代码：

int count = tuple_size<TR_AgentInfo>::value;

int count=tuple\u size:：value；

但是gcc给出了这个错误：

error: incomplete type std::tuple_size<TR_AgentInfo> used in nested name specifier

错误：嵌套名称说明符中使用了不完整的类型std:：tuple\u size

---

现在我能做什么呢？

如果您有一个

TR\u AgentInfo

的实例，您可以使用函数模板类型推断使其更友好，如下所示：

template <typename... T>
std::size_t get_tuple_size(std::tuple<T...> const &)
{
  return sizeof...(T);
}

---

否则，您需要使用适当的元编程来获取基类，但工具是可用的。

如果您只想让您的一个类使用

std:：tuple\u size

，您只需提供一个专门化：

namespace std
{
  template<> struct tuple_size<TR_AgentInfo>
  {
    static const size_t value = 2;

    // alternatively, `tuple_size<tuple<long long, string>>::value`
    // or even better, `tuple_size<TR_AgentInfo::tuple_type>::value`, #1
  };
}

名称空间std
{
模板结构元组大小
{
静态常量大小\u t值=2；
//或者，`tuple_size:：value`
//或者更好的是，`tuple_size:：value`，#1
};
}

明确允许您将专门化添加到命名空间

std

，这正是针对您这样的情况

---

如果您的实际类本身是模板化的，您可以简单地用适当的构造替换

2

。例如，对于建议#1，您可以为类添加

tuple_type

的typedef。有很多方法可以剥这只猫的皮。

但实际的问题是什么？看起来元组的大小总是2，那为什么是体操呢？我把代码简化得太多了！这些代码将由我自己制作的TemplateGenerator生成，然后将在另一个非常通用的模板库中使用。为什么不将元组大小存储为静态类常量？或者键入定义元组以便以后使用

std:：tuple\u size:：value

？我希望子类的行为与元组完全相同。如果您的类已完成，请说

namespace std{template struct tuple\u size{static const size\u t value=2；}

。明确允许向名称空间添加专门化。我不想在基类中得到它。我需要使用tuple_sizey，你要的是一个类的tuple_大小，而这个类不是tuple。基类是一个元组。您可以得到该基类的元组大小。或者我遗漏了什么？我想得到子类的元组大小。你认为有什么区别？在什么意义上，这里的子类是与基类不同的元组？毕竟，您使用的是公共继承来显式表示IS-A关系，即说

TR\u AgentInfo

是一个

元组。
namespace std
{
  template<> struct tuple_size<TR_AgentInfo>
  {
    static const size_t value = 2;

    // alternatively, `tuple_size<tuple<long long, string>>::value`
    // or even better, `tuple_size<TR_AgentInfo::tuple_type>::value`, #1
  };
}