C++新经典模板与泛型编程：萃取技术中的值萃取

最新推荐文章于 2026-03-13 08:28:17 发布
原创 最新推荐文章于 2026-03-13 08:28:17 发布 · 968 阅读 · 22 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#c++ #值萃取 #萃取 #萃取技术

传入一种类型，萃取出另外一种类型


#include <iostream>

template<typename T>
struct SumFixedTraits;

template<>
struct SumFixedTraits<char>
{
	using sumT = int;
};

template<>
struct SumFixedTraits<int>
{
	using sumT = __int64;
};

template<typename T>
auto funcsum(const T* begin, const T* end)
{
	using sumT = typename SumFixedTraits<T>::sumT; 
	sumT sum{};
	for (;;)
	{
		sum += (*begin);
		if (begin == end)
			break;
		++begin;
	}
	return sum;
}

int main()
{
	int my_int_array1[] = { 10,15,20 };
	int my_int_array2[] = { 1000000000,1500000000,2000000000 };
	char my_char_array[] = "abc";
	
	std::cout << funcsum(&my_int_array1[0], &my_int_array1[2]) << std::endl;
	std::cout << funcsum(&my_int_array2[0], &my_int_array2[2]) << std::endl;
	std::cout << (int)funcsum(&my_char_array[0], &my_char_array[2]) << std::endl;


	return 0;
}

在这里插入图片描述

  • 可以看到，求和的数组元素分别是int类型和char类型，其中char类型数据可以看作范围比较窄的int类型数据。
  • 所以，这两种类型的数据都可以用sumT sum{};的形式进行零初始化，但如果数组元素是其他类型的数据（如一个类类型），那么这种零初始化的格式可能就不合适。
  • 所以，可以尝试着利用萃取技术解决这个问题。在讲解固定萃取（fixed traits）的时候，核心思想是“传入一种类型，萃取出另外一种类型”，那么，此处的值萃取（value traits）的核心思想就是“传入一种类型，萃取出一个值”。
  • 从这句话读者可以看到，传入一种类型后，萃取出来的不仅限于一种类型，也可以是一个值。

传入一种类型，萃取出一个值

  • SumFixedTraits被当作固定萃取类模板，在这里，SumFixedTraits也同时被当作值萃取类模板来使用。现在，试着把零初始化方式移入SumFixedTraits模板，这里需要给每个当前SumFixedTraits模板的特化版本增加一行代码。
template<>
struct SumFixedTraits<char>
{
	using sumT = int;
	static const sumT initValue = 0;
};

template<>
struct SumFixedTraits<int>
{
	using sumT = __int64;
	static const sumT initValue = 0;
};

在上面的代码中，initValue的值是在编译期间就确定好的，可以直接在funcsum()函数模板中使用。修改后的funcsum()代码如下（注意sum被初始化的方式发生了改变）。

// 真他娘滴经典
template<typename T>
auto funcsum(const T* begin, const T* end)
{
	// 传入一个类型，返回一个类型，这就是固定萃取的运行
	using sumT = typename SumFixedTraits<T>::sumT;

	// 传入一个类型，返回一个值，这就是值萃取的运行
	sumT sum = SumFixedTraits<T>::initValue;

	for (;;)
	{
		sum += (*begin);
		if (begin == end)
			break;
		++begin;
	}
	return sum;
}

虽然这种写法目前看不出什么问题，但是如果对一个元素类型为double的数组求和，就会出现问题。设想一下，如果要对double类型的数组元素求和，可以再给SumFixedTraits类模板增加一个特化：

template<>
struct SumFixedTraits<double>
{
	using sumT = double;
	static const sumT initValue = 0.0;
};

error C2864: SumFixedTraits<double>::initValue: 带有类内初始化表达式的静态数据成员必 须具有不可变的常量整型类型，或必须被指定为"内联"
报错的代码行是static const sumT initValue = 0.0;，看上面的报错提示，只有整型才能进行这样的初始化，浮点型不可以。但是使用C++11标准引入的constexpr关键字，发现是可以的。所以，可以修改特化类型为double类型的SumFixedTraits类模板如下。

