STL萃取(Traits)机制

STL源码剖析:从组态、类型萃取到内存分配器的底层实现 C++标准模板库(STL)是泛型编程的核心组件,其设计哲学建立在类型安全、性能优化和可移植性之上。理解STL的底层实现原理,需要从编译器适配、模板元编程和内存管理等基础概念入手。类型萃取(Type Traits)作为模板元编程的关键技术,允许在编译期获取类型属性,为算法选择最优实现路径,例如在`std::copy`中根据POD类型判断是否使用`memcpy`。内存分配器(Allocator)则抽象了内存管理,分离对象构造与内存分配,通过`placement new`和类型萃取实现高效资源管理。这些机制共同支 阅读详情

问题前述

我们希望有一个类,并有一个成员方法 GetSum 可以完成数组元素的一系列运算。具体看如下代码:

#include <iostream>
using namespace std;

//处理int类型
class IntArray
{
public:
    IntArray()
    {
        a = new int[10];
        for (int i = 0; i < 10; ++i)
        {
            a[i] = i + 1;
        }
    }
    ~IntArray()
    {
        delete[] a;
    }

    int GetSum(int times)
    {
        int sum = 0;
        for (int i = 0; i < 10; ++i)
            sum += a[i];
        cout << "int sum=" << sum << endl;
        return sum * times;
    }

private:
    int *a;
};

//处理float类型
class FloatArray
{
public:
    FloatArray()
    {
        f = new float[10];
        for (int i = 1; i <= 10; ++i)
        {
            f[i - 1] = 1.0f / i;
        }
    }
    ~FloatArray()
    {
        delete[] f;
    }
    float GetSum(float times)
    {
        float sum = 0.0f;
        for (int i = 0; i < 10; i++)
            sum += f[i];
        cout << "float sum=" << sum << endl;
        return sum * times;
    }

private:
    float *f;
};

//通过模板类型推导,调用不同类型的GetSum函数
template <class T>
class Apply
{
public:
    float GetSum(T &t, float inarg)
    {
        return t.GetSum(inarg);
    }
};

int main()
{
    Apply<IntArray> iapply;
    IntArray iarr;
    cout << iapply.GetSum(iarr, 2) << endl;

    Apply<FloatArray> fapply;
    FloatArray farr;
    cout << fapply.GetSum(farr, 3) << endl;

    return 0;
}

虽然可以得到结果,但是并不完美,因为所有的返回值和传入的参数类型都使用了 float。将 int 类型也强转为 float 类型了。我们无法返回 IntArray 或者 FloatArray 中处理器的数据的类型。因为 int 可以强转,侥幸使得程序能运行,但是如果是复杂的类型,就行不通了。

这个时候,就需要 traits 技术了,讲完了 traits 后,再回来看这个问题的解决方法。

traits 概念

Traits,又被叫做特性萃取技术,说得简单点就是提取“被传进的对象”对应的返回类型,让同一个接口实现对应的功能。因为STL的算法和容器是分离的,两者通过迭代器链接。算法的实现并不知道自己被传进来什么。萃取器相当于在接口和实现之间加一层封装,来隐藏一些细节并协助调用合适的方法,这需要一些技巧(例如,偏特化)。总的来说,Traits 的作用主要是用来为使用者提供类型信息。

trains 技术需要用到的技术有:模板特化及 typename 关键字等。

模板特化(Template Specialization)

模板特化分为模板全特化和模板偏特化。

类模板全特化:

有时为了需要,针对特定的类型,需要对模板进行特化,也就是特殊处理。例如 stack 类模板针对 bool类型。因为实际上 bool 类型只需要一个二进制位,就可以对其进行存储,使用一个字或者一个字节都是浪费存储空间的。

template <typename T>
class stack
{
    //...
};

template <>
class stack<bool>
{
    //...
};

类模板的偏特化:

模板的偏特化是指需要根据模板的某些但不是全部的参数进行特化。例如 C++ 标准库中的类 vector 的定义:

template <class T, class Allocator>
class vector
{
    //...
};

template <class Allocator>
class vector<bool, Allocator>
{
    //...
};

这个偏特化的例子中,一个参数被绑定到 bool 类型,而另一个参数仍未绑定需要由用户指定。

typename 关键字

先看一个问题,以下模板的声明中, class 和 typename 有什么不同?

template<class T> class Test;
template<typename T> class Test;

答案:没有不同。

然而,C++ 并不总是把 class 和 typename 视为等价。有时候我们一定得使用 typename。

