C++ 如何在类中使用成员函数专门化？ #包括 #包括 使用名称空间std； 结构Uid{ typedef int类型； }; 结构名{ typedef字符串类型； }; 结构年龄{ typedef int类型； }; 模板 阶级人士{ 私人： typename T1:：type val1； typename T2:：type val2； typename T3:：type val3； //在这里添加一个get函数 } }; int main（）{ 人,； people.get（）；//使其生效 }

这是我的代码，我想在类中添加一个get函数，使函数调用get in main进行验证。

---

我试图在类中添加一个tempalte get及其专门化版本，但这是一种无效方法，编者说：在非名称空间作用域“class People”中显式专门化。有人说此方法在vs中有效，但它违反了标准。

您需要一个模板化get（）成员函数可以使用的帮助器类。助手类可以位于命名空间范围内

#include <iostream>
#include <string>

using namespace std;

struct Uid {
  typedef int type;  
};

struct Name {
  typedef string type;
};


struct Age {
  typedef int type;
};


template <class T1, class T2, class T3>
class People {
private:
  typename T1::type val1;
  typename T2::type val2;
  typename T3::type val3;
  //add a get function here
  }
};


int main() {
  People<Uid, Name, Age> people;
  people.get<Uid>(); //make this validate
}

#包括
#包括
使用std:：string；
使用std：：cout；
结构Uid{
typedef int类型；
};
结构名{
typedef字符串类型；
};
结构年龄{
typedef int类型；
};
//助手类，可以专门用于获取不同的人员成员。
模板结构PeopleGet；
模板
阶级人士{
公众：
人(
typename T1:：type const&val1，
typename T2:：type const&val2，
typename T3:：type const&val3
)
：val1（val1），
val2（val2），
val3（val3）
{
}
模板typename U:：type get（）
{
return PeopleGet:：get（*this）；
}
私人：
typename T1:：type val1；
typename T2:：type val2；
typename T3:：type val3；
模板好友类PeopleGet；
};
模板
结构PeopleGet{
静态typename T1:：type get（const-People&People）{return-People.val1；}
};
模板
结构PeopleGet{
静态typename T2:：type get（const-People&People）{return-People.val2；}
};
模板
结构PeopleGet{
静态typename T3:：type get（const-People&People）{return-People.val3；}
};
int main（）
{
人（5，“姓名”，47）；
这对我有用吗
#include <iostream>
#include <string>

using std::string;
using std::cout;

struct Uid {
  typedef int type;
};

struct Name {
  typedef string type;
};

struct Age {
  typedef int type;
};

// Helper class that can be specialized to get different members of People.
template <class P, class U> struct PeopleGet;


template <class T1, class T2, class T3>
class People {
public:
  People(
    typename T1::type const& val1,
    typename T2::type const& val2,
    typename T3::type const& val3
  )
  : val1(val1),
    val2(val2),
    val3(val3)
  {
  }

  template <class U> typename U::type get()
  {
    return PeopleGet<People<T1,T2,T3>,U>::get(*this);
  }
private:
  typename T1::type val1;
  typename T2::type val2;
  typename T3::type val3;

  template <class P,class U> friend class PeopleGet;
};


template <class T1,class T2,class T3>
struct PeopleGet<People<T1,T2,T3>,T1> {
  static typename T1::type get(const People<T1,T2,T3> &people)  { return people.val1; }
};

template <class T1,class T2,class T3>
struct PeopleGet<People<T1,T2,T3>,T2> {
  static typename T2::type get(const People<T1,T2,T3> &people)  { return people.val2; }
};

template <class T1,class T2,class T3>
struct PeopleGet<People<T1,T2,T3>,T3> {
  static typename T3::type get(const People<T1,T2,T3> &people)  { return people.val3; }
};


int main()
{
  People<Uid, Name, Age> people(5,"name",47);
  cout << people.get<Uid>() << "\n";
  cout << people.get<Name>() << "\n";
  cout << people.get<Age>() << "\n";
  return 0;
}