C/C++编程：trait和policy类

最新推荐文章于 2024-08-01 17:13:09 发布
最新推荐文章于 2024-08-01 17:13:09 发布
阅读量638 收藏 3
点赞数
分类专栏： C++
原文链接：http://www.josuttis.com/tmplbook/
版权
C++ 专栏收录该内容
1060 篇文章 297 订阅
订阅专栏

通过trait，可以根据某些类型来定义某种行为(policy)。

一个实例：累加一个序列

fixed traits

假设：

  • 所要计算总和的值都是存储在一个数组里面的
  • 目前已经有一个指向数组的指针，一个指向数组最后一个元素的后一位的指针，这两个指针之间的所有元素就是要进行求总和的元素
#ifndef UNTITLED_ACCUM1_H
#define UNTITLED_ACCUM1_H

template<typename T>
inline 
T accum(T const * beg, T const *end){
    T total = T();   //假设T()会生成一个等于0的值
    while (beg != end){
        total += *beg;
        ++beg;
    }
    return total;
}

#endif //UNTITLED_ACCUM1_H

问题：如果为正确的类型生成了0值？

  • 对于内建数值类型(比如int)， T()会生成0
  • 其他类型
#include <iostream>
#include <accum1.h>
using namespace std;

int main()
{
    int num[] = {1, 2, 3, 4, 5};

    std::cout << "the average value of the integer value is "
    << accum(&num[0], &num[5]) / 5 << "\n";


    char name[] = "templates";
    int length = size(name) - 1;

    std::cout << "the average value of the characters value is "
              << accum(&num[0], &num[length]) / length << "\n";
}

在这里插入图片描述

前半部分对，后半部分明显错了：这是因为模板时基于char类型进行实例化的，结果加起来超过了char可以表示的范围。

解决方法

  • 第一种：引入一个额外的模板参数AccT（表示变量total的类型和返回类型），但是这会给该模板的所有用户都加上一个额外的负担：每次调用这个模板的时候，都要指定这个额外的参数
  • 第二种：对accum()所调用的每个T类型都创建一个关联，所关联的类型就是用来存储累加和的类型。这种关联可以被看作类型T的一个特征，因此，我们也罢这个存储累加和的类型称为T的trait。于是，我们可以使用模板特化来写出这些关联代码
// accumtraits.h
#ifndef UNTITLED_ACCUMTRAITS_H
#define UNTITLED_ACCUMTRAITS_H


template<typename T>
class AccumulationTraits;

template<>
class AccumulationTraits<char>{
public:
    typedef int AccT;
};

template<>
class AccumulationTraits<short>{
public:
    typedef int AccT;
};

template<>
class AccumulationTraits<int>{
public:
    typedef long AccT;
};

template<>
class AccumulationTraits<unsigned int>{
public:
    typedef unsigned long AccT;
};

template<>
class AccumulationTraits<float>{
public:
    typedef double AccT;
};

#endif //UNTITLED_ACCUMTRAITS_H

上面代码中，模板AccumulationTraits被称为一个trait模板，因为它含有它的参数类型的一个trait（通常而言，可以存在多个trait和多个参数）对这个模板，我们并不提供一个泛型的定义，因为在我们不知道参数类型的前提下， 并不能确定应该选择什么样的类型作为和的类型。然而，我们可以利用某个实参类型，而T本身通常都能够作为这样的一个候选类型。

让我们来改写前面的accum()模板：

#ifndef UNTITLED_ACCUM1_H
#define UNTITLED_ACCUM1_H
#include "accumtraits.h"

template<typename T>
inline
typename AccumulationTraits<T>::AccT accum(T const * beg, T const *end){
   // 返回值的类型是一个元素类型的trait
    typedef typename AccumulationTraits<T>::AccT AccT;
    AccT total = AccT();  // 假设AccT()实际上生成了一个0值
    while (beg != end){

        total += *beg;
        ++beg;
    }
    return total;
}

#endif //UNTITLED_ACCUM1_H

运行main函数，生成正确：
在这里插入图片描述
总体来说，上面的修改增加了一个非常有用的机制，从而可以自定义我们的算法。进一步来说，如果有新的类型要使用accum()模板，那么只需要声明AccumulationTraits模板的一个新的显示特化来关联Acct和该类型即可。另外，任何类型都可以和Acct进行关联，来实现这个trait。

value trait

到目前位置，trait可以用来表示：‘主’类型所关联的一些额外的类型信息。本节中将说明这个额外的信息并不局限于类型，常数和其他类型的值也可以和一个类型进行关联

在上面的例子中，accum()模板使用了缺省构造函数的返回值来初始化结果变量(即total)，而且我们期望该返回值是一个类似0的值

  AccT total = AccT();  // 假设AccT()实际上生成了一个0值

显然，我们并不能保证上面的构造函数会返回一个符合条件的值，而且，类型Acct也不一定具有一个缺省构造函数。

对此，我们为AccumulationTraits添加一个value trait来解决这个问题：

#ifndef UNTITLED_ACCUMTRAITS_H
#define UNTITLED_ACCUMTRAITS_H


template<typename T>
class AccumulationTraits;

template<>
class AccumulationTraits<char>{
public:
    typedef int AccT;
    static AccT const zero = 0;
};

template<>
class AccumulationTraits<short>{
public:
    typedef int AccT;
    static AccT const zero = 0;
};

template<>
class AccumulationTraits<int>{
public:
    typedef long AccT;
    static AccT const zero = 0;
};

template<>
class AccumulationTraits<unsigned int>{
public:
    typedef unsigned long AccT;
    static AccT const zero = 0;
};

template<>
class AccumulationTraits<float>{
public:
    typedef double AccT;
    constexpr static AccT const zero = 0.0;
};

#endif //UNTITLED_ACCUMTRAITS_H

在上面的代码中，新trait是一个常量，而常量是在编译期求值的。因此，模板修改如下：

#ifndef UNTITLED_ACCUM1_H
#define UNTITLED_ACCUM1_H
#include "accumtraits.h"

template<typename T>
inline
typename AccumulationTraits<T>::AccT accum(T const * beg, T const *end){
    typedef typename AccumulationTraits<T>::AccT AccT;
    AccT total = AccumulationTraits<T>::zero;
    while (beg != end){

        total += *beg;
        ++beg;
    }
    return total;
}

#endif //UNTITLED_ACCUM1_H

在上面的代码中，total的初始化是这样的：

 AccT total = AccumulationTraits<T>::zero;

但是，这个方案有一个缺点：在所在类的内部，C++只允许我们对整型和枚举类型初始化成静态成员变量，而对于比如浮点型等其他类型就不能用上面的方案，比如下面的特化是错误的
在这里插入图片描述
对于这个问题，一个直接的解决方案就是不在所在类的内部定义这个value trait， 而在类外进行初始化，如下
在这里插入图片描述
不推荐这种做法，我们趋向于实现下面这种value trait，而且并不需要保证内联成员函数返回的必须是整形值：

#ifndef UNTITLED_ACCUMTRAITS_H
#define UNTITLED_ACCUMTRAITS_H


template<typename T>
class AccumulationTraits;

template<>
class AccumulationTraits<char>{
public:
    typedef int AccT;
    static AccT  zero(){
        return 0;
    } ;
};

template<>
class AccumulationTraits<short>{
public:
    typedef int AccT;
    static AccT  zero(){
        return 0;
    } ;
};

template<>
class AccumulationTraits<int>{
public:
    typedef long AccT;
    static AccT  zero(){
        return 0;
    } ;
};

template<>
class AccumulationTraits<unsigned int>{
public:
    typedef unsigned long AccT;
    static AccT  zero(){
        return 0;
    } ;
};

template<>
class AccumulationTraits<float>{
public:
    typedef double AccT;
    static AccT  zero(){
        return 0;
    } ;
};


#endif //UNTITLED_ACCUMTRAITS_H

模板改成：

#ifndef UNTITLED_ACCUMTRAITS_H
#define UNTITLED_ACCUMTRAITS_H


template<typename T>
class AccumulationTraits;

template<>
class AccumulationTraits<char>{
public:
    typedef int AccT;
    static AccT  zero(){
        return 0;
    } ;
};

template<>
class AccumulationTraits<short>{
public:
    typedef int AccT;
    static AccT  zero(){
        return 0;
    } ;
};

template<>
class AccumulationTraits<int>{
public:
    typedef long AccT;
    static AccT  zero(){
        return 0;
    } ;
};

template<>
class AccumulationTraits<unsigned int>{
public:
    typedef unsigned long AccT;
    static AccT  zero(){
        return 0;
    } ;
};

template<>
class AccumulationTraits<float>{
public:
    typedef double AccT;
    static AccT  zero(){
        return 0;
    } ;
};


