标签：return unknown 技法 traits func 简单 type class

7.简单说一下traits技法

traits技法利用“内嵌型别“的编程技巧与编译器的template参数推导功能，增强C++未能提供的关于型别认证方面的能力。常用的有iterator_traits和type_traits。

iterator_traits

被称为特性萃取机，能够方便的让外界获取以下5种型别：

value_type：迭代器所指对象的型别
difference_type：两个迭代器之间的距离
pointer：迭代器所指向的型别
reference：迭代器所引用的型别
iterator_category：三两句说不清楚，建议看书

type_traits

关注的是型别的特性，例如这个型别是否具备non-trivial defalt ctor（默认构造函数）、non-trivial copy ctor（拷贝构造函数）、non-trivial assignment operator（赋值运算符）和non-trivial dtor（析构函数），如果答案是否定的，可以采取直接操作内存的方式提高效率，一般来说，type_traits支持以下5中类型的判断：

__type_traits<T>::has_trivial_default_constructor
__type_traits<T>::has_trivial_copy_constructor
__type_traits<T>::has_trivial_assignment_operator
__type_traits<T>::has_trivial_destructor
__type_traits<T>::is_POD_type

由于编译器只针对class object形式的参数进行参数推到，因此上式的返回结果不应该是个bool值，实际上使用的是一种空的结构体：

struct __true_type{};struct __false_type{};

这两个结构体没有任何成员，不会带来其他的负担，又能满足需求，可谓一举两得

当然，如果我们自行定义了一个Shape类型，也可以针对这个Shape设计type_traits的特化版本

template<> struct __type_traits<Shape>
{
	typedef __true_type has_trivial_default_constructor;
	typedef __false_type has_trivial_copy_constructor;
	typedef __false_type has_trivial_assignment_operator;
	typedef __false_type has_trivial_destructor;
	typedef __false_type is_POD_type;
};

参考：阿秀

1.前言

traits，又被叫做特性萃取技术，说得简单点就是提取“被传进的对象”对应的返回类型，让同一个接口实现对应的功能。因为STL的算法和容器是分离的，两者通过迭代器链接。算法的实现并不知道自己被传进来什么。萃取器相当于在接口和实现之间加一层封装，来隐藏一些细节并协助调用合适的方法，这需要一些技巧（例如，偏特化）。最后附带一个小小的例子，应该能更好地理解特性萃取。

下面大部分来源于《STL源码剖析》，看原书能了解更多细节。

2.Traits编程技法

让我们一点点抛出问题，然后一点点深入。

1.首先，在算法中运用迭代器时，很可能会用到其相应类型（迭代器所指之物的类型）。假设算法中有必要声明一个变量，以“迭代器所指对象的类型”为型别，该怎么办呢？

解决方法是：利用function template的参数推导机制。

template < class I, class T>
void func_impl(I iter, T t)
{
	T tmp; // 这里就是迭代器所指物的类型新建的对象

	// ... 功能实现
}

template < class I>
inline
void func(I iter) 
{  
	func_impl(iter, *iter); // 传入iter和iter所指的值，class自动推导	
}

int main() 
{
	int i;  
	func(&i);
}

这里已经可以看出封装的意思了，没有一层impl的封装的话，每次你都要显式地说明迭代器指向对象型别，才能新建tmp变量。加一层封装显得清爽很多。

迭代器相应型别不只是“迭代器所指对象的型别”一种而已。根据经验，最常用的相应型别有五种，然而并非任何情况下任何一种都可以利用上述的template参数推导机制来取得。

函数的“template参数推导机制”推导的只是参数，无法推导函数的返回值类型。万一需要推导函数的传回值，就无能为力了。

C++的IMPL模式，也称为Pimpl（Pointer to IMPLementation）模式，是一种常见的设计模式。该模式的主要目的是为了将类的实现细节从接口中分离出来，以达到以下几个目标：

隐藏实现细节：接口用户不需要知道类的具体实现，这可以让接口变得更简洁，也有利于减少不必要的编译依赖。
提高编译速度：如果类的实现改变，只需要重新编译实现文件，不需要重新编译使用该类的文件。
降低二进制接口（ABI）的变动：当实现发生改变时，使用该类的代码不需要重新编译。

一个基本的Pimpl模式的例子如下：

// myclass.h
class MyClassImpl; // 前向声明
class MyClass
{
public:
    MyClass();
    ~MyClass();
    void doSomething();
private:
    MyClassImpl* pImpl; // 指向具体实现的指针
};

// myclass.cpp
class MyClassImpl
{
public:
    void doSomething() { /* 具体实现 */ }
};