template<>
struct SumFixedTraits<double>
{
	using sumT = double;
	static constexpr sumT initValue = 0.0;
};

完整的值萃取代码，如下


#include <iostream>

template<typename T>
struct SumFixedTraits;

template<>
struct SumFixedTraits<char>
{
	using sumT = int;
	static const sumT initValue = 0;
};

template<>
struct SumFixedTraits<int>
{
	using sumT = __int64;
	static const sumT initValue = 0;
};

// 真他娘滴经典
template<typename T>
auto funcsum(const T* begin, const T* end)
{
	// 传入一个类型，返回一个类型，这就是固定萃取的运行
	using sumT = typename SumFixedTraits<T>::sumT;

	// 传入一个类型，返回一个值，这就是值萃取的运行
	sumT sum = SumFixedTraits<T>::initValue;

	for (;;)
	{
		sum += (*begin);
		if (begin == end)
			break;
		++begin;
	}
	return sum;
}


template<>
struct SumFixedTraits<double>
{
	using sumT = double;
	static constexpr sumT initValue = 0.0;
};


int main()
{
	double my_double_array1[] = { 12.8,15.8,20.6 };
	std::cout << funcsum(&my_double_array1[0], &my_double_array1[2]) << std::endl;


	return 0;
}

在这里插入图片描述
可以看到，通过值萃取类模板的手段，分别解决了数组元素类型为int、char、double时的求和问题。但是考虑一下，如果数组元素是类类型，如何进行类类型对象的求和呢？例如，有这样一个类A（放在SumFixedTraits类模板前面）：

class A
{
public:
	A(int v1, int v2) : m_i(v1 + v2)
	{
	}
	int m_i;
};

template<typename T>
struct SumFixedTraits;

template<>
struct SumFixedTraits<A>
{
	using sumT = A;
	static const sumT initValue(0, 0);
};

编译一下，编译器会报错：
error C2131: 表达式的计算结果不是常数
说明这种初始化initValue对象的方式不可行，那么这个初始化就要放到类外。
（1）对针对类A特化的SumFixedTraits类模板中的static const sumT initValue{0,0 };代码行进行修改，代码如下。

template<>
struct SumFixedTraits<A>
{
	using sumT = A;
	static const sumT initValue; // 这是声明，不是定义
};

（2）然后在某个.cpp源文件中对initValue进行初始化，代码如下（注意写法）。
A const SumFixedTraits<A>::initValue = A{ 0,0 }; //定义并初始化
注意，不能在多个.cpp源文件中都加入上述代码，否则链接会报错，类似：
MyProject.obj : error LNK2005: "public: static class A const SumFixedTraits<class A>:: initValue" (?initValue@?$SumFixedTraits@VA@@@@2VA@@B) 已经在 myclass.obj 中定义

// A.h
#pragma once

class A
{
public:
	A(int v1, int v2) : m_i(v1 + v2)
	{
	}
	int m_i;
};

// A.cpp
#include "A.h"
#include "test.h"

A const SumFixedTraits<A>::initValue = A(0, 0); // 定义并初始化

// test.h

#include <iostream>

#include "demo.h"

template<typename T>
struct SumFixedTraits;

template<>
struct SumFixedTraits<A>
{
	using sumT = A;
	static const sumT initValue; // 这是声明，不是定义
};

template<typename T>
auto funcsum(const T* begin, const T* end)
{
	// 传入一个类型，返回一个类型，这就是固定萃取的运行
	using sumT = typename SumFixedTraits<T>::sumT;

	// 传入一个类型，返回一个值，这就是值萃取的运行
	sumT sum = SumFixedTraits<T>::initValue;

	for (;;)
	{
		sum += (*begin);
		if (begin == end)
			break;
		++begin;
	}
	return sum;
}

int main()
{
	return 0;
}

上述方
案虽然可以解决问题，但比较烦琐，在C++ 17标准中，提出了一种新的解决方案解决类似问题—inline变量。所以，修改后的针对类A特化的SumFixedTraits类模板代码如下（注意写法）。