默认情况下,C++ 语言假定通过作用域运算符访问的名字不是类型。因此,如果我们希望使用一个模板类型参数的类型成员,就必须显式告诉编译器该名字是一个类型。我们通过使用关键字 typename 来实现这一点:

template<typename T>
typename T::value_type top(const T &c)
{
    if (!c.empty())
        return c.back();
    else
        return typename T::value_type();
}

top 函数期待一个容器类型的实参,它使用 typename 指明其返回类型,并在 c 中没有元素时生成一个初始值的默认元素,并返回给调用者。

在这里我们只需要记住一点,当我们希望通知编译器一个名字表示类型时,必须使用关键字 typename,而不能使用 class。

实现 Traits Classes

完了背景知识,我们正式进入 traits 的关键地带。

我们知道,在 STL 中,容器与算法是分开的,彼此独立设计,容器与算法之间通过迭代器联系在一起。那么,算法是如何从迭代器类中萃取出容器元素的类型的?没错,这正是我们要说的 traits classes 的功能。

迭代器所指对象的类型,称为该迭代器的 value_type。我们来简单模拟一个迭代器 traits classes 的实现。

template <class IterT>
struct my_iterator_traits
{
    typedef typename IterT::value_type value_type;
};

my_iterator_traits 其实就是个类模板,其中包含一个类型的声明。有上面 typename 的基础,相信大家不难理解 typedef typename IterT::value_type value_type; 的含义:将迭代器的 value_type 通过 typedef 为 value_type。

对于 my_iterator_traits,我们还有一个一个偏特化版本。

template <class IterT>
struct my_iterator_traits<IterT *>
{
    typedef IterT value_type;
};

即如果 my_iterator_traits 的实参为指针类型时,直接使用指针所指元素类型作为 value_type。

为了测试 my_iterator_traits 能否正确萃取迭代器元素的类型,我们先编写以下的测试函数。

void fun(int a) {
    cout << "fun(int) is called" << endl;
}

void fun(double a) {
    cout << "fun(double) is called" << endl;
}

void fun(char a) {
    cout << "fun(char) is called" << endl;
}

我们通过函数重载的方式,来测试元素的类型。

测试代码如下:

my_iterator_traits<vector<int>::iterator>::value_type a;
fun(a); // 输出 fun(int) is called

my_iterator_traits<vector<double>::iterator>::value_type b;
fun(b); // 输出 fun(double) is called

my_iterator_traits<char *>::value_type c;
fun(c); // 输出 fun(char) is called

为了便于理解,我们这里贴出 vector 迭代器声明代码的简化版本:

template <typename T, ...>
class vector
{
public:
    class iterator
    {
    public:
        typedef T value_type;
        //...
    };
    //...
};

我们来解释 my_iterator_traits<vector<int>::iterator>::value_type a; 语句的含义。

vector<int>::iterator 为 vector<int> 的迭代器,该迭代器包含了 value_type 的声明,由 vector 的代码可以知道该迭代器的value_type 即为 int 类型。

接着,my_iterator_traits<vector<int>::iterator> 会采用 my_iterator_traits 的通用版本,即 my_iterator_traits<vector<int>::iterator>::value_type 使用 typename IterT::value_type 这一类型声明,这里 IterT 为 vector<int>::iterator,故整个语句萃取出来的类型为 int 类型。

对 double 类型的 vector 迭代器的萃取也是类似的过程。

而 my_iterator_traits<char*>::value_type 则使用 my_iterator_traits 的偏特化版本,直接返回 char 类型。

由此看来,通过 my_iterator_traits ,我们正确萃取出了迭代器所指元素的类型。

总结一下我们设计并实现一个 traits class 的过程:

  1. 确认若干我们希望将来可取得的类型相关信息。例如,对于上面的迭代器,我们希望取得迭代器所指元素的类型。
  2. 为该信息选择一个名称。例如,上面我们起名为 value_type。
  3. 提供一个 template 和一组特化版本(例如,我们上面的 my_iterator_traits),内容包含我们希望支持的类型相关信息。

问题解决

通过上面对 traits 的描述,现在用 traits 解决最初遇到的问题。

#include <iostream>
using namespace std;

//处理int类型
class IntArray
{
public:
    IntArray()
    {
        a = new int[10];
        for (int i = 0; i < 10; ++i)
        {
            a[i] = i + 1;
        }
    }
    ~IntArray()
    {
        delete[] a;
    }

