突破编程_C++_C++11新特性（type_traits的属性类型特性以及操作类型特性）

最新推荐文章于 2024-10-07 07:00:00 发布
最新推荐文章于 2024-10-07 07:00:00 发布
阅读量1.7k 收藏 25
点赞数 15
分类专栏： 突破编程_C++_C++11新特性 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/h8062651/article/details/136967440
版权
本文详细介绍了C++标准库中的type_traits工具，如std::alignment_of,std::rank,std::extent用于获取类型信息，以及std::conditional,std::common_type,std::decay,std::enable_if用于类型操纵和条件编译。通过实例展示了这些工具在泛型编程中的应用，包括数组维度处理和类型安全的函数实现。
摘要由CSDN通过智能技术生成

1 type_traits 的属性类型特性

1.1 std::alignment_of

std::alignment_of 是一个模板类，用于获取类型的对齐要求。对齐是指数据在内存中的位置，某些硬件平台可能要求特定类型的数据位于特定地址的边界上。

定义：

template< class T >  
struct alignment_of;

样例：

#include <iostream>  
#include <type_traits>  

int main() {
	std::cout << "Alignment of int: " << std::alignment_of<int>::value << std::endl;	
	std::cout << "Alignment of double: " << std::alignment_of<double>::value << std::endl;
	return 0;
}

上面代码输出为：

Alignment of int: 4
Alignment of double: 8

1.2 std::rank

std::rank 是一个模板类，用于获取数组类型的维度数。对于非数组类型，其值为 0。

定义：

template< class T >  
struct rank;

样例：

#include <iostream>  
#include <type_traits>  

int main() {
	std::cout << "Rank of int: " << std::rank<int>::value << std::endl;
	std::cout << "Rank of int[3]: " << std::rank<int[3]>::value << std::endl;
	std::cout << "Rank of int[3][4]: " << std::rank<int[3][4]>::value << std::endl;
	return 0;
}

上面代码输出为：

Rank of int: 0
Rank of int[3]: 1
Rank of int[3][4]: 2

1.3 std::extent

std::extent 是一个模板类，用于获取数组类型的长度。它通常与 std::rank 结合使用，以确定特定维度的长度。

定义：

template< class _Ty, unsigned int _Nx = 0 >  
struct extent;

样例：

#include <iostream>  
#include <type_traits>  

int main() {
	std::cout << "Rank of int: " << std::rank<int>::value << std::endl;
	std::cout << "Rank of int[3]: " << std::rank<int[3]>::value << std::endl;
	std::cout << "Rank of int[3][4]: " << std::rank<int[3][4]>::value << std::endl;
	return 0;
}

上面代码输出为：

Extent of int[3]: 3
First dimension extent of int[3][4]: 3
Second dimension extent of int[3][4]: 4

1.4 std::remove_all_extents

std::remove_all_extents 是一个模板类，用于移除数组类型的所有维度，将其转换为其元素类型。换句话说，它将多维数组转换为其基础元素类型。

定义：

template< class T >  
struct remove_all_extents;

样例：

#include <iostream>  
#include <type_traits>  
  
int main() {  
    std::cout << typeid(std::remove_all_extents<int[3][4]>::type).name() << std::endl;  
    return 0;  
}

上面代码输出为：

int

注意：typeid(T).name() 在不同的编译器和平台上可能会返回不同的字符串，因此上述输出可能会因环境而异。但核心思想是 std::remove_all_extents 将数组类型转换为其基础元素类型。

2 std::rank 与 std::extent 的综合应用示例

std::rank 和 std::extent 分别用于获取数组或指针类型的维度数和特定维度的长度。这两个工具在泛型编程和模板元编程中特别有用，尤其是在处理不同维度的数组或指针类型时。

下面是一个综合使用 std::rank 和 std::extent 的真实应用场景示例：一个函数模板，用于打印任意维度数组的形状（即各维度的长度）。

#include <iostream>  
#include <type_traits>  

// 递归辅助函数模板，用于打印数组形状  
template <typename T, std::size_t N = std::rank<T>::value>
struct print_array_shape_helper;

// 特化：数组维度为0时，结束递归  
template <typename T>
struct print_array_shape_helper<T, 0> {
	static void print(const T&) {
		// 无需打印，因为没有更多维度  
	}
};