template<>
struct SumFixedTraits<A>
{
	using sumT = A;
	//static const sumT initValue; // 这是声明，不是定义
	inline static const sumT initValue(0, 0);
};

除了上述两种解决方案，还可以采用在特化的SumFixedTraits类模板中引入静态成员函数（initValue）的方式解决问题，因为这种函数都写在特化的SumFixedTraits类模板定义中，因此都是inline的成员函数。看一看修改后的各个特化的SumFixedTraits类模板，代码如下。

// killCmake.cpp: 定义应用程序的入口点。
//

#include "killCmake.h"

using namespace std;

class A
{
public:
	A(int v1, int v2) : m_i(v1 + v2)
	{
	}
	int m_i;
};

template<typename T>
struct SumFixedTraits;

template<>
struct SumFixedTraits<A>
{
	using sumT = A;
	//static const sumT initValue; // 这是声明，不是定义
	static const sumT initValue()
	{
		return A(0, 0);
	}
};

template<>
struct SumFixedTraits<char>
{
	using sumT = int;
	static const sumT initValue()
	{
		return 0;
	}
};

template<>
struct SumFixedTraits<int>
{
	using sumT = __int64;
	static const sumT initValue()
	{
		return 0;
	}
};


template<>
struct SumFixedTraits<double>
{
	using sumT = double;
	static constexpr sumT initValue()
	{
		return 0;
	}
};

// 真他娘滴经典
template<typename T>
auto funcsum(const T* begin, const T* end)
{
	// 传入一个类型，返回一个类型，这就是固定萃取的运行
	using sumT = typename SumFixedTraits<T>::sumT;

	// 传入一个类型，返回一个值，这就是值萃取的运行
	sumT sum = SumFixedTraits<T>::initValue();

	for (;;)
	{
		sum += (*begin);
		if (begin == end)
			break;
		++begin;
	}
	return sum;
}

int main()
{
	cout << "Hello CMake." << endl;
	return 0;
}

这个程序到这里还没完，函数模板funcsum()中要对类A的对象作加法运算，用到了+=运算符，所以这里需要对类A重载一下+=运算符。在类A的定义中添加代码：

class A
{
public:
	A(int v1, int v2) : m_i(v1 + v2)
	{
	}
	A& operator+=(const A& obj)
	{
		m_i += obj.m_i;
		return *this;
	}
	int m_i;
};

在main()主函数中添加代码：

// killCmake.cpp: 定义应用程序的入口点。
//

#include "killCmake.h"

using namespace std;

class A
{
public:
	A(int v1, int v2) : m_i(v1 + v2)
	{
	}
	A& operator+=(const A& obj)
	{
		m_i += obj.m_i;
		return *this;
	}
	int m_i;
};

template<typename T>
struct SumFixedTraits;

template<>
struct SumFixedTraits<A>
{
	using sumT = A;
	//static const sumT initValue; // 这是声明，不是定义
	static const sumT initValue()
	{
		return A(0, 0);
	}
};

template<>
struct SumFixedTraits<char>
{
	using sumT = int;
	static const sumT initValue()
	{
		return 0;
	}
};

template<>
struct SumFixedTraits<int>
{
	using sumT = __int64;
	static const sumT initValue()
	{
		return 0;
	}
};


template<>
struct SumFixedTraits<double>
{
	using sumT = double;
	static constexpr sumT initValue()
	{
		return 0;
	}
};

// 真他娘滴经典
template<typename T>
auto funcsum(const T* begin, const T* end)
{
	// 传入一个类型，返回一个类型，这就是固定萃取的运行
	using sumT = typename SumFixedTraits<T>::sumT;

	// 传入一个类型，返回一个值，这就是值萃取的运行
	sumT sum = SumFixedTraits<T>::initValue();

	for (;;)
	{
		sum += (*begin);
		if (begin == end)
			break;
		++begin;
	}
	return sum;
}

