-1

这是编译和运行良好的完整代码：

 # include <iostream>

using namespace std;

template<class T> class A { };

template<int i> class B { };

class C {
   public:
      int x;
};

class D {
   public:
      C y;
      int z;
};

template<class T> void f (T)          { cout << "T" << endl; };
template<class T> void f1(const T)    { cout << "const T" << endl; };
temlate<class T> void f2(volatile T) { cout << "volatile T" << endl;  };
template<class T> void g (T*)         { cout << "T*" << endl; };
template<class T> void g (T&)         { cout << "T&" << endl; };
template<class T> void g1(T[10])      { cout << "T[10]" << endl;};
template<class T> void h1(A<T>)       { cout << "A<T>" << endl; };

void test_1() {
   A<char> a;
   C c;

   f(c);   f1(c);   f2(c);
   g(c);   g(&c);   g1(&c);
   h1(a);
}

template<class T>          void j(C(*)(T)) { cout << "C(*) (T)" << endl; };
template<class T>          void j(T(*)())  { cout << "T(*) ()" << endl; }
template<class T, class U> void j(T(*)(U)) { cout << "T(*) (U)" << endl; };

void test_2() {
   C (*c_pfunct1)(int);
   C (*c_pfunct2)(void);
   int (*c_pfunct3)(int);
   j(c_pfunct1);
   j(c_pfunct2);
   j(c_pfunct3);
}

template<class T>          void k(T C::*) { cout << "T C::*" << endl; };
template<class T>          void k(C T::*) { cout << "C T::*" << endl; };
template<class T, class U> void k(T U::*) { cout << "T U::*" << endl; };


void test_3() {
   k(&C::x);
   k(&D::y);
   k(&D::z);
}

template<class T>     void m(T (C::*)() )
   { cout << "T (C::*)()" << endl; };
template<class T>     void m(C (T::*)() )
   { cout << "C (T::*)()" << endl; };
template<class T>     void m(D (C::*)(T))
   { cout << "D (C::*)(T)" << endl; };
template<class T, class U>  void m(C (T::*)(U))
   { cout << "C (T::*)(U)" << endl; };
template<class T, class U>  void m(T (C::*)(U))
   { cout << "T (C::*)(U)" << endl; };
template<class T, class U>  void m(T (U::*)() )
   { cout << "T (U::*)()" << endl; };
template<class T, class U, class V> void m(T (U::*)(V))
   {
 cout << "T (U::*)(V)" << endl; };

void test_4() {
   int (C::*f_membp1)(void);
   C (D::*f_membp2)(void);
   D (C::*f_membp3)(int);
   m(f_membp1);
   m(f_membp2);
   m(f_membp3);

   C (D::*f_membp4)(int);
   int (C::*f_membp5)(int);
   int (D::*f_membp6)(void);
   m(f_membp4);
   m(f_membp5);
   m(f_membp6);

   int (D::*f_membp7)(int);
   m(f_membp7);
}

template<int i> void n(C[10][i]) { cout << "E[10][i]" << endl; };
template<int i> void n(B<i>)     { cout << "B<i>" << endl; };

void test_5() {
   C array[10][20];
   n(array);
   B<20> b;
   n(b);
}

template<template<class> class TT, class T> void p1(TT<T>)
   { cout << "TT<T>" << endl; };
template<template<int> class TT, int i>     void p2(TT<i>)
   { cout << "TT<i>" << endl; };
template<template<class> class TT>          void p3(TT<C>)
   { cout << "TT<C>" << endl; };

void test_6() {
   A<char> a;
   B<20> b;
   A<C> c;
   p1(a);
   p2(b);
   p3(c);
}

int main() { test_1(); test_2(); test_3(); test_4(); test_5(); test_6(); }

我的生活和大脑中所有问题的原因是：test_3()

便于阅读的相关代码：

class C {
   public:
      int x;
};

template<class T>          void k(T C::*) { cout << "T C::*" << endl; };
template<class T>          void k(C T::*) { cout << "C T::*" << endl; };
template<class T, class U> void k(T U::*) { cout << "T U::*" << endl; };

void test_3() {
   k(&C::x);
   k(&D::y);
   k(&D::z);
}

这段代码最让我讨厌：

template<class T>          void k(T C::*)

我的意思是那是什么样的语法以及它如何正常工作。为什么我们需要T之前C::*或C之前T::*反之亦然。请帮助我，有人告诉我为什么这种语法如此奇怪以及它是如何工作的。

我是 C++ 新手，在 C#、C 和 OOP 方面有很好的经验。请解释语法和任何替代方式/语法，以更简洁的方式编写上述代码行（如果有）。先感谢您。

4

2 回答 2

5

T C::*声明指向C具有该类型的类的任何成员的指针T（其中T是模板参数）。参数没有名称，因此不能在函数内部使用。它仅用于重载解析。C T::*和也是如此T U::*。

从实例化中可以看出它起作用的原因：

k(&C::x);

这解决了第一个重载，并且T将被推断为具有 type int，因为C::xis 属于 type int。

k(&D::y);

这解决了第二个重载，因为D::y它的类型是C. T将被推断为有 type D。

k(&D::z);

这解决了第三个重载。T将被推断为有类型D并且U将被推断为有类型int，因为D::zis of type int。

总而言之，我想说这个例子可能是为了迷惑人们。如果它是作为一个教程，它可以做更好的命名和一些评论。

于 2012-12-07T10:45:02.013 回答
2

看起来该程序演示了各种重载解决方案。这只是练习语法。

T C::*声明一个对象，该对象引用类型为 的类的C成员T。要引用类的成员，您需要类的类型和成员的类型。声明中的::运算符对应于初始化中使用的运算符：

T C:: *x = & C::q;

这里的*指针声明符匹配地址操作符&，类似于声明和初始化指针T *y = & r;。引用类成员的对象称为指向成员的指针，因为它在语法中看起来像一个指针。（但在引擎盖下它根本不是指针。）

指向成员的指针很少使用，在您更熟悉 C++ 之前，您可以放心地忽略它们。

这与模板没有任何特别的关系，程序只是使用指向成员的指针，因为它涉及两个底层类型T和C，并且模板重载决议根据签名中 T 和 C 的具体程度选择其中一个函数匹配参数类型的 T 和 C 部分。

于 2012-12-07T10:50:43.277 回答