编译期Assertions
//动态检测
#include
template
TypeOut safe_reinterpret_cast(TypeIn tIn)
{
assert(sizeof(TypeIn) <= sizeof(TypeOut));
return reinterpret_cast(tIn);
}
int main()
{
void* pValue = nullptr;
char nValue0 = reinterpret_cast(pValue); //正常运行
char nValue1 = safe_reinterpret_cast(pValue); //引发中断
return 0;
}
//静态检测，但是编译器报的错并不直接
//结合常量表达式和编译器自动检查分配0数组错误
#define STATIC_CHECK(expr) { char aTem[expr ? 1 : 0]; }
template
TypeOut safe_reinterpret_cast(TypeIn tIn)
{
STATIC_CHECK(sizeof(TypeIn) <= sizeof(TypeOut));
return reinterpret_cast(tIn);
}
int main()
{
void* pValue = nullptr;
char nValue0 = reinterpret_cast(pValue); //编译通过
//char nValue1 = safe_reinterpret_cast(pValue); //编译失败
//error C2466: 不能分配常量大小为 0 的数组
long long nValue2 = safe_reinterpret_cast(pValue);//编译成功
return 0;
}
//最终版:检测任意常量表达式，且能自定义编译器报错的字符串
template class CCompileTimeCheck
{
public:
CCompileTimeCheck(...);
};
template<> class CCompileTimeCheck {};
#define STATIC_CHECK(expr, msg) \
{ \
class C##msg {}; \
sizeof((CCompileTimeCheck (C##msg()))); \
}
template
TypeOut safe_reinterpret_cast(TypeIn tIn)
{
STATIC_CHECK(sizeof(TypeOut) >= sizeof(TypeIn), Szn);
return reinterpret_cast(tIn);
}
int main()
{
void* pValue = nullptr;
long long nValue0 = safe_reinterpret_cast(pValue);//正常编译
char nValue1 = safe_reinterpret_cast(pValue); //编译出错
/*
error C2440: “”:
无法从“safe_reinterpret_cast::CSzn”转换为“CCompileTimeCheck”
*/
return 0;
}
对象构造、函数声明、名称查找的规则组合体现的一个例子
#include
#include
class CTest
{
public:
CTest() { printf("CTest\n"); }
CTest(CTest&) { printf("CTest Copy\n"); }
};
class CTest1
{
public:
CTest1() { printf("CTest1\n"); }
CTest1(CTest&) { printf("CTest1 Create\n"); }
CTest1(CTest1&) { printf("CTest1 Copy\n"); }
};
int main()
{
{
int nV0 = double(2.2); //强制类型转换 nV0 = 2
//反汇编: 008F3E2C mov dword ptr [nV0],2
int nV1 = (double)2.2; //强制类型转换 nV1 = 2
//反汇编: 008F3E33 mov dword ptr [nV1],2
auto nV2 = int(double()); //强制类型转换 nV2 = 0
//反汇编: 008F3E3A mov dword ptr [nV2],0
auto nV3 = static_cast(double());
//反汇编: 01003E25 mov dword ptr [nV3],0
auto pStr = typeid(int(double())).name();
//pStr = "int __cdecl(double (__cdecl*)(void))"
pStr = typeid((int(double()))).name();
//pStr = "int"
pStr = typeid(double()).name();
//pStr = "double __cdecl(void)"
pStr = typeid((double())).name();
//pStr = "double"
//int (double); //编译失败
int Fun(double); //函数声明
pStr = typeid(Fun).name(); //pStr = "int __cdecl(double)"
//sizeof 需要一个表达式或类型
//sizeof(Fun); //error Cun2070: “int (double)”: 非法的 sizeof 操作数
int nV4 = sizeof(Fun(1.1)); //Fun即使不进行定义，也不会报错 nV4 = 4
//反汇编: 009C3ECD mov dword ptr [nV4],4
}
{
auto Test1 = CTest1(CTest()); //输出"CTest" "CTest1 Create"
(CTest1(CTest())); //输出"CTest" "CTest1 Create"
CTest1 CTest(); //函数声明
CTest1 (CTest()); //函数声明 等价上一句
//从此 名字 CTest就不是自定义的类了，而是一个函数名称
auto it = CTest1(CTest()); //输出"Suprise" "CTest1" "CTest1 Copy"
auto it1 = CTest(); //输出"Suprise" "CTest1"
printf("");
}
return 0;
}
CTest1(CTest()) //等价于 CTest1 CTest() 此段代码是是CTest函数的定义
{
printf("Suprise\n");
return CTest1();
}
模板偏特化
- 模板类可以全特化也可以偏特化
- 模板类的成员函数只能全特化，不能偏特化(参见第一章)
- namespace-level的函数不能偏特化，但是可以被轻易的重载
常数映射为类型
- 应用场景:
有必要根据某个编译期常数调用一个或数个不同的函数
编译期实施分派(if-else switch语句)
template
struct IntToType
{
enum { eValue = nValue };
};
template
class CTest
{
public:
void Fun()
{
//编译期分派
if (bTest)
{
tValue.SomeFun();
}
}
private:
T tValue;
};
template
class CTest1
{
private:
void Fun(IntToType)
{
tValue.SomeFun();
}
void Fun(IntToType){}
public:
//编译期分派
void Suprise()
{
Fun(IntToType());
}
private:
T tValue;
};
int main()
{
int nValue = 10;
auto it0 = IntToType<10>(); //编译成功
//auto it1 = IntToType(); //编译出错
//“IntToType”: 模板参数“nValue”:“nValue”: 局部变量不能用作非类型参数
CTest Test;
//Test.Fun(); //编译出错
CTest1 Test1;
Test1.Suprise(); //编译成功
return 0;
}
类型对类型的映射
//类型映射到类型
template
struct STypeToType{ typedef T TypeOriginal; };
template
T* Create(const U& u, STypeToType)
{
return new T(u);
}
template
CTest* Create(const U& u, STypeToType)
{
//根据类型定制的版本
return new CTest(u, -1);
}
型别选择
- 一个应用场景:比如根据不同的类型，在vector中选择放置对象本身还是对象的指针
#include
#include
using std::vector;
//方法一:扩展性差
template
struct STest
{
typedef T* Type;
};
template
struct STest
{
typedef T Type;
};
//方法二:扩展性好
template
struct SSelect
{
typedef T Type;
};
template
struct SSelect
{
typedef U Type;
};
int main()
{
//it0 = "int *"
auto it0 = typeid(STest::Type).name();
//it1 = "int"
auto it1 = typeid(STest::Type).name();
//it2 = "int"
auto it2 = typeid(SSelect::Type).name();
//it3 = "double"
auto it3 = typeid(SSelect::Type).name();
return 0;
}
编译期间侦查可转换性和继承性
- 面对两个陌生的类型T和U，如何得知U是否继承于T？在编译期间发掘这样的关系，意味着不必使用dynamic_cast，后者会所耗执行效率。
template
class CConversion
{
//此类可以用于编译期间侦测类型的可转换性
typedef char Small;
class CBig { char aBuff[2]; };
//定义class CBig { char aBuff[2]; }; 确保sizeof(CBig) != sizeof(Small)
static Small Fun(U);
static CBig Fun(...);
/*
若T能转换为U则调用Fun(U), 否则调用Fun(...)
则有如下结论:
若T能转换为U : Fun返回Small
若T不能转换为U : Fun返回CBig
*/
static T MakeT();
//定义一个不完全函数，即使T类型的构造函数是private类型的也无妨
public:
enum
{
eExists = sizeof(Fun(MakeT())) == sizeof(Small)
//若T能转换为U则 Exists = true
//若T不能转换为U则 Exists = false
/*
sizeof可以用在任何表达式上，不论后者有多复杂，sizeof会直接传回大小，
不需要等到执行期才评估。这意味着sizeof可以感知重载、模板具现、转换规则
，或任何可以发生在C++表达式上的机制
*/
};
enum
{
eExistsToWay = eExists && CConversion::eExists
};
enum
{
eSameType = false
};
};
//模板偏特化
template
class CConversion
{
public:
enum { eExists = true, eExistsToWay = true, eSameType = true };
};
class CFather {};
class CChild : public CFather {};
int main()
{
bool aRe0[] =
{
CConversion::eExists, //true
CConversion::eExists, //false
CConversion::eExists,//true
CConversion::eExists,//false
};
bool aRe1[] =
{
//true
CConversion::eExistsToWay,
//false
CConversion::eExistsToWay,
};
bool aRe2[] =
{
CConversion::eSameType, //true
CConversion::eSameType, //false
};
return 0;
}
Type Traits
//类型判断
#include
using std::vector;
template
class CTypeTraits
{
public:
enum
{
eNormal,
eNference,
eNormalPoint,
ePointToMember,
};
private:
template struct STypeTest
{
enum { eResult = eNormal };
};
template struct STypeTest
{
enum { eResult = eNference };
};
template struct STypeTest
{
enum { eResult = eNormalPoint };
};
template struct STypeTest
{
enum { eResult = eNormalPoint };
};
template
struct STypeTest
{
enum { eResult = ePointToMember };
};
template
struct STypeTest
{
//类的常量 成员/成员函数 指针
enum { eResult = ePointToMember };
};
public:
enum { eType = STypeTest::eResult };
};
struct A
{
int value;
int Fun();
};
int main()
{
//语法 : 定义一个指向类的常量成员函数的指针
vector::size_type (vector::*p)() const = &vector::size;
char aRe[] =
{
CTypeTraits::iterator>::eType, //0
CTypeTraits::eType, //0
CTypeTraits::eType, //1
CTypeTraits::eType, //2
CTypeTraits::eType, //2
CTypeTraits::eType, //3
CTypeTraits::eType, //3
CTypeTraits::size)>::eType, //3
};
return 0;
}
//利用偏特化 去掉 const 属性
template
class CDelConst
{
private:
template struct SNotConst
{
typedef U Type;
};
template struct SNotConst
{
typedef U Type;
};
public:
typedef typename SNotConst::Type Type;
};