int main()
{
	cout << "Hello CMake." << endl;

	A my_A_array1[]{ A{3,1},A{6,8},A{12,11} };
	std::cout << funcsum(&my_A_array1[0], &my_A_array1[2]).m_i << std::endl;

	return 0;
}

在这里插入图片描述

模板的萃取技巧或萃取.md
11-29
模板的萃取技巧
c++模板之萃取
cchao985771161的博客
08-30 495
假如，我们要设计一个_Copy的模板函数。我们为了提高效率采用memcpy，可以这样写： template<typename T> T* _Copy(T* dest, T* src, size_t n) { memcpy(dest, src, sizeof(T)*n); return dest; } 我们知道一般的类型（比如int，float，double，char等）进行复制的时候采...
模板的特化和萃取
Nemo
05-11 793
之前对模板化编程进行了总结（详见https://blog.csdn.net/timecur/article/details/89949643）。这篇将介绍模板的重要概念---模板特化。 模板的特化 模板针对某些具体的类型不能处理或者处理结果有误，就需要进行模板特化。 // 例如一个比较两元素大小的模板 template<class T> T& Max...
C++模板（第二版）笔记之第十二章：萃取的实现
喜欢打篮球的普通人
01-11 945
解决办法3：对于那些不是总是生成整型值的值萃取， 使用 inline 成员函数。同样的， 如果成员函数返回的是字面值类型， 可以将该函数声明为 constexpr 的。问题：一个用户定义的任意精度的 BigInt 类型， 可能就不是字面值类型，
C++模板编程之类型萃取
红军不怕远征难，万水千山只等闲
04-09 1889
C++ 模板编程中的萃取（Traits）特性是一种强大的技术，它允许在编译时获取类型的相关信息，并根据这些信息来调整程序的行为。萃取特性本质上是一种类型信息的查询机制，通过模板元编程实现，在标准库和许多开源库中被广泛应用。萃取是一种通过模板来封装类型相关信息的技术，这些信息可以是类型的属性、行为或者其他特征。通过萃取，我们可以在编译时根据不同的类型执行不同的操作，实现代码的复用和泛化。实现原理萃取通常基于模板特化来实现。模板特化允许我们为特定的类型或一组类型提供专门的实现。
C++ 模板类型萃取技术
flyingleo1981的专栏
06-21 1356
自从C++中引入了template后，以泛型技术为中心的设计得到了长足的进步。STL就是这个阶段杰出的产物。STL的目标就是要把数据和算法分开，分别对其进行设计，之后通过一种名为iterator的东西，把这二者再粘接到一起。设计模式中，关于iterator的描述为：一种能够顺序访问容器中每个元素的方法，使用该方法不能暴露容器内部的表达方式。可以说，类型萃取技术就是为了要解决和iterator有关的
C++模板元编程与泛型编程在游戏开发中的实践
轻口味的专栏
05-13 2652
C++模板元编程与泛型编程在现代游戏开发中扮演着关键角色，尤其是在高性能和编译期优化方面。本文系统梳理了六大C++模板元编程技术，包括模板函数与类、类型萃取、特化与偏特化、变长模板参数、编译期循环与递归以及CRTP（Curiously Recurring Template Pattern），并结合游戏引擎中的实际应用案例，展示了这些技术如何提升代码的抽象性和性能。通过Mermaid图，文章清晰地展示了技术演进路径及其在游戏引擎中的具体应用，如ECS组件系统、资源管理器和序列化系统等。最终，文章强调了合理应用
C++ 模板进阶：特化、萃取与可变参数模板
最新发布
今天比昨天更努力一点！
03-13 1万+
本文介绍了C++模板编程的三大进阶技术：模板特化、类型萃取和可变参数模板。首先讲解了指针和数组类型的特化方法，实现精准的类型适配；其次深入解析类型萃取的实现原理，展示如何利用模板特化在编译期获取类型信息；最后探讨可变参数模板的语法和应用，包括递归展开和折叠表达式两种处理方式。文章通过丰富的代码示例，帮助开发者掌握这些高级模板技术，提升泛型编程能力，为构建更灵活的C++库和框架打下基础。
C++ 萃取技术——值萃取
慢慢记录，慢慢更新。
09-12 1523
在 C++ 编程中，萃取技术（Traits）是模板元编程的一个核心概念，用于在编译时提供类型相关的信息。其中，值萃取（Value Traits）是一种特定形式的萃取技术，它允许程序员为不同的数据类型定义特定的属性或值。
【C++ 泛型编程 高级篇】 C++ 模版元编程 类型萃取器的运用教程
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
06-09 2177
C++ 泛型编程 类型萃取器的运用
C++ 萃取技术——将萃取类模板用作模板参数
慢慢记录，慢慢更新。
09-14 1935
在 C++ 编程中，理解和应用 Trait 类模板是提高代码质量和灵活性的关键技术之一。Trait 类模板提供了一种机制，通过这种机制可以在编译时查询或设置有关类型的特定属性。这些属性可能包括类型的数学特性、行为特性、或者与类型相关的支持操作。
c++ 模版 萃取
2303_76659378的博客
10-18 287
讲述萃取的存在必要性
c++ 模板技巧——类型萃取
yuanshenqiang的博客
05-19 402
通过一些模板技巧，使得模块内部可以根据用户输入数据类型，返回不同的数据，实现接口的统一。
C++类型萃取
无聊星期三的博客
10-19 2430
类型萃取 类型萃取指的是当泛型编程时，根据一个模板类（我这里就用类来说了，当然模板函数也可以）的模板类型，使用一个traits来获取其类型，针对其类型调用不同的函数，比如拷贝函数 ，如果普通类型int、double之类的则调用较快的内存拷贝（memcpy），而需要申请空间的如string、vector等，则使用for循环赋值拷贝。
C++模板元编程(三)——类型萃取
hhhcbw的博客，欢迎各位来访
07-07 1148
类型萃取(type_traits)是一种编译时技术，用于在编译期间获取和操作类型的信息，主要用于泛型编程以及在编译时做出决策。
c++类型萃取
习惯有你
12-24 2712
类型萃取 类型萃取，可简单理解为类型获取，萃取的典型应用是在模板函数中区分T的类型是原生类型POD，还是自定义类型，POD全称plain old data，简单理解就是c++从c继承来的基本数据类型，如int、double等。 之所以需要区分类型，主要是因为POD类型与自定义类型的很多处理方法不同，典型的就是copy，POD可以直接使用c库提供的memcpy，它主要是实现内存层面的拷贝，而非POD类型需要使用for循环挨个拷贝，因为涉及到深拷贝与浅拷贝的问题，所以在模板中...
我的C++实践(5)：类型萃取技术
Jack Zhou的专栏
08-26 6077
   C++模板中的类型参数T是抽象的，我们并不能在模板内部直接获得它的具体特征。类型萃取（抽取）技术就是要抽取类型的一些具体特征(trait)，比如它是哪种具体类型，它是引用类型，内建类型，还是类类型等。可见，类型萃取技术其实就是trait模板技术的具体体现。获取类型的具体特征在Java、C#等语言中也称为反射(reflection)，C++中通过模板技术也可以实现一定的反射行为。   类型
c++萃取技术
qq_38158479的博客
01-15 940
萃取(traits)技术 参考网页 https://en.cppreference.com/w/cpp/types C++11提供很多类型萃取接口，这些接口是一些类模板。 通过萃取接口中的value值为true，false获取信息。 #include <iostream> #include <vector> #include <algorithm> #include <map> #include <list> #include <unorde
【C/C++基础进阶系列】C/C++ 萃取技术
CopperSun 技术博客
04-03 1481
【C/C++基础进阶系列】C/C++ 萃取技术 【1】萃取技术基本概念演示 #include <iostream> using namespace std; namespace _nmsp1 { // 计算数组中元素的和值的函数模板 template <typename T> T funcsum(const T* begin, const T* end) { T sum{}; // 零初始化，如果数值型变量被初始化为0，指针型变量被初始化为nullptr，boo
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值