#endif //UNTITLED_ACCUMTRAITS_H

很明显，trait可以代表更多的类型。trait可以是一个机制，用于提供accum()所需要的，关于元素类型的所有必要信息：实际上，这个元素类型就是调用accum()的类型，即模板参数的类型。下面是trait概念的关键部分：trait提供了一个配置具体元素(通常是类型)的途径，而该途径主要用于泛型计算

参数化trait

上面所说的trait被称为fixed trait，因为一旦定义了这个分类的trait，就不能在算法中对它进行改写。

原则上讲，参数化trait主要的目的在于：添加一个具有缺省值的模板参数，而且该缺省值是由我们前面所介绍的trait模板决定的。在这种具有缺省值的情况下，许多用户就可以不需要提供这个额外的模板实参，但是对于有特殊需求的用户，也可以改写这个预设的和类型。

#ifndef UNTITLED_ACCUM1_H
#define UNTITLED_ACCUM1_H
#include "accumtraits.h"

template <typename T,
        typename AT = AccumulationTraits<T> >
class Accum {
public:
    static typename AT::AccT accum (T const* beg, T const* end) {
        typename AT::AccT total = AT::zero();
        while (beg != end) {
            total += *beg;
            ++beg;
        }
        return total;
    }
};

#endif //UNTITLED_ACCUM1_H


#include <iostream>
#include <accum1.h>

using namespace std;

int main()
{
    int num[] = { 1, 2, 3, 4, 5 };

    std::cout << "the average value of the integer value is "
    << Accum<int>::accum(&num[0], &num[5]) / 5 << "\n";


    char name[] = "templates";
    int length = size(name) - 1;

    std::cout << "the average value of the characters value is "
              << Accum<char>::accum(&name[0], &name[length]) / length << "\n";
}

policy和policy类

在上面的例子中，我们对序列中的给定值进行了求和，实际上，我们还可以对它们进行求积；如果这些值是字符串的话，还可以对它们进行连接等操作。在这所有的情况中，针对accum()的所有操作，唯一需要改变的只是total += *beg()。于是我们把这个操作称为accum()过程中的一个policy。因此，一个policy类就是一个提供了一个接口的类，该接口能够在算法中应用一个或者多个policy。

我们先来用policy改写上面的操作。引入一个SumPolicy类：

#ifndef UNTITLED_SUMPOLICY_H
#define UNTITLED_SUMPOLICY_H

class SumPolicy{
public:
    template<typename T1, typename T2>
    static void accumulate(T1& total, T2 const & value){
        total += value;
    }
};

#endif //UNTITLED_SUMPOLICY_H

在上面中，我们把policy中实现了一个具有成员函数模板的普通类(也就是说，类本身不是模板，而且该成员函数是隐式内联的)。然后我们在accum模板中使用它：

#ifndef UNTITLED_ACCUM1_H
#define UNTITLED_ACCUM1_H
#include "accumtraits.h"
#include "sumpolicy.h"

template <typename T,
        typename Policy = SumPolicy,
        typename Traits = AccumulationTraits<T> >
class Accum {
public:
    typedef typename Traits::AccT AccT;
    static AccT accum (T const* beg, T const* end) {
        AccT total = Traits::zero();
        while (beg != end) {
            Policy::accumulate(total, *beg);
            ++beg;
        }
        return total;
    }
};

#endif //UNTITLED_ACCUM1_H

使用：

#include <iostream>
#include <accum1.h>

using namespace std;

int main()
{
    int num[] = { 1, 2, 3, 4, 5 };

    std::cout << "the average value of the integer value is "
    << Accum<int, SumPolicy>::accum(&num[0], &num[5]) / 5 << "\n";


    char name[] = "templates";
    int length = size(name) - 1;

    std::cout << "the average value of the characters value is "
              << Accum<char>::accum(&name[0], &name[length]) / length << "\n";
}

在这里插入图片描述
我们可以指定其他的Policy，就可以进行不同的计算。下面我们来看一个例子：

#include <iostream>
#include <accum1.h>

using namespace std;
class MultPolicy {
public:
    template<typename T1, typename T2>
    static void accumulate (T1& total, T2 const& value) {
        total *= value;
    }
};

int main()
{
    int num[] = { 1, 2, 3, 4, 5 };

    std::cout << "the average value of the integer value is "
    << Accum<int, MultPolicy>::accum(&num[0], &num[5]) / 5 << "\n";
    
}

