C/C++语言基础--C++模板与元编程系列六,C++元编程相关库的讲解与使用
本专栏目的
- 更新C/C++的基础语法,包括C++的一些新特性
前言
- 模板与元编程是C++的重要特点,也是难点,本人预计将会更新10期左右进行讲解,这是第六期,讲解元编程相关库等,本人感觉这一部分内容还是比较复杂的;
- C语言后面也会继续更新知识点,如内联汇编;
- 欢迎收藏 + 关注,本人将会持续更新。
文章目录
- 1、元编程简介
- 简介
- constexpr
- 为什么需要元编程技术??
- 2、C++元编程相关库的使用
- is_void
- is_integral
- is_floating_point
- is_const
- remove_const
- remove_reference
- is_same
- enable_if
- conditional
- declval
1、元编程简介
简介
🃏 官方:元编程(Metaprogramming)是指某类计算机程序的编写,这类计算机程序编写或者操纵其他程序(或者自身)作为它们的数据,或者在运行时完成部分本应在编译时完成的工作。
🛰 简单的说:在编译期进行计算或者类型判断这两类
constexpr
constexpr
在变量模板这一届已经讲过了,详细请看:C/C++语言基础–C++模板与元编程系列三(变量模板、constexpr、萃取等…………)
constexpr
就是一个很典型的例子,他修饰的函数、变量这些在编译期就完成了计算或者类型判断,这里仅作简单介绍,这里举两个例子:
1、结合模板
template <int x>
struct MM {
constexpr static int y = x + 1;
};
- 这里定义了一个结构体,在结构体中定义了
constexpr
变量,这说明这个变量的值在编译的时候就计算出来了,但是这里要注意的是要加static修饰,在C++17
标准之后,constexpr
就已经默认自动会加上static
修饰,==原因是:==如果不加那么程序就不知道这个变量应该在什么地方存储,把他定义为静态变量也符合元编程的定义,🐯 提示:一般程序的内存分配是在运行的时候分配的,但是有些不是,是在编译期确定,如:静态、全局、常量等………… - 传递参数:是在模板中,利用模板的特化特性
2、constexpr
修饰函数
constexpr int add(int a, int b)
{
return a + b;
}
-
注意:
constexpr
修饰的的函数,那么调用他的地方,仅仅说明可以在编译期进行计算,但是不一定就在编译器进行计算,还可能在运行期计算,如下: -
int x = 10; int y = 20; cout << add(x, y) << endl; // 运行期计算,因为编译器不确定 cout << add(10, 20) << endl; // 编译期计算 constexpr int sum = add(10, 20); // 返回值结=接收,需要用constexpr修饰
-
但是小编认为,最好先用变量接收这个值,然后在输出,然后需要注意的是: 返回值一定要用constexpr修饰,这样的
add(x, y)
会报错,这样符合元编程概念:在编译期进行静态计算.
为什么需要元编程技术??
主要目的: 提高效率
😈 假设:有一个东西,在运行的时候经常要用,这个值是固定的,但是需要通过计算得出,我们这里假设斐波那契数列前30项是固定的,需要经常使用,那么这个时候就可以现用元编程的循环结构先在编译器进行计算,后面在运行的时候直接调用即可(这个代码见下一节:元编程的三种编程方式)
2、C++元编程相关库的使用
C++11标准引入了一系列增强模板元编程特性的功能和库,但并没有直接引入一个名为“元编程库”的单一头文件,然而,C++11通过增强模板、类型特征(type traits)和其他编译时特性,为元编程提供了更强大的支持。
在C++11中,与元编程紧密相关的头文件主要是<type_traits>
。这个头文件包含了大量的类型特征模板,这些模板可以在编译时查询类型的信息,并根据这些信息进行条件编译或生成代码。
<type_traits>
头文件主要解决的是: 元编程中类型判断问题。
is_void
is_void
是在编译期进行判断,这个变量类型是否是void,一般结合模板使用(这里简单举例了一下)。
适用场景
- 检查基本类型
- 检查自定义类型
#include <iostream>
#include <iomanip>
#include <type_traits>
using namespace std;
struct MyType {
string name;
unsigned int age;
};
int main()
{
// 检查基本类型
cout << boolalpha;
cout << "is_void<void>: " << is_void<void>::value << endl;
cout << "is_void<int>: " << is_void<int>::value << endl;
// 检查自定义类型
cout << "is_void<MyType>: " << is_void<MyType>::value << endl;
// C++17简化版本
cout << "C++17: " << is_void_v<void> << endl;
return 0;
}
输出:
is_integral
is_void
是在编译期进行判断类型是否为整型类型。
注意:整型类型包括所有的整数类型(如 char
、short
、int
、long
、long long
等)以及它们的无符号版本(如 unsigned char
、unsigned short
、unsigned int
、unsigned long
、unsigned long long
等),不只是int哈 🤠🤠🤠🤠
#include <iomanip>
#include <iostream>
#include <type_traits>
using namespace std;
int main()
{
// 判断是整型
cout << boolalpha;
cout << "is_integral<int>: " << is_integral<int>::value << endl;
cout << "is_integral<char>: " << is_integral<char>::value << endl;
cout << "is_integral<unsigned>: " << is_integral<unsigned>::value << endl;
cout << "is_integral<long long>: " << is_integral<long long>::value << endl;
// 判断不是整形
cout << "is_integral<string>: " << is_integral<string>::value << endl;
cout << "is_integral<double>: " << is_integral<double>::value << endl;
// C++17 优化版本
cout << "C++17: " << is_integral_v<int> << endl;
return 0;
}
输出:
is_floating_point
用于在编译时检查一个给定的类型是否为浮点型类型。浮点型类型主要包括 float
、double
.
#include <iostream>
#include <iomanip>
#include <type_traits>
using namespace std;
int main()
{
// 检查浮点型
cout << boolalpha;
cout << "is_floating_point<float>: " << is_floating_point<float>::value << endl;
cout << "is_floating_point<double>: " << is_floating_point<double>::value << endl;
// 检查非浮点型
cout << "is_floating_point<string>: " << is_floating_point<string>::value << endl;
cout << "is_floating_point<int>: " << is_floating_point<int>::value << endl;
// C++17优化版本
cout << "C++17: " << is_floating_point_v<int> << endl;
return 0;
}
输出:
is_const
在编译时检查一个给定的类型是否被const修饰。如果类型是常量类型,则返回为 true
;否则为 false
。
#include <iostream>
#include <iomanip>
#include <type_traits>
using namespace std;
template<typename _Ty>
void isConst()
{
// 17版本: is_const_v
if (is_const<_Ty>::value) {
cout << "is const" << endl;
}
else {
cout << "no const" << endl;
}
}
void test()
{
isConst<int>();
isConst<const int>();
isConst<const char*>();
}
int main()
{
test();
return 0;
}
输出:
remove_const
在编译时移除类型的 const
限定符
- 如果给定的类型已经是
const
限定的,std::remove_const
会生成一个去除了const
限定符的新类型 - 如果给定的类型原本就没有
const
限定符,那么它就直接返回该类型本身
#include <iostream>
#include <iomanip>
#include <type_traits>
using namespace std;
template<typename _Ty>
void fix(_Ty t)
{
// C++14 简化版本: remove_const_t
using Type = remove_const<_Ty>::type;
Type num = t;
cout << num + 10 << endl;
}
int main()
{
constexpr int x = 10;
fix<decltype(x)>(x);
return 0;
}
结果:
remove_reference
在编译时移除类型的引用限定符(即 &
或 &&
)
- 如果给定的类型是一个引用类型,
std::remove_reference
会生成一个去除了引用限定符的新类型 - 如果给定的类型原本就不是引用类型,那么它就直接返回该类型本身。
#include <iostream>
#include <iomanip>
#include <type_traits>
using namespace std;
template <class _Ty>
void fix(_Ty t)
{
if (is_same_v<_Ty, int&>) {
t += 10;
cout << "before t: " << t << endl;
// C++简化版: remove_reference_t
using Type = remove_reference<_Ty>::type;
Type num = t;
num += 20;
cout << "before t: " << t << "\tbefore num: " << num << endl;
}
}
int main()
{
int x = 20;
int& y = x;
fix<int&>(y);
return 0;
}
结果:
👀 很明显,这个去掉了&d的作用
is_same
用于在编译时检查两个类型是否完全相同
它不是直接可执行的代码,而是用作模板参数或与其他模板结合使用时,在编译时提供类型信息的工具
#include <iostream>
#include <iomanip>
#include <type_traits>
using namespace std;
template <typename _Ty>
void fix(_Ty t)
{
// 如果不用constexpr会报错,因为不用constexpr编译器会在运行的时候运行代码,这个时候编译器就是错误
if constexpr (is_same_v<_Ty, string>) {
t += "--fix";
}
else {
t += 10;
}
cout << " fix: " << t << endl;
}
void test()
{
fix<int>(18);
fix<string>(string("yxz"));
fix<double>(8);
}
int main()
{
cout << boolalpha;
test();
return 0;
}
结果:
😜 这里有个注意点: if constexpr
结构,这个下一篇介绍元编程的三种编程方式会讲🏚🏚
enable_if
用于在编译时基于模板参数的条件来选择性地启用或禁用函数模板、类模板的特定特化—,或者模板成员函数。std::enable_if
通常与 typename = std::enable_if<condition>::type
(C++11),在C++14有enable_if_t
。
💌 核心: 启用、禁止
#include <iostream>
#include <type_traits>
using namespace std;
template<typename _Ty, typename = enable_if<is_integral_v<_Ty>>::type>
void printInt(_Ty t)
{
cout << "整型数据: " << t << endl;
}
int main()
{
printInt<int>(10);
//printInt<double>(10.0); // 报错
return 0;
}
结果:
conditional
std::conditional
是一个模板结构体,它根据给定的条件来选择两个类型之一。这类似于条件编译指令(如 #ifdef
),但它是在类型级别上工作的,而不是在编译指令级别。
std::conditional
模板接受两个类型参数和一个布尔条件作为模板参数。
- 如果条件为真(
true
),则std::conditional
的type
成员别名将解析为第一个类型参数; - 如果条件为假(
false
),则它将解析为第二个类型参数。
#include <iostream>
#include <type_traits>
using namespace std;
int main()
{
constexpr bool condition = false; // 条件判断, 这个一般需要结合模板, 然后更具实际业务常见
using Type = conditional<condition, int, string>::type;
Type t;
if constexpr (!is_integral_v<Type>) {
t += string("yxz");
}
cout << t << endl;
return 0;
}
结果:
declval
std::declval
是 C++11 引入的一个非常有用的工具,它位于 <utility>
头文件中,它允许在编译期的时候判断一个类是不是包含某一种方法。
std::declval
基本用法
template<typename T>
auto func() -> decltype(std::declval<T>().member_function()); //判断T这个类是否有member_function这个方法
🛰 例子:
#include <iostream>
#include <type_traits>
#include <utility>
using namespace std;
class Test
{
public:
void print()
{
cout << __FUNCTION__ << endl;
}
};
class Other
{
public:
Other()
{
cout << __FUNCTION__ << endl;
}
};
template <typename T>
auto func() -> decltype(declval<T>().print())
{
cout << __FUNCTION__ << endl;
}
int main()
{
func<Test>();
//func<Other>(); 报错
return 0;
}
结果: