模板之TypeTraits

太过爱你忘了你带给我的痛 2022-08-14 01:45 228阅读 0赞

Traits 是一种 “可用于编译器根据型别作判断” 的泛型技术，像在执行期根据数值执行判断一样。

Traits 好处：可以在 ”型别确立当时“意外的其他地点做出与型别相关的判断。这会让代码变得比较干净，更具可读性，而且更好维护。

### 1 实作出 Pointer Traits ###

// 边界标记 NullType 和 EmptyType
    class NullType;
    struct EmptyType {}; 
    
    template <typename T>
    class TypeTraits
    {
    private:
    	template <class U> struct PointerTraits // 不是指针，且该型别不能使用
    	{
    		enum { result = false };
    		typedef NullType PointeeType;
    	};
    	template <class U> struct PointerTraits<U*> // 针对任意指针型别
    	{
    		enum { result = true };
    		typedef U PointeeType; // T 是个指针型别，求得 T 所指型别，NOT Pointer！！！
    	};
    public:
    	enum { isPointer = PointerTraits<T>::result };
    	typedef typename PointerTraits<T>::PointeeType PointeeType; // typename 不可少！！
    };

同理，可用 template traits 判断 pointers to members

template <typename T>
    class TypeTraits
    {
    private:
    	// pointers to members
    	template <class U> struct PToMTraits
    	{
    		enum { result = false };
    	};
    	template <class U, class V>
    	struct PToMTraits < U V::* >
    	{
    		enum { result = true };
    	};
    
    	// stripping qualifiers （卸除饰词）
    	template <class U> struct UnConst
    	{
    		typedef U Result;
    	};
    	template <class U> struct UnConst <const U>
    	{
    		typedef U Result;
    	};
    public:
    	enum { isMemberPointer = PToMTraits<T>::result };
    };

### 2 优化的参数型别 ###

在泛型代码中，任意给定一个型别 T，什么是”将 T 对象传入函数当做参数“的最有效做法 ？

一般而言，最有效的方法是在传入一个精巧型别时采用 by reference 传递方式，而面对纯量型别时采用 by value 传递方式。

纯量型别由数值型别、枚举型别、指针、指向成员之指针组成。

精巧型别由自定义的类型struct 或者 class 组成。

精巧型别应避免额外暂时对象带来的额外开销（构造函数和析构函数的额外调用动作）；纯量型别应避免 reference 带来的间接性所造成的额外开销。

注意：C++ 不允许 references to references。因此，如果 T 已经是一个 reference，千万别对它再加上 reference。

### 3 卸除饰词 ###

template <typename T>
    class TypeTraits
    {
    private:
    	// stripping qualifiers （卸除饰词）
    	template <class U> struct UnConst
    	{
    		typedef U Result;
    	};
    	template <class U> struct UnConst <const U>
    	{
    		typedef U Result;
    	};
    public:	
    	typedef typename UnConst<T>::Result NonConstType;
    };

### 4 运用 TypeTraits ###

enum CopyAlgoSelector { Conservative, Fast };
    
    // Conservative routine-works for any type
    template <typename InIt, typename OutIt>
    OutIt CopyImpl(InIt first, InIt last, OutIt result, Int2Type<Conservative>)
    {
    	for (; first != last; ++first, ++result)
    		*result = *first
    }
    // Fast routine-works only for pointers to raw data
    template <typename InIt, typename OutIt>
    OutIt CopyImpl(InIt first, InIt last, OutIt result, Int2Type<Fast>)
    {
    	const size_t n = last - first;
    	memcpy(result, first, n*sizeof(*first));
    	return result + n;
    }
    template <typename InIt, typename OutIt>
    OutIt Copy(InIt first, InIt last, OutIt result)
    {
    	typedef TypeTraits<InIt>::PointeeType SrcPointee;
    	typedef TypeTraits<OutIt>::PointeeType DestPointee;
    	enum { copyAlgo = 
    		TypeTraits<InIt>::isPointer &&
    		TypeTraits<OutIt>::isPointer &&
    		TypeTraits<SrcPointee>::isStdFundamental &&  // 将在 typelist中介绍
    		TypeTraits<DestPointee>::isStdFundamental &&
    		sizeof(SrcPointee) == sizeof(DestPointee) ? Fast : Conservative };
    
    	return CopyImpl(first, last, result, Int2Type<copyAlgo>);
    }

enum copyAlgo 会自动选择某个算法， 逻辑：如果迭代器 都是指针，而且都指向基本型别，而且所指型别的大小一样，那么就使用 memcpy。

如果你这样做：

int*p1 = ...
    int* p2 =..
    usigned int* p3 = ..
    Copy(p1, p2, p3); // Copy() 调用快速版本，虽然“源端类型” 和 “目标端类型”并不形同。

假设你有一个 C struct ，由基本类型组成的数据，就是所谓的plain old data 或称 POD 结构。C++ 可对 POD 进行 bitwise copy（位逐一拷贝）动作，但Copy() 却无法判断出操作对象是否为 POD，因此调用慢速版本。你只能这样：

template <typename T> struct SupportsBitwiseCopy
    {
    	enum { result = TypeTraits<T>::isStddFundamental };
    };
    template <typename InIt, typename OutIt>
    OutIt Copy(InIt first, InIt last, OutIt result, int2Type<true>)
    {
    	typedef TypeTraits<InIt>::PointeeType SrcPointee;
    	typedef TypeTraits<OutIt>::PointeeType DestPointee;
    	enum { useFast = 
    		TypeTraits<InIt>::isPointer &&
    		TypeTraits<OutIt>::isPointer &&
    		SupportsBitwiseCopy<SrcPointee>::result &&  // 将在 typelist中介绍
    		SupportsBitwiseCopy<DestPointee>::result &&
    		sizeof(SrcPointee) == sizeof(DestPointee) ? Fast : Conservative };
    
    	return CopyImpl(first, last, result, Int2Type<useFast>);
    }
    // 某 （MyType）POD 型别的特化
    template <> struct SupportsBitwiseCopy < MyType >
    {
    	enum { result = true };
    };