结果不对：
在这里插入图片描述
这是因为对初始值选择造成的：求积时初始值不能为0. 这个现象说明了：不同的trait和不同的policy应该是相互交互的，我们应该用更加谨慎的态度来对待模板设计

另：并不是所有的问题都必须有trait和policy来解决的。比如，C++标准库的accumulate函数就把这个初值作为函数调用的第三个实参

成员模板和模板的模板参数

上面我们把SumPolicy和MultPolicy实现为具有成员模板的普通类。另外，我们也可以使用类模板来设计这个policy class接口，而这个policy class也就被用作模板的模板实参：

#ifndef UNTITLED_SUMPOLICY_H
#define UNTITLED_SUMPOLICY_H
template<typename T1, typename T2>
class SumPolicy{
public:
    static void accumulate(T1& total, T2 const & value){
        total += value;
    }
};

#endif //UNTITLED_SUMPOLICY_H

为使用模板的模板参数，我们对accum做如下修改：

#ifndef UNTITLED_ACCUM1_H
#define UNTITLED_ACCUM1_H
#include "accumtraits.h"
#include "sumpolicy.h"

template <typename T,
        template<typename , typename > class Policy = SumPolicy,
        typename Traits = AccumulationTraits<T> >
class Accum {
public:
    typedef typename Traits::AccT AccT;
    static AccT accum (T const* beg, T const* end) {
        AccT total = Traits::zero();
        while (beg != end) {
            Policy<AccT, T>::accumulate(total, *beg);
            ++beg;
        }
        return total;
    }
};

#endif //UNTITLED_ACCUM1_H

使用模板：

#include <iostream>
#include <accum1.h>

int main()
{
    int num[] = { 1, 2, 3, 4, 5 };

    std::cout << "the average value of the integer value is "
    << Accum<int>::accum(&num[0], &num[5]) / 5 << "\n";

}

在这里插入图片描述
使用模板的模板参数访问policy class的优缺点：

  • 优点：借助于某个依赖于模板参数的类型，就可以很容易的让policy class携带一些状态信息（也就是静态成员变量）
  • 缺点：policy类必须被写成模板，而且接口中还定义了模板参数的确切个数，这个定义会让我们无法在policy中添加额外参数。如果如果我们希望给SumPolicy添加一个Boolean型的非类型模板实参，从而选择使用+=求和或者+求和，如果是第一种方案就可以这样写：
#ifndef SUMPOLICY_HPP
#define SUMPOLICY_HPP

template<bool use_compound_op = true>
class SumPolicy {
  public:
    template<typename T1, typename T2>
    static void accumulate (T1& total, T2 const & value) {
        total += value;
    }
};

template<>
class SumPolicy<false> {
  public:
    template<typename T1, typename T2>
    static void accumulate (T1& total, T2 const & value) {
        total = total + value;
    }
};

#endif // SUMPOLICY_HPP

而第2种方案就不能做这样的修改

组合多个trait 、 poliy

trait和policy通常都不能完全代替多个模板参数，但是它们可以减少参数的个数，并把个数限制在可控制的范围内。那如何对这些参数进行排序呢？

一个简单的策略就是根据缺省值使用频率递增的对各个参数进行排序。这就意味着：trait参数将位于 policy参数的后面，因为客户端代码中通常都会修改policy参数

运用普通迭代器进行累积

#ifndef UNTITLED_ACCUM1_H
#define UNTITLED_ACCUM1_H

#include <iterator>
template<typename Iter>
inline 
typename std::iterator_traits<Iter>::value_type
accum(Iter start, Iter end){
    typedef typename std::iterator_traits<Iter>::value_type VT;
    
    VT total = VT();
    while (start != end){
        total += *start;
        start++;
    }
    return total;
}

#endif //UNTITLED_ACCUM1_H

