请问下这个模板的语法是啥。。

[NYN]

template<class S, class T>
struct SameClass
{
    template<class Identical, Identical> //A: 这个一般都是 typename A, typename B吧。。这样写有啥特殊语法么？
    struct type_match;                    
 
    template<class _1>
    static char (& func(
         type_match< T& (_1::*)(const _1&), &_1::operator => *) )[1]; // 这个必须用这种写法才能有效果，请问下这种写法的含义是啥。。跟之前(A:)的有啥匹配关系?
 
    template<class >
    static char (& func(...))[2];
 
    static bool const value = sizeof(func<S>(0)) == 1;
};
 
template<class c1, class c2>
bool IsSameClassAs() { return SameClass<c1,c2>::value == 1; }

[Saleayas]

那么这个呢？

struct C1
{
};

struct C2
{
	C1 &operator = (C2 const &);
};

[Saleayas]

那么这个呢？

struct C1
{
};

struct C2
{
	C1 &operator = (C2 const &);
};

[pengzhixi]

[Quote=引用 3 楼 的回复:]
那么这个呢？

C/C++ code


struct C1
{
};

struct C2
{
C1 &operator = (C2 const &);
};
[/Quote]
看清楚 &_1::operator =这个函数后面可不是说参数类型不同于_1的

[NYN]

我的意思是。。既然要确定Identical2个参数一致，为什么不能用
template<class _1>
static char (& func(
type_match< T, _1) )[1];
呢？(事实上这个也编译不过)而一定要用以上的写法？
而且其实Identical这2个参数并不一致，一个是类cp构造函数的类型声明，另一个是类cp构造函数的地址

考虑到这个，我才问这个模板的写法有没什么语法规定或者要求。。

[珍惜生命远离CPP]

这个叫做 Non-type template arguments

呃，这个检测的东西和 SameClass这个名字 不符合

只是检测 S 类中是否有 T& operator=( const S&);

struct B {};
struct A
{
    B& operator=( const A& );
};

int main()
{
    printf( "%d\n" , IsSameClassAs<A,B>() );// 1 
    printf( "%d\n" , IsSameClassAs<A,A>() );// 0 
}

[Saleayas]

[Quote=引用 4 楼 的回复:]

引用 3 楼 的回复:
看清楚 &_1::operator =这个函数后面可不是说参数类型不同于_1的
[/Quote]

没有看懂！！
其实 is_same 很简单。
何必去依赖一个类的函数呢？

[pengzhixi]

首先必须保证是class啊，如果你传递 int,long怎么整呢

[NYN]

哎，可能是我的表达能力太差了。。
Non-type template arguments应该是这样的：
template<class Identical_1, int Identical_2>
struct type_match;

但是这里的用法是
template<class Identical, int Identical> // 注意这里Identical是一样的！
struct type_match;

配合
template<class _1>
static char (& func(
type_match< T& (_1::*)(const _1&), &_1::operator => *) )[1];
之间的关系是什么？为什么一个类成员函数类型声明加上对应的指针地址，就能成功特化到这个函数声明？

不讨论这个模板的作用是否合适，有啥bug，纯说语法好么！？

[pengzhixi]

type_match和func的关系 就是
func模板函数第一个版本是用 一个type_match<T1,T2>*作为参数的。

至于为什么用 成员函数指针作为type_match的参数无非考虑到 这样一个要求，那就是参数必须是一个class而非其他的类型（int,double等等）。

一旦传递的参数类型（必须是class 类型） 是相互可以替换的那么就会匹配到第一个func，否则就会以匹配失败但不是错误的机制 从而匹配到第2个func模板

[NYN]

好吧又看了下明白了。。这个template<class Identical, int Identical>第一个Identical声明了一个类型，第2个Identical是这个类型的常量。。
type_match< T& (_1::*)(const _1&), &_1::operator => *
这里 T& (_1::*)(const _1&) 声明了某个构造函数指针类型，&_1::operator =是构造函数指针类型的常量
特化到这个函数必须满足2个条件：
1. 编译器必须检查到这个_1类型具有构造函数指针类型的常量(也就是说他是一个类)
2. 编译器必须检查到_1这个构造函数的返回值必须是T&
所以一般的类可以特化成功，得到'same'的结果。

[pengzhixi]

不是这个类型的常量 。而是像我们 int a,b;这样
只是代表两者的类型是一样的。

[NYN]

顺便补充一下匹配错误但不是失败的机制叫做SFINAE，有兴趣的可以查一查。。

[珍惜生命远离CPP]

[Quote=引用 9 楼 的回复:]

哎，可能是我的表达能力太差了。。
Non-type template arguments应该是这样的：
template<class Identical_1, int Identical_2>
struct type_match;

但是这里的用法是
template<class Identical, int Identical> // 注意这里Identical是一样的！
str……
[/Quote]
template<class Identical, Identical>
Identical是个类型，当然可以这么写了，只是没写后面的变量而已。


这么写也没啥问题

template<class>
struct A
{
};

int main()
{
	A<int> a;
}

[NYN]

[Quote=引用 12 楼 的回复:]

不是这个类型的常量 。而是像我们 int a,b;这样
只是代表两者的类型是一样的。
[/Quote]

我不赞同，如果这么说那
template<typename a, b>
class A
这样也能编译过了，而且你看下实现部分传入的是啥。。不是2个类型，而是一个类型和一个类型的实例。

[pengzhixi]

晕 我只是想表达 int a,b中b的类型是确定的。并不是让你模板参数也完全按照这个写法去写
template<typename a, a obj>要写也是这么写。

这个就是所谓的非类型模板参数

[pengzhixi]

1.<class Identical, Identical> 两个参数类型必须一致。这样为后面的func函数的重载埋伏笔

2.template<class _1>
static char (& func(
type_match< T& (_1::*)(const _1&), &_1::operator => *) )[1];

这个是一个函数 func，返回类型是数组的引用 char(&arr)[1] 参数是一个type_match类对象的指针。

T& (_1::*)(const _1&), &_1::operator = 分别是type_match模板类的两个模板参数。

[redleaves]

其实就是
template
< typename _Type, //在这里声明一个类型参数
_Type _val // 用上面声明的类型定义一个非类型参数
>
class xxxx;

用的时候
xxxx<int,1>
xxxx<char,'c'>
这样都能匹配.
但问题是在一些编译器上,编译不过.

[taodm]

楼主既然已经知道语法了，可以结贴了吧。