C++17新特性-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_34799070/article/details/146279999

文章目录

1 `lambda`表达式可以捕获 `*this`
3 constexpr新特性
- 3.1 允许lambda中使用`constexpr`
4 变量新特性
5 新的方法和类型

有用的新特性

lambda表达式捕获*this
结构化绑定
强制的赋值省略
std::string_view
try_emplace
std::optional

1 `lambda`表达式可以捕获 `*this`

C++11引入的lambda：
（1）可以使用值传递[=]，引用传递[&]或者混合传递[&, a]来捕获可以的外部对象。
（2）可以使用this指针[this]或值传递[=]捕获当前对象，但其实都是本对象的指针。

C++17的lambda引入捕获[*this]，使得可以捕获当前对象的常量副本，相当于是以值捕获的形式捕获了this指向的对象，并且赋予const属性。

void Student::func()
{
	auto lambda = [*this] {
		return this->a;//此时this仍是指针属性
	}
}

3 constexpr新特性

3.1 允许lambda中使用`constexpr`

C++17允许lambda表达式在constexpr上下文中使用，从而使其可以在编译期求值。

void func()
{
	constexpr auto add = [](int a, int b) {
		return a + b;
	};
	add(2,3);
}

4 变量新特性

4.1 inline变量

它主要解决了多个编译单元之间共享全局变量的链接问题，特别是对于模板和头文件中定义的变量。
inline变量的主要特点包括：

定义在头文件中‌：可以在多个编译单元中包含同一个头文件，每个编译单元都会有一个独立的定义。‌
避免多重定义错误‌：传统的常量定义在头文件中会导致每个源文件都有自己的定义，这会在链接时引起错误。使用inline变量可以确保每个编译单元只有一个定义。

// constants.h
inline const int MAX_SIZE = 100;

例如在多个文件中包含constnts.h时，每个文件都会有一个MAX_SIZE的定义，但不会引起链接错误。

这个功能似乎很鸡肋且错误

4.2 结构化绑定

提供一种简洁、直观的方式来解包元组、结构体或数组中的数据到多个单独的变量中。

auto [x, y, z] = expression;

示例

元组解包

#include <tuple>
std::tuple<int, double, std::string> getTuple() {
    return {42, 3.14, "Hello"};
}
int main() {
    auto [a, b, c] = getTuple();
}

结构体解包

struct Point {
    int x;
    int y;
};
int main() {
    Point p{10, 20};
    auto [x, y] = p;
}

数组解包

int main() {
    int arr[] = {1, 2, 3};
    auto [a, b, c] = arr;
}

4.3 if和switch语句中的初始化器

C++17引入if和switch语句的初始化器，使得在使用条件判断时可以在内部进行变量初始化。此前这种只允许在for循环等情况中出现

if 示例

if(auto it = m.find("a"); it != m.end()) // 先定义再使用
{
	...
}

swicth示例

std::vector<int> numbers = {10, 20, 30, 40};
switch (int i = numbers.size(); i) {
	case 4:
		break;
}

4.4 强制的复制省略

int main()
{
	student s = getStudent();
	return 0;
}

在C++17之前，返回局部对象用于赋值时，通常会涉及到拷贝构造函数的调用，即使编译器应用了返回值优化。但这些是可选的，这意味着编译器仍然可以选择不进行这些优化，从而导致性能损失。

C++17改变了这一点，有时被称为强制返回值优化，确保消除这些复制操作。

4.5 临时物质化

临时物质化是指在需要一个完整的对象时，将一个临时的prvalue（纯右值）表达式转换为一个临时对象的过程。这主要发生在以下几种情况：

当 prvalue 需要作为引用的初始化值时：如果一个 prvalue 被用作初始化一个引用，那么这个 prvalue 将会物质化为一个临时对象，以便引用可以绑定到它上面。
在 prvalue 作为函数参数传递时：如果函数参数是按值传递的，而传递的实参是 prvalue，那么这个 prvalue 将物质化为一个临时对象，然后将其传递给函数。
在 prvalue 作为函数的返回值时：当函数返回一个 prvalue 时，这个 prvalue 通常会物质化为一个临时对象，特别是在涉及到返回类型转换时。

#include <iostream>

struct A {
    int value;
    A(int v) : value(v) { std::cout << "A(" << value << ") constructed\n"; }
    A(const A& other) : value(other.value) { std::cout << "A copied\n"; }
};