    int GetSum(int times)
    {
        int sum = 0;
        for (int i = 0; i < 10; ++i)
            sum += a[i];
        cout << "int sum=" << sum << endl;
        return sum * times;
    }

private:
    int *a;
};

//处理float类型
class FloatArray
{
public:
    FloatArray()
    {
        f = new float[10];
        for (int i = 1; i <= 10; ++i)
        {
            f[i - 1] = 1.0f / i;
        }
    }
    ~FloatArray()
    {
        delete[] f;
    }
    float GetSum(float times)
    {
        float sum = 0.0f;
        for (int i = 0; i < 10; i++)
            sum += f[i];
        cout << "float sum=" << sum << endl;
        return sum * times;
    }

private:
    float *f;
};

//基础模板
template <class T>
class NumTraits
{
};

//模板特化
template <>
class NumTraits<IntArray>
{
public:
    typedef int resulttype;
    typedef int inputargtype;
};

template <>
class NumTraits<FloatArray>
{
public:
    typedef float resulttype;
    typedef float inputargtype;
};

template <class T>
class Apply2
{
public:
    typename NumTraits<T>::resulttype GetSum(T &obj, typename NumTraits<T>::inputargtype inputarg)
    {
        return obj.GetSum(inputarg);
    }
};

int main()
{
    IntArray iarr;
    FloatArray farr;

    Apply2<IntArray> ai2;
    Apply2<FloatArray> af2;

    cout << "2整型数组的和3倍:" << ai2.GetSum(iarr, 3) << endl;
    cout << "2浮点数组的和3.2倍:" << af2.GetSum(farr, 3.2f) << endl;

    return 0;
    return 0;
}

得到的结果如下:

$ ./test 
2整型数组的和3倍:int sum=55
165
2浮点数组的和3.2倍:float sum=2.92897
9.3727

可以看到,我们使用了一个额外的 NumTraits 的类型萃取器,通过这个萃取器我们便可以得到对应的类型的返回值类型和传入值类型,完美的解决了问题。

参考:
细说 C++ Traits Classes

“深入掌握C++ STL中的Traits编程技巧“,在使用STL时,Traits是一种非常有用的编程技巧。它允许您以一种通用的方式使用STL组件,并自动适应不同... 然后,我们定义了一个序列化函数serialize,该函数接受任何类型的参数,并使用我们定义的通用序列化器来序列化它们。总之,Traits编程技巧是STL中非常有用的一种技术,它可以帮助我们以通用的方式使用STL组件,并自动适应不同类型的数据。对于不同类型的数据结构,序列化方式也不同。例如,对于一个整数数组,我们可以使用内存中的连续字节表示数据,但对于一个对象,我们需要逐个序列化其成员变量。然后,我们定义了一个比较函数compare,该函数接受两个任意类型的参数,并使用我们定义的通用比较器来比较它们。 阅读详情

相关推荐

深入剖析一个卷积块(ConvBlock)

深入剖析一个卷积块(ConvBlock)

qq_45670407的博客 1927

STL中的traits技术

使用STL中的advance和迭代器类型来讲解trait技术 1.迭代器类型 熟悉的迭代器类型:输入、输出、前向、双向、随机。 c++标准程序库分别提供专属的卷标结构(tag struct),一个空的结构体来标志具体是哪种类型迭代器,如下: // ITERATOR STUFF (from <iterator>) // ITERATOR TAGS (from...

u012138730的专栏 1464

monocle使用sct整合数据integration还是rna中的counts数据 轨迹分析 拟时序

【代码】monocle使用sct整合数据integration还是rna中的counts数据 轨迹分析 拟时序。

生信小博士的博客 1049

stl的萃取机制

stl类型萃取机制

weixin_45157276的博客 316

Dify平台+Excel批量分析实战:5分钟搞定大模型数据处理(附完整代码)

本文详细介绍了如何利用Dify平台的数据集功能,结合Excel和Python脚本,快速构建大模型批量数据处理流水线。通过实战案例演示,读者可在5分钟内完成客户反馈情感分析、产品文案生成等任务,实现从原始数据到结构化洞察的高效转化,极大提升工作效率。

3a9bq4r8t2y的博客 318

硬件原理图分析