上面accum()仍然允许我们使用指针来调用accum(）：

#include <iostream>
#include <accum1.h>

int main()
{
    int num[] = { 1, 2, 3, 4, 5 };

    std::cout << "the average value of the integer value is "
    << accum(&num[0], &num[5]) / 5 << "\n";

}

这是因为C++标准库提供了iterator_trait。iterator_trait结构封装了迭代器的所有相关属性。由于存在一个适用于指针的局部特化，所以普通指针类型也能使用这些trait：

namespace std{
	template<typename T>
	struct iterator_traits<T*>{
		typedef T                          value_type;
		typedef ptrdiff_t                  difference_type;
		typedef random_access_iterator_tag iterator_category;
		typedef T*                         pointer;
		typedef T&                         reference;
	};
}

trait和policy的区别

policy更加注重行为，trait更加注重类型。

  • trait表示模板参数一些自然的额外属性
  • policy表示泛型函数和泛型类的一些可配置行为（通常具有被经常使用的缺省值）

相对于trait

  • trait可以是fixed trait(也就是说，不需要通过模板参数进行传递的trait)
  • trait参数通常都具有很自然的缺省值(该缺省值很少会被改写，或者是不能改写的)
  • trait参数可以紧密依赖于一个或者多个主参数
  • trait通常都是由trait模板实现的

对于policy class

  • 如果不以模板参数的形式进行传递的话，policy class几乎不起作用
  • policy参数并不需要缺省值，而且通常都是显示指定这个参数（尽管很多泛型组件都配置了使用频率很高的缺省policy）
  • policy参数和属于同一个模板的其他参数通常都是正交的
  • policy class 一般都包含了成员函数
  • policy既可以使用普通类实现，也可以使用模板实现
OceanStar的学习笔记
关注
专栏目录
最好的 C++ 模板元编程干货！
萧海的博客
07-01 348
链接 | https://www.cnblogs.com/liangliangh/p/4219879.html 所谓元编程就是编写直接生成或操纵程序的程序，C++ 模板给 C++ 语言提供了元编程的能力，模板使 C++ 编程变得异常灵活，能实现很多高级动态语言才有的特性（语法上可能比较丑陋，一些历史原因见下文）。普通用户对 C++ 模板的使用可能不是很频繁，大致限于泛型编程，但一些系统级的代码，尤其是对通用性、性能要求极高的基础库（如 STL、Boost）几乎不可避免的都大量地使用 C++ 模板，一个稍.
C++模版的本质
C语言与CPP编程的博客
03-18 921
我想知道上帝的構思，其他的都祇是細節。 ...
C++ STL : Traits
wnznw的博客
03-24 206
1 traits 概念引入 迭代器所致对象的类型 : value_type Promble : temeplate参数推导机制可以推导出函数参数,但是不能推导出函数返回值 使用声明内嵌的方法解决 template<class T> struct MyIter { typedef T value_type;//传进来T是value_type,用T*表示迭代器 T* ptr; MyIter(T* p = 0) : ptr(p){} T& operato
C++ Traits
pjzjchn的专栏
06-09 628
Traits技术可以用来获得一个 类型 的相关信息的。 首先假如有以下一个泛型的迭代器类，其中类型参数 T 为迭代器所指向的类型：template typename T>class myIterator{ ...};当我们使用myIterator时，怎样才能获知它所指向的元素的类型呢？我们可以为这个类加入一个内嵌类型，像这样：template typename T>class myIterator
C++中的模板特性（Traits）
最新发布
qq_41328432的博客
08-01 468
C++中的模板特性（Traits）是一种常见的技术，用于在编译时提取或操作类型信息。Traits类提供了一种灵活且可扩展的方法，用于实现类型特定的行为和元编程。
Step By Step(C++模板Trait)
飞空静渡
09-12 1040
Trait是C++模板设计的一个基本应用技巧，通过应用Trait模板参数，可以在工业强度的程度设计中既保证了程序的灵活性，同时也有效的减少了类型参数的数量。对于普通函数而言，如果想要对该函数的功能进行更为细粒化的控制，一个主要的方法便是为该函数增加更多的参数，而函数体内的逻辑代码则会根据参数值的不同而选择不同的逻辑分支，最终返回不同的结果。一个极端的现象是函数的参数过多，而且并不是每个参数都会为每
traits：Traits技术初探
weixin_34082177的博客
03-25 240
概述:traits是一种特性萃取技术 color: #663300; font-family: 宋体; padding: 0px; margin: 0px;"&gt;,它在Generic Programming中被广泛运用,常常被用于使不同的类型可以用于相同的操作,或者针对不同类型提供不同的实现.traits在实现过程中往往需要用到以下三种C++的基本特性:enumtypedef...
c++ template(9)trait和Policy
weixin_33974433的博客
03-29 100
  先看一个Demo: 累加序列： template &lt;typename T&gt; inline T accum (T const* beg, T const* end) { T total = T(); // assume T() actually creates a zero value while (beg != end) { ...
泛型编程技巧(trait_Policy)
10-01
详细讲解了关于c++模板技术中的trait和policy技术，很值得一看。
Effective C++ 学习笔记 第七章：模板与泛型编程
SiberiaBear的专栏
09-09 401
第一章见 Effective C++ 学习笔记 第一章：让自己习惯 C++ 第二章见 Effective C++ 学习笔记 第二章：构造、析构、赋值运算 第三章见 Effective C++ 学习笔记 第三章：资源管理 第四章见 Effective C++ 学习笔记 第四章：设计与声明 第五章见 Effective C++ 学习笔记 第五章：实现 第六章见 Effective C++ 学习笔记 第六章：继承与面向对象设计 文章目录条款 41：了解隐式接口和编译期多态总结 条款 41：了解隐式接口和编译期.
C++ traits
道法自然
03-31 796
最近和一个朋友闲聊的时候他对我说一个人对C++的理解很多种境界，朋友不是个喜欢吹牛的人，于是听他细说，觉得很是有道理。 想写一篇C++ traits方面的文章已经有一段时间了，但是说实话traits这项技术确实有些晦涩，很担心写完了达不到期望的效果，于是每每试图以简炼的文字表达，慢慢的就等到了今天。 先说说我为什么专门对这项技术写一篇文章吧。记得当时在看STL/boost代码的时候经常遇到tr
c++_traits.pdf
08-29
c++_traits Classes which encapsulate properties of types Is this an integer type? An arithmetic type? A pointer type?... Closely related to partial specialization
活用C++模板之traits
weixin_34221036的博客
08-21 851
介绍traits的文章很多，但感觉大部分文章的说明都很晦涩难懂，把一个并不很复杂的C++模板的应用描述的过于复杂。忍不住想把自己的理解跟大家分享一下，或许我也只是掌握了一点traits的皮毛而已，但也希望这些皮毛能略微抓住你的眼球，带给你一些启发。 首先，介绍traits前，回味一下C++的模板及应用，如果你脑海里浮现出的只是为实现一些函数或类的重用的简单模板应用，那我要告诉你，你o...
c++ trait
Stroller
08-13 1133
#include struct no_move{};//两个marker类型 struct has_move{}; struct myValueType{ public: void move(){std::cout"move a myValueType obj."std::endl;} }; template typename T> struct traits{ typede
C/C++编程：policy trait
OceanStar的博客
04-23 158
property trait：用于确定模板参数的一些属性。比如这些参数表示什么类型，在混合类型的操作中，应该提升哪一个类型等等。 policy trait：定义如何对待这些类型。 只读的参数类型 在C/C++中，函数调用实参在缺省情况下都是以传值方式进行传递的。也就是说，由调用者计算出来的实参值需要被拷贝到被调用者所控制的位置中；但是如果参数是很大的数据结构，这种拷贝非常耗资源；因此，对于这种数据，应该传递const引用；如果参数是很小的结构，从性能的观点看，究竟采用何种机制依赖于代码所在的实际体系结果.
c++ trait和policy(c++ template这本书)
LiQian06336的博客
10-07 176
trait template <typename T> T accum(T const* beg,T const* end) { T total = T();//假设T事实回生成一个等于0的值 while(beg!=end) { total += *beg;// 问题是假如 T类型 是char ，和就会溢出 beg++; } return total; } 把上面的和的类型改为 AccumTraits<T>::Acct ,简单方法再传一个模板参..
C++ trait example
windowsLearner的专栏
07-06 645
an example modified #include using namespace std; template class AccumulationTraits; template class AccumulationTraits{ public:     typedef int AccT;     static AccT zero(){         ret
trait和policy
Jack Zheng's Blog
04-05 333
什么是trait和policy： 用一个例子来说明： AccumutionTraits头文件： #ifndef ACCUMUTIONTRAITS #define ACCUMUTIONTRAITS //与T相关的Trait都被定义在这里了 template<typename T> class AccumutionTraits; //char template<> ...
深入理解C++模板元编程：揭示 Trait 的秘密
"模板元编程是C++中的一种高级技术，它允许在编译时进行计算和代码生成。C++模板在设计之初并未考虑模板元编程，但随着Erwin Unruh在1994年的发现，这个概念逐渐发展起来，成为C++程序员探索和创新的重要领域。模板...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值