// 递归情况：打印当前维度大小，并递归调用下一个维度  
template <typename T, std::size_t N>
struct print_array_shape_helper {
	static void print(const T& arr) {
		std::cout << std::extent<T, N - 1>::value << " ";
		print_array_shape_helper<T, N - 1>::print(arr);
	}
};

// 打印数组形状的包装函数  
template <typename T>
void print_array_shape(const T& arr) {
	constexpr std::size_t rank = std::rank<T>::value;
	if (rank > 0) {
		std::cout << "Array shape: ";
		print_array_shape_helper<T, rank>::print(arr);
		std::cout << std::endl;
	}
	else {
		std::cout << "Not an array type." << std::endl;
	}
}

int main() 
{
	// 一维数组  
	int arr1[] = { 1, 2, 3, 4, 5 };
	print_array_shape(arr1); // 输出: Array shape: 5  

	// 二维数组  
	int arr2[][3] = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };
	print_array_shape(arr2); // 输出: Array shape: 3 3  

	// 不是数组的类型  
	int non_array = 42;
	print_array_shape(non_array); // 输出: Not an array type.  

	return 0;
}

上面代码的输出为：

Array shape: 5
Array shape: 3 3
Not an array type.

在这个示例中，print_array_shape 函数模板接受一个数组作为参数，并使用 std::rank 来确定其维度数（即秩）。然后，它使用 std::make_index_sequence 生成一个从 0 到 rank - 1 的索引序列，并将其传递给 print_array_shape_impl 函数模板。

print_array_shape_impl 函数模板接受一个数组和一个索引序列作为参数。它使用折叠表达式（C++17及更高版本中的特性）和 std::extent 来遍历数组的每一个维度，并打印出每一维的长度。

通过这种方式，我们可以编写一个通用的函数来打印任意维度数组的形状，而无需事先知道数组的确切维度数。这种技术对于处理不同大小和维度的数组非常有用，尤其是在科学计算、数据分析或任何需要处理多维数据的领域中。

3 type_traits 的操作类型特性

3.1 std::conditional

std::conditional 是一个模板类，它接受一个布尔条件、两个类型 T 和 F 作为模板参数，然后根据条件在 T 和 F 之间选择一个类型。如果条件为 true，则选择 T，否则选择 F。

定义：

template<class _Ty1,
	class _Ty2>
struct conditional<true, _Ty1, _Ty2>

样例：

#include <iostream>  
#include <type_traits>  

int main() {
	using Type1 = std::conditional<true, int, double>::type; // Type1 是 int  
	using Type2 = std::conditional<false, int, double>::type; // Type2 是 double  

	std::cout << typeid(Type1).name() << std::endl; 
	std::cout << typeid(Type2).name() << std::endl; 

	return 0;
}

上面代码输出为：

int
double

3.2 std::common_type

std::common_type 是一个模板类，它接受多个类型作为模板参数，并确定这些类型的公共类型。如果所有类型都可以隐式转换为某个类型，那么 common_type 就是该类型。

定义：

template<class _Ty1,
	class _Ty2,
	class... _Rest>
struct common_type<_Ty1, _Ty2, _Rest...> : _Common_type3<void, _Ty1, _Ty2, _Rest...>

样例：

#include <iostream>  
#include <type_traits>  
  
int main() {  
    using CommonType = std::common_type<int, float, double>::type; // CommonType 是 double  
  
    std::cout << typeid(CommonType).name() << std::endl; 
  
    return 0;  
}

上面代码输出为：

double

3.3 std::decay

std::decay 是一个模板类，它接受一个类型作为模板参数，并产生一个“衰减”后的类型。这通常意味着它会去除引用和 CV 限定符（const 和 volatile），如果是数组或函数类型，则会转换为对应的指针类型。

定义：

template<class T>
struct decay

样例：

#include <iostream>  
#include <type_traits>  

int main() {
	using DecayedType = std::decay<int&>::type; // DecayedType 是 int  
	using DecayedArrayType = std::decay<int[5]>::type; // DecayedArrayType 是 int*  

	std::cout << typeid(DecayedType).name() << std::endl; 
	std::cout << typeid(DecayedArrayType).name() << std::endl; 

	return 0;
}

上面代码输出为：

int
int * __ptr64

3.4 std::enable_if