MyClass::MyClass() : pImpl(new MyClassImpl()) {}
MyClass::~MyClass() { delete pImpl; }
void MyClass::doSomething() { pImpl->doSomething(); }

上面的代码展示了如何使用Pimpl模式。类的具体实现被隐藏在了MyClassImpl类中，而MyClass只包含一个到实现的指针。当调用doSomething方法时，实际上是调用了实现的方法。

注意，为了正确地管理内存，我们在MyClass的构造函数中分配了实现对象的内存，并在析构函数中释放了这个内存。这是符合“谁创建，谁销毁”的原则的。

2.声明内嵌型别似乎是个好主意，这样我们就可以直接获取。

template < class T>
struct MyIter 
{
	typedef T value_type; // 内嵌型别声明
	// ...
};

template < class I>
typename I::value_type
func(I ite)
{
	return *ite;
}

// ...
MyIter<int> ite(new int(8));
cout << func(ite);

看起来不错，但是并不是所有迭代器都是class type，原生指针就不行！如果不是class type，就无法为它定义内嵌型别。

这时候就需要 偏特化 出现。

3.偏特化就是在特化的基础上再加一点限制，但它还是特化的template。

template < class I>
struct iterator_traits 
{
	typedef typename I::value_type value_type;
};

template < class I>
struct iterator_traits<T*>
{
	typedef T value_type;
};

 template < class I> typename iterator_traits<I>::value_type
 func(I ite)
 {
	 return *ite;
}

func在调用 I 的时候，首先把 I 传到萃取器中，然后萃取器就匹配最适合的 value_type。（萃取器会先匹配最特别的版本）这样当你传进一个原生指针的时候，首先匹配的是带<T*>的偏特化版本，这样 value_type 就是 T，而不是没有事先声明的 I::value_type。这样返回值就可以使用 typename iterator_traits<I>::value_type 来知道返回类型。

3.让traits干更多东西

迭代器有常见有五种类型: value_type, difference_type, reference_type, pointer_type都比较容易在 traits 和相应偏特化中提取。但是，iterator_category一般也有5个，这个相应型别会引发较大规模的写代码工程。

例如，我们实现了 func_II, func_BI, func_RAI 分别代表迭代器类型是Input Iterator，Bidirectional Iterator和Random Access Iterator的对应实现。

现在，当客端调用func()的时候，我们可能需要做一个判断：

template < class Iterator>
void func(Iterator & i) 
{     
	if (is_random_access_iterator(i))        
		func_RAI(i);
	if (is_bidirectional_iterator(i))   
		func_BI(i);
	else  
		func_II(i);
}

但这样在执行时期才决定使用哪一个版本，会影响程序效率。最好能够在编译期就选择正确的版本。

重载这个函数机制可以达成这个目标。

struct input_iterator_tag {};
struct output_iterator_tag {};
struct forward_iterator_tag : public input_iterator_tag {};
// ...
// 继承的好处就是，当函数需要用 input_iterator_tag 的时候
// 假设你传进一个forward_iterator_tag，它会沿继承向上找，知道符合条件

声明了一些列 tag 之后，我们就可以重载 func函数： func(tag)。

到这里，各个型别的具体重载实现已经写好，但是需要一个统一的接口，这时候 traits 就可以出场了。

template < class Iterator>
inline void func(Iterator & i)
{ 
    typedef typename Iterator_traits<Iterator>::iterator_category category;
    __func(i, category()); // 各型别的重载
}

4.简单实例代码

所以说，traits一方面，在面对不同的输入类时，能找到合适的返回型别；另一方面，当型别对应有不同的实现函数的时候，能起到一个提取型别然后分流的作用。

先假设我们有一个 func 函数，可以接受自定义的类或者原始的指针作为参数，并自动输出使用了什么tag。

首先根据 traits（由本身或偏特化版本实现），它会提取 u 的返回型别，然后调用对应的构造函数 return_type()，来当作各个重载版本 __func 的重载标志区分不同的实际函数。

●首先我们看看接口代码的编写

template < class unknown_class>
inline typename unknown_class_traits<unknown_class>::return_type // 萃取器取得对应型别
func(unknown_class u) 
{    
	typedef typename unknown_class_traits<unknown_class>::return_type return_type;
	return __func(u, return_type()); // 需要调用构造函数当tag
}

●先 return_type 的构造函数

template <class unknown_class>
inline typename unknown_class_traits<unknown_class>::return_type
return_type(unknown_class) 
{
    typedef typename unknown_class_traits<unknown_class>::return_type RT;
    return RT();
}