文章目录1 硬件原理图分析1.1 MCU部分1.2 NB部分1.3 电源部分 1 硬件原理图分析 1.1 MCU部分 MCU接口部分没啥需要注意,都是常规操作。 1.2 NB部分 U4是用来防静电的。 由于NB的以上几个引脚只支持1.8V,所以这里需要3.3V转1.8V的电路。只要把握住谁改变电平就好分析是怎么实现电平转换的了。 1.3 电源部分 图中的MOS是用来实现USB和电池同时插入时只能USB供电功能的。 ...

木子皿--啥都不会的菜鸟 8178

STL源码剖析(七)traits机制

STL源码剖析(七)traits机制 文章目录STL源码剖析(七)traits机制一、为什么需要traits机制?二、iterator traits2.1 iterator traits的定义2.2 iterator traits相关的函数三、type traits 一、为什么需要traits机制? traits可以称为萃取机,可以通过它来获取迭代器的一些信息,在STL算法中发挥巨大的作用 如下面...

JT同学的博客 848

基于STM32H750的便携式双通道示波器与信号发生器AFE设计

示波器和信号发生器是电子测量与嵌入式系统调试的基础仪器,其核心在于模拟前端(AFE)对宽动态范围、高精度采样与低失真输出的协同实现。原理上需兼顾输入信号调理(衰减/放大/偏置)、ADC/DAC接口匹配、触发同步及电源完整性设计。技术价值体现在以低成本器件达成±15V输入/±10V输出、16位等效采样精度与85kHz带宽的工程平衡。典型应用场景包括电机驱动波形观测、传感器信号验证、电源环路测试及通信电平分析。本方案聚焦STM32H750平台,深度融合硬件拓扑与片上资源特性,为嵌入式教学与原型开发提供可复现、易

weixin_35755188的博客 111

STL-萃取技术traits技术

设计适当的型别,是迭代器的责任。设计适当的迭代器,是容器的责任。

谢谢大家的关注 957

使用 Simulink/Simscape Electrical/Stateflow,构建一个并网逆变器短路故障动态响应与恢复策略仿真模型

本文基于Simulink平台,详细介绍了并网逆变器短路故障的动态响应与恢复策略仿真方法。主要内容包括:1)构建包含热模型的高精度逆变器模型;2)模拟IGBT击穿和桥臂直通两种短路故障;3)设计基于Stateflow的微秒级快速保护逻辑;4)实现放电、去磁、自检、重启的完整恢复流程。仿真结果表明,所提出的保护方案能在200μs内有效限制故障电流,避免器件永久损坏,并通过标准化恢复流程实现系统安全重启。文章还探讨了硬件保护协同、多级保护和预测保护等高级策略,为电力电子系统安全防护提供了实用解决方案。

xiaoheshang_123的博客 107

MIT液态神经网络(LNN)深度研究:原理、应用与未来

液态神经网络(Liquid Neural Networks, LNNs)代表了人工智能领域,特别是神经网络架构设计中的一次范式转移。它从根本上挑战了传统深度学习模型依赖大规模参数和静态架构的惯例,转而寻求一种更为动态、高效且受生物神经系统启发的计算范式。LNN的核心创新在于其将神经网络的计算过程从离散的、基于时间步的更新,转变为连续的、由微分方程驱动的动态系统演化。这种转变不仅赋予了模型前所未有的适应性和鲁棒性,还使其在处理复杂的时序数据和因果推断任务时表现出色。本章节将深入剖析LNN的技术原理,从其核心的

步子哥的博客 2593

STL 萃取(Traits)机制剖析

模板特化 在将萃取机制之前,先要说明模板特化 当有两个模板类,一个是通用泛型模板,一个是特殊类型模板,如果创建一个特殊类型的对象,会优先调用特殊的类型模板类,例如: template <typename T> //泛型模板 class MyClass { public: MyClass() { cout << "T MyClas...

WindSun's Blog 200

PCL 三维重建 泊松曲面重建算法

本文介绍了基于泊松曲面重建算法的三维重建过程。泊松重建是一种利用点云数据生成三维表面的算法,它基于点云的法线估计和泊松方程的求解,能够生成光滑且连续的曲面模型。该方法适用于复杂形状和细节的表面重建。

纵马踏花向自由 1090

STL——萃取机制(Traits)

我将从定义、技术实现、设问形式、实例总结来阐述我对于萃取机制的理解。 1.定义:traits中文意思是特性,它通过提取不同类的共性,使得可以统一处理。 2.技术实现:traits运用显式模板特殊化将代码中因为类型不同而发生变化的片段提取出来,用统一的接口来包装,并通过traits模板类公开的接口间接访问相应的类。 3.设问形式: 问题1:什么是显式模板特殊化呢? 答:模板特殊化...