std::enable_if 是一个模板类，它根据一个布尔条件来启用或禁用模板特化。它通常与 std::is_same、std::is_integral 等类型特性检查模板结合使用，以在编译时根据类型特性进行条件编译。

定义：

template<bool _Test,
	class _Ty = void>
struct enable_if

样例：

#include <iostream>  
#include <type_traits>  

template<typename T, typename std::enable_if<std::is_integral<T>::value, int>::type = 0>
void foo(T) {
	std::cout << "Integral type." << std::endl;
}

template<typename T, typename std::enable_if<!std::is_integral<T>::value, int>::type = 0>
void foo(T) {
	std::cout << "Non-integral type." << std::endl;
}

int main() {
	foo(12);  
	foo(3.14); 

	return 0;
}

上面代码输出为：

Integral type.
Non-integral type.

4 std::conditional 应用于类型包装器

下面是一个使用 std::conditional 的示例，展示了如何在模板中基于类型属性选择一个类类型或者类型别名：

#include <iostream>  
#include <type_traits>  

// 整数类型包装器  
template<typename T>
struct IntegerWrapper {
	T value;
	IntegerWrapper(T v) : value(v) {}
	void print() const {
		std::cout << "Integer: " << value << std::endl;
	}
};

// 浮点类型包装器  
template<typename T>
struct FloatWrapper {
	T value;
	FloatWrapper(T v) : value(v) {}
	void print() const {
		std::cout << "Float: " << value << std::endl;
	}
};

// 使用std::conditional根据类型属性选择包装器  
template<typename T>
using WrapperType = typename std::conditional<
	std::is_integral<T>::value,
	IntegerWrapper<T>,
	FloatWrapper<T>
>::type;

int main() {
	// 使用WrapperType为整数类型选择包装器  
	WrapperType<int> intWrapper(12);
	intWrapper.print(); // 输出 "Integer: 12"  

	// 使用WrapperType为浮点类型选择包装器  
	WrapperType<double> floatWrapper(3.14);
	floatWrapper.print(); // 输出 "Float: 3.14"  

	return 0;
}

上面代码输出为：

Integer: 12
Float: 3.14

这个示例定义了两个模板包装器：IntegerWrapper 用于整数类型，FloatWrapper 用于浮点类型。然后，使用 std::conditional 来根据类型 T 是否为整数类型来选择相应的包装器。这里 std::conditional 有三个模板参数：第一个是一个布尔表达式，第二个是在表达式为 true 时选择的类型，第三个是在表达式为 false 时选择的类型。

WrapperType 是一个类型别名模板，它使用了 std::conditional 来选择适当的包装器类型。然后，在 main 函数中，分别创建了一个整数类型的包装器和一个浮点类型的包装器，并调用了它们的 print 方法。

5 std::enable_if 应用于类型安全的加法函数

下面示例是一个简单的类型安全的加法函数，它根据输入类型选择不同的加法实现：

#include <iostream>  
#include <type_traits>  

// 整数加法  
template<typename T>
typename std::enable_if<std::is_integral<T>::value, T>::type
add(T a, T b) {
	return a + b;
}

// 浮点加法  
template<typename T>
typename std::enable_if<std::is_floating_point<T>::value, T>::type
add(T a, T b) {
	return a + b;
}

// 通用加法包装器 
template<typename T>
auto add_wrapper(T a, T b) -> decltype(add(a, b)) {
	return add(a, b);
}

template<typename T, bool IsIntegral>
struct adder;

template<typename T>
struct adder<T, true> {
	static T add(T a, T b) {
		return a + b; // 整数加法实现  
	}
};

template<typename T>
struct adder<T, false> {
	static T add(T a, T b) {
		return a + b; // 浮点加法实现（假设T是浮点类型）  
	}
};

// 使用std::conditional来选择加法器实现  
template<typename T>
T conditional_add(T a, T b) {
	return adder<T, std::is_integral<T>::value>::add(a, b);
}

int main() 
{
	// 使用add_wrapper进行整数加法  
	std::cout << "5 + 3 (integers) = " << add_wrapper(5, 3) << std::endl;

	// 使用add_wrapper进行浮点加法  
	std::cout << "5.0 + 3.0 (floats) = " << add_wrapper(5.0, 3.0) << std::endl;

	// 使用conditional_add进行整数加法  
	std::cout << "5 + 3 (integers via conditional) = " << conditional_add(5, 3) << std::endl;

	// 使用conditional_add进行浮点加法  
	std::cout << "5.0 + 3.0 (floats via conditional) = " << conditional_add(5.0, 3.0) << std::endl;

	return 0;
}