然后是实现设定的 tag ，用来模仿前面说的 II，RAI等

struct A {};
struct B : A{};

●然后是 traits 隆重登场，有两个偏特化版本。

/*特性萃取器*/
template <class unknown_class>
struct unknown_class_traits 
{
    typedef typename unknown_class::return_type return_type;
};

/*特性萃取器 —— 针对原生指针*/
template <class T>
struct unknown_class_traits<T*> 
{
    typedef T return_type;
};

/*特性萃取其 —— 针对指向常数*/
template <class T>
struct unknown_class_traits<const T*> 
{
    typedef const T return_type;
};

●突然忘记了交代 unknown_class 的结构，自定义的类，必须要 typedef。

template <class AorB>
struct unknown_class
{
    typedef AorB return_type;
};

●最后是func各个重载版本。

template <class unknown_class>
inline typename unknown_class_traits<unknown_class>::return_type
__func(unknown_class, A) 
{
    cout << "use A flag" << endl;
    return A();
}

template <class unknown_class>
inline typename unknown_class_traits<unknown_class>::return_type
__func(unknown_class, B) 
{
    cout << "use B flag" << endl;
    return B();
}

template <class unknown_class, class T>
T
__func(unknown_class, T)
{
    cout << "use origin ptr" << endl;
    return T();
}

●有了这些我们就可以测试了

int main()
{
    unknown_class<B> b;
    unknown_class<A> a;
    //unknown_class<int> i;
    int value = 1;
    int* p = &value;

    A v1 = func(a);
    B v2 = func(b);
    int v3 = func(p);

    char ch = getchar();
}

可以看到，对于用自定义类传入同一个接口，它会自动使用对应的函数，而且返回值也合适。对原始指针也适用，完美！

附

下面是完整代码：

#include <iostream>
using namespace std;

/*先定义一些tag*/
struct A {};
struct B : A {}; // 继承的好处就是，当函数需要参数为A，
// 而你传入的参数为B的时候，可以往上一直找到适合的对象

/*假设有一个未知类*/
template <class AorB>
struct unknown_class 
{
    typedef AorB return_type;
};

/*特性萃取器*/
template <class unknown_class>
struct unknown_class_traits 
{
    typedef typename unknown_class::return_type return_type;
};

/*特性萃取器 —— 针对原生指针*/
template <class T>
struct unknown_class_traits<T*>
{
    typedef T return_type;
};

/*特性萃取其 —— 针对指向常数*/
template <class T>
struct unknown_class_traits<const T*> 
{
    typedef const T return_type;
};


/*决定使用哪一个类型*/
template <class unknown_class>
inline typename unknown_class_traits<unknown_class>::return_type
return_type(unknown_class) 
{
    typedef typename unknown_class_traits<unknown_class>::return_type RT;
    return RT();
}

template <class unknown_class>
inline typename unknown_class_traits<unknown_class>::return_type
__func(unknown_class, A)
{
    cout << "use A flag" << endl;
    return A();
}

template <class unknown_class>
inline typename unknown_class_traits<unknown_class>::return_type
__func(unknown_class, B)
{
    cout << "use B flag" << endl;
    return B();
}

template <class unknown_class, class T>
T
__func(unknown_class, T) 
{
    cout << "use origin ptr" << endl;
    return T();
}

template <class unknown_class>
inline typename unknown_class_traits<unknown_class>::return_type
func(unknown_class u) 
{
    typedef typename unknown_class_traits<unknown_class>::return_type return_type;
    return __func(u, return_type());
}

int main() 
{
    unknown_class<B> b;
    unknown_class<A> a;
    //unknown_class<int> i;
    int value = 1;
    int* p = &value;

    A v1 = func(a);
    B v2 = func(b);
    int v3 = func(p);

    char ch = getchar();
}

参考：[C++ traits技术浅谈](

标签：return,unknown,技法,traits,func,简单,type,class
From： https://www.cnblogs.com/codemagiciant/p/17601959.html

7.简单说一下traits技法

7.简单说一下traits技法

1.前言

2.Traits编程技法

1.首先，在算法中运用迭代器时，很可能会用到其相应类型（迭代器所指之物的类型）。假设算法中有必要声明一个变量，以“迭代器所指对象的类型”为型别，该怎么办呢？

2.声明内嵌型别似乎是个好主意，这样我们就可以直接获取。

3.偏特化就是在特化的基础上再加一点限制，但它还是特化的template。

3.让traits干更多东西

4.简单实例代码

附

相关文章

赞助商

阅读排行