学习C++设计新思维(泛型编程与设计模式之应用).pdf之继承关系检查

ok！主题是：检查型别A与B是不是有继承关系，在本书的P38，下面直接上代码。

#pragma once


template<class T, class U>
class Conversion
{
	typedef char Small;
	class Big{ char dummy[2]; };

	static Small Test(U);
	static Big Test(...);
	static T MakeT();

public:
	enum { exists = sizeof(Test(MakeT())) == sizeof(Small) };
	enum { exists2Ways = exists && Conversion<U, T>::exists };
	enum { sameType = false };
};

template<class T>
class Conversion < T, T >
{
public:
	enum { sameType = true, exists = true, exists2Ways = true };
};


#define SUPERSUBCLASS(T, U)	\
	(Conversion<const T*, const U*>::exists &&	\
	!Conversion<const T*, const void*>::sameType)



#define SUPERSUBCLASS_STRICT(T, U)	\
	(SUPERSUBCLASS(T, U) &&	\
	!Conversion<const T, const U>::sameType)

void chapter2_CI_CI()
{
	cout << "<int->long>" << Conversion<int, long>::exists << "\n" << endl;
	cout << "<char->char*>" << Conversion<char, char*>::exists << "\n" << endl;
	cout << "<std::size_t->vector<int>>" 
		<< Conversion<std::size_t, std::vector<int>>::exists << "\n" << endl;

	class A{};
	class B : public A{};
	cout << "SUPERSUBCLASS(A, B):" << SUPERSUBCLASS(A, B) << endl;
	cout << "SUPERSUBCLASS(B, A):" << SUPERSUBCLASS(B, A) << endl;
	cout << "SUPERSUBCLASS(int, long):" << SUPERSUBCLASS(int, long) << endl;
	cout << "SUPERSUBCLASS(int, int):" << SUPERSUBCLASS(int, int) << endl;
	cout << "SUPERSUBCLASS(char, char*):" << SUPERSUBCLASS(char, char*) << endl << endl;

	cout << "SUPERSUBCLASS_STRICT(A, B):" << SUPERSUBCLASS_STRICT(A, B) << endl;
	cout << "SUPERSUBCLASS_STRICT(B, A):" << SUPERSUBCLASS_STRICT(B, A) << endl;
	cout << "SUPERSUBCLASS_STRICT(int, long):" << SUPERSUBCLASS_STRICT(int, long) << endl;
	cout << "SUPERSUBCLASS_STRICT(int, int):" << SUPERSUBCLASS_STRICT(int, int) << endl;
	cout << "SUPERSUBCLASS_STRICT(char, char*):" << SUPERSUBCLASS_STRICT(char, char*) << endl;

}

<int->long>1
<char->char*>0
<std::size_t->vector<int>>0


SUPERSUBCLASS(A, B):0
SUPERSUBCLASS(B, A):1
SUPERSUBCLASS(int, long):0
SUPERSUBCLASS(int, int):1
SUPERSUBCLASS(char, char*):0


SUPERSUBCLASS_STRICT(A, B):0
SUPERSUBCLASS_STRICT(B, A):1
SUPERSUBCLASS_STRICT(int, long):0
SUPERSUBCLASS_STRICT(int, int):0
SUPERSUBCLASS_STRICT(char, char*):0
请按任意键继续. . .

上面是代码和运行结果。使用win7+vs2013.

----------------------

我也是才学模板的，所以涉及不深，也说不上什么来。错误之处请指正。

他的转换是依赖函数的重载机制的。

像代码：enum { exists = sizeof(Test(MakeT())) == sizeof(Small) };使用MakeT方法的返回值传给方法Test，而Test有2个版本，所以编译器择优选择，如果可以匹配到static Small Test(U)，则可以转换，负责编译器只能选择static Big Test(...);，这时就表示不能转换，同时再依赖于sizeof的大小检测。这里应该都明白了， 但是看你会有一个问题，A不能转换为B，但是要是2个大小一样怎么办？请看： typedef char Small;class Big{ char dummy[2]; };

同时在检测类型一致时，使用了类模板偏特化的机制，函数是没有偏特化的。但是好像可以使用TYPE2TYPE来填坑。

类：

template<class T>
class Conversion < T, T >

这个类模板的声明呢，跟代码里其他一个模板类的声明不一样，一个是template<class T, class U>，一个就是template<class T>，但是这个类却使用了 class Conversion < T, T >，这个就是偏特化，如果你要定义一个类对象，如：Conversion (int ,int),那么编译器会选择模板参数只有一个的，如果你定义Conversion (int ,long),他会选择有两个模板参数的。模板偏特化还可以让你这么定义：

template<class T>
class Conversion < T, int >

这样不管T是什么，如果第二个参数是int，就会选择这个版本。

----------------------

不说了，免得误导人~~！