上面代码输出为：

5 + 3 (integers) = 8
5.0 + 3.0 (floats) = 8
5 + 3 (integers via conditional) = 8
5.0 + 3.0 (floats via conditional) = 8

这个示例定义了两个重载的 add 函数模板，分别用于整数和浮点数的加法。然后创建了一个 add_wrapper 函数模板，它使用 decltype 和 enable_if 来根据参数类型选择正确的 add 函数。

这种基于条件的类型选择在模板元编程中非常常见，允许程序员编写更加通用和灵活的代码，同时保持类型安全。

breakthrough_01
关注
专栏目录
C++11的新特性
程序员黄老师的精品课！
04-28 792
C++11标准发布已有一段时间了, 维基百科上有对C++11新标准的变化和C++11新特性介绍的文章. 我是一名C++程序员,非常想了解一下C++11. 英文版的维基百科看起来非常费劲,而中文版维基百科不是知道是台湾还是香港人翻译的然后由工具转换成简体中文的,有些术语和语言习惯和大陆程序不一样! 我决定结合这两个版本按照我自己的习惯把这篇文章整理到我的博客中.分享给关注我和关注C++11的朋友
C++ STL type_traits.h
pisuto的博客
09-29 366
全部代码 #pragma once #include <type_traits> // 可以继续添加 namespace tinySTL { // enable_if template<bool B, typename T = void> struct enable_if {}; template<typename T> struct enable_if<true, T> { using type = T; }; temp
C++ Traits
pjzjchn的专栏
06-09 640
Traits技术可以用来获得一个 类型 的相关信息的。 首先假如有以下一个泛型的迭代器类，其中类型参数 T 为迭代器所指向的类型：template typename T>class myIterator{ ...};当我们使用myIterator时，怎样才能获知它所指向的元素的类型呢？我们可以为这个类加入一个内嵌类型，像这样：template typename T>class myIterator
C++ STL源码剖析 7-traits
最新发布
wesigj的博客
10-07 746
在C++中，Traits是一种模板编程技术，它允许我们为不同的数据类型提供统一的操作函数。Traits通常通过模板类和特化来实现，可以在编译时提供类型信息，从而实现类型安全的代码。Traits是一种特性萃取技术，它在泛型编程中被广泛使用。它通过模板类和特化来实现，允许我们为不同的数据类型提供统一的操作函数，如advance、swap、encode/decode等。Traits的实现通常依赖于枚举、typedef和模板的偏特化。// 定义一个通用的 Traits 模板// 默认实现，假设 T 不是特殊类型。
C++ traits编程技法之__type_traits
mmshixing的博客
06-13 4224
__type_trivial  双底线前缀，表示是SGI STL以外的东西，不在STL标准范围之内。 __type_trivial负责萃取型别（Type）的特性，究竟是什么特性呢？          注：trivial是英文“无意义的、不重要”的意思。          答曰：这个型别是否具备non-trivialdefalt ctor、non-trivial copy ctor、non-t
突破编程_C++_C++11新特性（type_traits的概念以及核心类型特性）
突破编程
03-22 1983
C++11 新特性：type_traits的概念以及核心类型特性
深入解析C++的type_traits
fl2011sx的博客
08-03 3354
C++的type_traits是一套纯粹编译期的逻辑，可以进行一些类型判断、分支选择等，主要用于模板编程。使用type_traits并不难，但是我们希望能够更加深入了解其实现方式，与此同时，可以更进一步体验C++的模板编程。 本篇文章旨在引导大家自行实现type_traits的基础代码。 模板编程不像常规的代码，可以有if-else这些流控制语句，我们需要充分利用模板、模板特例、类型转换等特性来实现编译期的一系列判断和类型转换。 定义基础常量 第一步，我们需要定义true和false两个常量，所有的type
C++模板元编程_C++_
10-01
11. **C++标准库的元编程支持**：标准库如`<type_traits>`提供了很多内置的模板元程序，如`std::is_same`, `std::integral_constant`, 和 `std::enable_if`等，用于检查类型特性或控制模板的实例化。 12. **Boost....
C++ TypeTraits示例：类型特性与特化应用
在C++编程中，TypeTraits是一种强大的工具，用于封装类型的信息，帮助开发者检查和分析编译时类型属性。这些类模板提供了一种方法来静态地确定一个类型是否具有特定性质，如整型、算术类型或指针类型等。通过部分...
C++Templates_c++templates_C++Templates全览_healthbhr_源码.rar
09-29
- **类型检测（Type Traits）**：模板用于检测类型属性，如`std::is_same`, `std::is_arithmetic`等。 - **类型推导（Type Deduction）**：通过模板实例化自动推导变量类型，如`auto`关键字的使用。 5. **模板偏...
【BOOST C++ 15 泛型编程】（1）Boost.TypeTraits
gongdiwudu的专栏
11-20 4025
反省是重点中的重点，泛型在实践中贯穿工程的始终。以下库支持泛型编程。无需详细了解模板元编程即可使用这些库。 Boost.TypeTraits 提供了检查类型属性的函数。 Boost.EnableIf 可以与 Boost.TypeTraits 一起使用，例如，根据函数的返回类型重载函数。 Boost.Fusion 使创建异构容器成为可能——其元素可以具有不同类型的容器。
C++ type_traits 原理
06-24 856
一、简单介绍 (1)、type_traits 类型萃取,C++11中已经成为了一个核心模块。 (2)、标准库包括helper classes 、type traits、type transformations 三个模块。 ...
C++traits
qq_60755751的博客
04-12 1449
C++的标准库提供了,它定义了一些编译时基于模板类的接口用于查询、修改类型的特征：输入的时类型，输出与该类型相关的属性通过type_traits技术编译器可以回答一系列问题：它是否为数值类型？是否为函数对象？是不是指针？有没有构造函数？能不能拷贝构造等等type_traits技术还能对类型进行变换，比如给定的类型任意T，能为这个类型添加const修饰符、添加引用或指针等。而这一切都发生在编译时，过程中没有任何运行时开销。
C++ 标准库 ＜type_traits＞
Aforxiaoxie的博客
07-31 483
type_traits> 中的模板通常使用 std:: 前缀，例如 std::is_integral<T>::value 用于检查类型 T 是否是整数类型。std::enable_if<Condition, T>: 如果 Condition 为 true，则类型为 T，否则此模板不参与重载决议。std::add_lvalue_reference<T>: 为类型 T 添加左值引用修饰。std::is_reference<T>: 判断类型 T 是否为引用类型。
C++模板元编程Type_traits
热门推荐
林多
02-28 1万+
type_traits type_traits是C++11提供的模板元基础库。 type_traits可实现在编译期计算、判断、转换、查询等等功能。 type_traits提供了编译期的true和false。 // type_traits中源码 template &amp;lt;class T, T val&amp;gt; struct integral_constant { typedef i...
C++ type_traits （tcy)
tcy-阿春
12-04 1067
1.1.概述 type_traits提供编译期间计算、查询、判断、转换和选择的帮助类 1.2.作用： 1）获取修改变量数据类型；获取函数返回类型； 2）判断数据类型，修改类型属性 3）重载相同参数不同的返回类型； 4）根据条件选择不同的数据类型； 5）编译器类型检查 1.3.定义： template <class T, T v> struct integral_constant { static constexpr T v.
C++ Type traits
huangyimin的专栏
02-20 4331
 C++ Type traitsby John Maddock and Steve ClearyDDJ 2000/10译者：陈崴侯捷注：本文系北京《程序员》杂志 2001/06 的文章。译笔顺畅，技术饱满。承译者陈崴先生与《程序员》杂志负责人蒋涛先生答允，转载於此，以飨台湾读者，非常感谢。未得陈崴先生与蒋涛先生二人之同意，任何人请勿将此文再做转载。
c++ type traits
liyongOFDM的专栏
06-22 1147
使用C++的template时，有时需要确定一个模板类是不是一个特定类型的，有时因为不用的类型需要不同的处理方式，这是可以考虑使用type traits 1.全特化：即所偶 #include template class is_int{ public: static const bool value = false; }; template<> class is_int{ p
c++ trait
Stroller
08-13 1147
#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
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值