A getA() {
    return A(5); // 返回 prvalue
}

void takeA(A a) {
    std::cout << "Received A: " << a.value << std::endl;
}

int main() {
    const A& aRef = A(10); // prvalue 物质化为临时对象，引用绑定到它
    takeA(A(20)); // prvalue 物质化为临时对象，传递给函数

    A myA = getA(); // prvalue 物质化过程
    return 0;
}

5 新的方法和类型

5.1 `std::string_view`

std::string_view顾名思义是字符串的“视图”，类成员变量包含两个部分：字符串指针和字符串长度，它提供对现有字符串的只读访问，而无需进行拷贝。‌ std::string_view主要用于那些只需要读取字符串内容而不进行修改的场景，从而避免了std::string的高成本复制问题。

构造对象时，如果传参为明文字符串const char*,const string&则需要进行一次内存分配，将字符串拷贝到堆上，而std::string_view可以避免
在处理子串时，std::string::substr也需要进行拷贝和分配内存，而std::string_view::substr则不需要，在处理大文件解析时，性能优势非常明显。

‌构造函数‌：

std::string_view();//默认构造函数
std::string_view(const char* s); //从C风格字符串创建字符串视图。
std::string_view(const std::string& str); //从std::string对象创建字符串视图。
std::string_view(const std::string_view& other); //从另一个字符串视图创建字符串视图。

‌访问函数‌

data(); //返回指向字符串数据的指针。
size(); //返回字符串的长度。
substr(size_t pos, size_t count); //返回从位置pos开始的count个字符的子视图。
contains(std::string_view sv); //检查当前字符串视图是否包含另一个字符串视图。

‌修改函数‌：

remove_prefix(size_t n); //移除前n个字符。
remove_suffix(size_t n); //移除后n个字符。

‌比较函数‌：

== 和 != //比较两个字符串视图是否相等。
<, <=, >, >= //比较两个字符串视图的字典顺序。

5.2 `try_emplace`

在向std::map或std::unordered_map中插入元素时，使用emplace的操作是构造一次元素，如果key不存在则插入；如果已存在则后立刻析构，因此进行一次多余的构造和析构。
C++17加入了try_emplace，避免了这个问题。

std::map<std::string, std::string> m;
m.try_emplace("c", "aaa");

5.3 `std::apply`

相当于把容器的值当函数的输入：

int add_ten(int first, int second) {
	return first + second;
}

std::cout << std::apply(add_ten, std::pair(1, 2)) << '\n';

输出：
3

5.4 `std::optional`

std::optional<T>代表一个可能存在的T值，常用于可能失败的函数的返回值中，比如工厂函数。在C++17之前，往往使用T*作为返回值，如果为nullptr则代表函数失败，否则T*指向了真正的返回值。

但是这种写法模糊了所有权，函数的调用方无法确定是否应该接管T*的内存管理
返回值可能为空对于调用方是很危险的。

// pre c++17
ReturnType* func(const std::string& in) {
    ReturnType* ret = new ReturnType;
    if (in.size() == 0)
        return nullptr;
    // ...
    return ret;
}

// c++17 更安全和直观
std::optional<ReturnType> func(const string& in) {
    ReturnType ret;
    if (in.size() == 0)
        return std::nullopt;
    // ...
    return ret;
}

举例

#include <iostream>
#include <optional>
#include <vector>
 
std::optional<int> findValue(const std::vector<int>& numbers, int target) {
    for (int num : numbers) {
        if (num == target) {
            return std::make_optional(num); // 使用 std::make_optional 返回一个值
        }
    }
    return std::nullopt; // 表示没有找到目标值，返回一个空的 std::optional 对象
}
 
int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    auto result = findValue(numbers, 3);
 
    if (result) { // 如果 result 包含一个值，则条件为真
        std::cout << "Found: " << *result << std::endl; // 解引用 optional 来获取值
    } else {
        std::cout << "Not found." << std::endl; // result 为空时执行
    }
 
    return 0;
}

5.5 `std::variant`

std::variant<T, U, ...>代表一个联合体容器，容器中的值是指定类型的一种，与union相比有以下两点优势：

可以存储复杂类型，而union只能直接存储基础的POD类型，对于如std::vector和std::string等复杂类型则需要用户手动管理内存。
类型安全，std::variant存储了内部的类型信息，所以可以进行安全的类型转换，c++17之前往往通过union+enum来实现相同功能。