weixin_30807677的博客 297

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

判断void*参数类型_C++|深入理解STL类型萃取机制(type traits)

我们知道Traits是C++语言的一种高级特性。STL首先利用Traits技术对迭代器的特性做出规范,制定出iterator_traits(参考:STL算法如何萃取(traits)迭代器型别(value_type)?)。后来SGI STL把它应用在迭代器以外的地方, 就有了type_traits。函数、类或者一些封装的通用算法中的某些部分会因为数据类型不同而导致处理或逻辑不同(而我们又不希望因为数...

weixin_39627361的博客 339

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

bool类型0和1真假_C++|深入理解STL类型萃取机制(type traits)

我们知道Traits是C++语言的一种高级特性。STL首先利用Traits技术对迭代器的特性做出规范,制定出iterator_traits(参考:STL算法如何萃取(traits)迭代器型别(value_type)?)。后来SGI STL把它应用在迭代器以外的地方, 就有了type_traits。函数、类或者一些封装的通用算法中的某些部分会因为数据类型不同而导致处理或逻辑不同(而我们又不希望因为数...

weixin_32968155的博客 456

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

STL之traits编程技法

traits编程技法利用了“内嵌型别”的编程技巧与编译器的template参数推导功能。 下面主要看看利用traits编程技法实现的迭代器萃取机制。 5种迭代器类型定义: struct input_iterator_tag {}; struct output_iterator_tag {}; struct forward_iterator_tag : public input...

weixin_33939843的博客 305

STL中的traits机制

STL中的traits机制  Traits技术是STL iterator设计中非常重要的一枚棋子,它主要依靠偏特化(template Partial Specialization)进行处理。比如templatestruct MyClass {...};它的一个偏特化形式可以为:templatestruct MyClass {...};当然还有其它形式的表达方

ToDoList的专栏 990

STL 源码剖析 总结索引 | 第三章:迭代器(iterators)概念与 traits 编程技法

迭代器的设计思维;迭代器是一种智能指针;迭代器相应类型;Traits:value type,difference type,reference type,pointer type,iterator_category;std::iterator的保证及源码;__type_traits

AsherGu的博客 859

《STL源码剖析》traits技法

包括 1】:萃取迭代器特性:iterator_traits 2】:萃取型别特性__type_traits 萃取迭代器特性 原因—作用: 因为:模板参数推导机制无法推导函数的返回值型别; 所以:使用内嵌型别声明  typedef T value_type 又因为:原生指针无法定义内嵌型别 所以:对原生指针T*,指向const的指针(常对象的指针const T *)进行模板特化 --

我的E家 1305

第三章-迭代器(Iterators)概念与Traits编程技法

在STL中,是连接容器(Containers)与算法(Algorithms)的“桥梁”,而则是迭代器实现泛型能力的“幕后推手”。两者共同支撑了STL“算法与容器解耦”的核心设计,让一套算法能适配所有容器。

u010632343的博客 968

关于C++类型萃取

关于C++类型萃取   最近在看《STL源码剖析》,关于C++类型萃取的问题看了几天,感觉还是有些疑惑。   如果在C++中声明一个“以迭代器所指对象的类型”为类别,应当如何做。C++只支持sizeof(),并未支持typeof()!即便动用RTTI性质中的typ...

dianchifu6676的博客 164

C++:Traits编程技法在STL迭代器中的应用

本文介绍了《STL源码剖析》中的迭代器章节的大部分内容,在原著的基础上加入了自己的理解。

z3256707200的博客 1470

STL迭代器traits萃取原理与工程实践

迭代器是C++泛型算法的核心抽象,其本质是统一访问不同数据结构的接口。理解迭代器需掌握两大基础机制:类型别名(typedef)用于类类型自我声明,而traits技术则实现对原生指针等内置类型的编译期特征提取。iterator_traits通过模板偏特化和SFINAE,在零运行时开销下完成value_type、iterator_category等关键类型信息的稳定萃取,支撑算法根据迭代器能力(如随机访问、双向遍历)自动选择最优实现路径。该机制广泛应用于容器适配、编译期安全校验、算法重载分发等工业级场景,是ST

weixin_30745553的博客 281
上一篇: 字符串匹配之BF与KMP算法
下一篇: C++11的Lambda函数
code_peak
博客等级 码龄5年 403粉丝 67原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

code_peak

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值