C++17_第三篇-Aet

Bingliaolong 2024-06-29 23:34 Aet | 隐藏边栏 | 抢沙发 | 3 0

文章评分 1 次，平均分 5.0 ：

结构化绑定

结构化绑定允许我们解构和绑定返回的元组、数组或结构体中的值，使得代码更加简洁和可读

#include <tuple>

#include <iostream>

std::tuple<int, double, std::string> getTuple() {

return {1, 2.3, "hello"};

}

int main() {

auto [a, b, c] = getTuple();

std::cout << a << " " << b << " " << c << std::endl;

return 0;

}

嵌套命名空间

C++17 允许使用嵌套命名空间声明的简写方式，减少冗长的代码

namespace A::B::C {

void func() {

std::cout << "Nested namespaces in C++17" << std::endl;

}

`std::filesystem`

跨平台文件系统操作

#include <filesystem>

namespace fs = std::filesystem;

fs::create_directory("test"); // 创建目录

for (auto& entry : fs::directory_iterator(".")) {

// 遍历当前目录

}

`std::variant`

std::variant 是一个类型安全的联合体，允许存储多个类型中的一种

#include <variant>

#include <iostream>

std::variant<int, double, std::string> getValue(int id) {

switch (id) {

case 0: return 42;

case 1: return 3.14;

default: return "Hello";

}

int main() {

auto v = getValue(1);

std::cout << std::get<double>(v) << std::endl;

return 0;

}

`std::variant` 和 `std::visit`

类型安全的联合体与访问器

#include <variant>

#include <string>

std::variant<int, std::string> data = "hello";

std::visit([](auto&& arg) {

using T = std::decay_t<decltype(arg)>;

if constexpr (std::is_same_v<T, int>) { /*...*/ }

else if constexpr (std::is_same_v<T, std::string>) { /*...*/ }

}, data);

`std::any`

std::any 可以存储任何类型的值，类似于类型安全的 void*

#include <any>

#include <iostream>

int main() {

std::any a = 42;

std::cout << std::any_cast<int>(a) << std::endl;

a = std::string("Hello");

std::cout << std::any_cast<std::string>(a) << std::endl;

return 0;

}

文件系统库

C++17 引入了文件系统库，用于处理文件和目录操作

#include <filesystem>

#include <iostream>

namespace fs = std::filesystem;

int main() {

fs::create_directory("example");

for (const auto& entry : fs::directory_iterator(".")) {

std::cout << entry.path() << std::endl;

}

return 0;

}

`constexpr` 的改进

C++17 对 constexpr 进行了改进，允许更多的表达式在编译时计算

constexpr int factorial(int n) {

if (n <= 1) return 1;

else return n * factorial(n - 1);

}

int main() {

constexpr int result = factorial(5);

std::cout << result << std::endl;

return 0;

}

`[[nodiscard]]` 属性

[[nodiscard]] 属性用于标记返回值不应被忽略

[[nodiscard]] int compute() {

return 42;

}

int main() {

compute(); // 编译器警告：返回值被忽略

return 0;

}

折叠表达式（Fold Expressions）

C++17 引入了折叠表达式，简化了可变参数模板的处理

#include <iostream>

template<typename... Args>

auto sum(Args... args) {

return (args + ...); // 左折叠

}

int main() {

std::cout << sum(1, 2, 3, 4) << std::endl; // 输出 10

return 0;

}

`std::byte`

C++17 引入的一种新的数据类型，用于表示一个字节（8位）的数据
它提供了一种类型安全的方式来处理字节数据，避免了传统使用 unsigned char 进行字节操作所带来的潜在类型问题
std::byte 位于头文件 <cstddef>

#include <cstddef>

enum class byte : unsigned char {};

#include <cstddef>

#include <iostream>

int main() {

std::byte b{0x1F}; // 使用整数字面值初始化

std::cout << std::to_integer<int>(b) << std::endl; // 输出 31

return 0;

}

#include <cstddef>

#include <iostream>

int main() {

std::byte b1{0b0011'1100};

std::byte b2{0b0000'1111};

// 按位与

std::byte b3 = b1 & b2;

std::cout << std::to_integer<int>(b3) << std::endl; // 输出 12 (0b0000'1100)

// 按位或

std::byte b4 = b1 | b2;

std::cout << std::to_integer<int>(b4) << std::endl; // 输出 63 (0b0011'1111)

// 按位异或

std::byte b5 = b1 ^ b2;

std::cout << std::to_integer<int>(b5) << std::endl; // 输出 51 (0b0011'0011)

// 按位取反

std::byte b6 = ~b1;

std::cout << std::to_integer<int>(b6) << std::endl; // 输出 195 (0b1100'0011)

// 左移

std::byte b7 = b1 << 1;

std::cout << std::to_integer<int>(b7) << std::endl; // 输出 120 (0b0111'1000)

// 右移

std::byte b8 = b1 >> 2;

std::cout << std::to_integer<int>(b8) << std::endl; // 输出 15 (0b0000'1111)

return 0;

}

#include <cstddef>

#include <iostream>

int main() {

std::byte b{0x2A}; // 42 in hexadecimal

int n = std::to_integer<int>(b);

std::cout << n << std::endl; // 输出 42

return 0;

}

`std::apply`

概述

C++17 引入的元组工具函数，用于将元组（std::tuple）的元素展开为函数的参数列表
1. 将参数包应用到可调用对象上

#include <tuple>

#include <iostream>

#include <functional>

int add(int a, int b) {

return a + b;

}

int main() {

std::tuple<int, int> t{1, 2};

std::cout << std::apply(add, t) << std::endl; // 输出 3

return 0;

}

#include <tuple>

#include <iostream>

void printSum(int a, int b, int c) {

std::cout << a + b + c << '\n';

}

int main() {

std::tuple<int, int, int> tpl{1, 2, 3};

std::apply(printSum, tpl); // 输出 6（等价于 printSum(1, 2, 3)）

}

支持 `Lambda` 和函数对象

auto multiply = [](int x, int y) { return x * y; };

std::tuple<int, int> nums{4, 5};

int result = std::apply(multiply, nums); // 返回 20

结合结构化绑定

auto tpl = std::make_tuple(42, "hello", 3.14);

std::apply([](int n, const char* s, double d) {

std::cout << n << " " << s << " " << d << '\n';

}, tpl); // 输出 "42 hello 3.14"

处理成员函数

#include <functional> // 需要 std::invoke

struct Calculator {

int add(int a, int b) { return a + b; }

};

int main() {

Calculator calc;

auto args = std::make_tuple(7, 8);

// 使用 std::invoke 处理成员函数

int sum = std::apply(

[&calc](int a, int b) { return calc.add(a, b); },

args

); // 返回 15

}

元编程模板

C++11/14
1. 需要手动解包

template<size_t... Is, typename Tuple>

void printTupleImpl(Tuple&& tpl, std::index_sequence<Is...>) {

(void)std::initializer_list<int>{

(std::cout << std::get<Is>(tpl) << ' ', 0)...

};

}

template<typename Tuple>

void printTuple(Tuple&& tpl) {

printTupleImpl(std::forward<Tuple>(tpl),

std::make_index_sequence<std::tuple_size_v<Tuple>>{});

}

C++17新方法（std::apply）

void printTuple(auto&& tpl) {

std::apply([](auto&&... args) {

((std::cout << args << ' '), ...);

}, tpl);

}

`std::invoke`

概述

统一调用语法
1. 无论调用对象类型如何，均使用相同语法：

#include <functional>

// 调用普通函数

int add(int a, int b) { return a + b; }

std::invoke(add, 3, 4); // 返回 7

// 调用成员函数

struct Calculator {

int multiply(int a, int b) { return a * b; }

};

Calculator calc;

std::invoke(&Calculator::multiply, calc, 5, 6); // 返回 30

// 访问成员变量

struct Point { int x, y; };

Point p{10, 20};

std::invoke(&Point::x, p); // 返回 10

支持所有可调用类型


类型	示例
普通函数	`std::invoke(add, 1, 2)`
成员函数	`std::invoke(&Class::method, obj, args...)`
成员变量	`std::invoke(&Class::member, obj)`
函数对象	`std::invoke([](int x) { return x*2; }, 3)`
函数指针	`std::invoke(func_ptr, args...)`

用于调用可调用对象

#include <iostream>

#include <functional>

struct Foo {

void display() const {

std::cout << "Hello, World!" << std::endl;

}

};

int main() {

Foo f;

std::invoke(&Foo::display, f); // 输出 Hello, World!

return 0;

}

成员函数的调用方式

自动处理对象类型（对象实例/指针/引用）

Calculator calc;

Calculator* pCalc = &calc;

// 等价调用

std::invoke(&Calculator::multiply, calc, 2, 3); // 对象实例

std::invoke(&Calculator::multiply, pCalc, 2, 3); // 对象指针

std::invoke(&Calculator::multiply, std::ref(calc), 2, 3); // 引用

完美转发参数

template<typename Callable, typename... Args>

auto wrapper(Callable&& func, Args&&... args) {

return std::invoke(std::forward<Callable>(func),

std::forward<Args>(args)...);

}

与`std::apply` 结合

展开元组参数进行调用：

auto args = std::make_tuple(8, 9);

std::apply(

[](int a, int b) { return std::invoke(add, a, b); },

args

); // 返回 17

动态内存分配对齐控制

支持指定动态内存的对齐方式：

1 2	struct alignas(64) CacheLine { /.../ }; auto* p = new CacheLine; // 自动按 64 字节对齐

`constexpr` 静态数据成员

允许在类内直接初始化 constexpr static 成员：

struct Constants {

static constexpr double pi = 3.1415926; // 无需类外定义（C++17 前需要）

};

标准库新增

`std::from_chars` 和 `std::to_chars`

高性能字符串与数值的转换（不依赖本地化设置，无异常）：

#include <charconv>

const char* str = "42";

int value;

auto [ptr, ec] = std::from_chars(str, str + 2, value);

if (ec == std::errc{}) {

std::cout << value; // 输出 42

}

`std::sample`

从序列中随机抽样元素：

#include <algorithm>

#include <iterator>

#include <random>

std::vector<int> data{1, 2, 3, 4, 5};

std::vector<int> samples(3); // 存储 3 个样本

std::sample(data.begin(), data.end(), samples.begin(), 3, std::mt19937{});

`std::scoped_lock`

多锁的 RAII 包装器，避免死锁：

std::mutex mtx1, mtx2;

{

std::scoped_lock lock(mtx1, mtx2); // 同时锁定 mtx1 和 mtx2

// 临界区代码

} // 自动释放所有锁

`std::not_fn`

通用逻辑非包装器，替代 std::not1/not2：

auto is_positive = [](int x) { return x > 0; };

auto is_non_positive = std::not_fn(is_positive);

bool result = is_non_positive(-5); // true

平凡类类型

概述

在C++中，平凡类类型（Trivial Types）是指具有非常简单构造和析构行为的类型
它们的对象可以通过简单的位复制（bitwise copy）来创建和销毁，而不需要额外的构造和析构代码

定义

平凡的默认构造函数：
1. 如果有默认构造函数，它必须是平凡的，即编译器自动生成的，或者显式定义但没有自定义代码
2. 隐式生成或显式 = default，且不执行额外操作
平凡的拷贝构造函数：
1. 如果有拷贝构造函数，它必须是平凡的，即编译器自动生成的，或者显式定义但没有自定义代码
2. 隐式生成或显式 = default
平凡的拷贝赋值运算符：
1. 如果有拷贝赋值运算符，它必须是平凡的，即编译器自动生成的，或者显式定义但没有自定义代码
2. 隐式生成或显式 = default
平凡的移动构造函数（C++11起）：
1. 如果有移动构造函数，它必须是平凡的，即编译器自动生成的，或者显式定义但没有自定义代码
2. 隐式生成或显式 = default
平凡的移动赋值运算符（C++11起）：
1. 如果有移动赋值运算符，它必须是平凡的，即编译器自动生成的，或者显式定义但没有自定义代码
2. 隐式生成或显式 = default
平凡的析构函数：
1. 如果有析构函数，它必须是平凡的，即编译器自动生成的，或者显式定义但没有自定义代码
2. 隐式生成或显式 = default，且不虚化
没有虚函数和虚基类：
1. 类型不能有虚函数或虚基类

示例

平凡的

struct TrivialType {

int x;

double y;

// 默认构造函数、拷贝构造函数、赋值运算符、析构函数都是编译器生成的

};

不平凡的

struct NonTrivialType {

int x;

NonTrivialType() { x = 42; } // 自定义的默认构造函数

};

检查类型

#include <iostream>

#include <type_traits>

struct TrivialType {

int x;

double y;

};

struct NonTrivialType {

int x;

NonTrivialType() { x = 42; }

};

int main() {

std::cout << std::boolalpha;

std::cout << "TrivialType is trivial: " << std::is_trivial<TrivialType>::value << std::endl;

std::cout << "NonTrivialType is trivial: " << std::is_trivial<NonTrivialType>::value << std::endl;

return 0;

}

平凡类型的关键用途

高效内存操作
1. 平凡类型支持 memcpy/memmove 等底层操作，常用于序列化或数据传输：

TrivialType obj1{42, 3.14};

TrivialType obj2;

std::memcpy(&obj2, &obj1, sizeof(TrivialType)); // 安全且高效

静态初始化优化
1. 平凡类型可能在编译期直接初始化，减少运行时开销：

1	constexpr TrivialType globalObj{1, 2.0}; // 可能静态初始化

`C++17`相关

聚合类的扩展
1. C++17 允许聚合类包含 public 基类（需非虚继承），这可能导致某些类型更易满足平凡性条件：

// C++17 中的聚合类（包含基类）

struct Base { int a; };

struct Derived : Base { int b; }; // 聚合类（C++17）

static_assert(std::is_trivial_v<Derived>); // 成立（若基类和成员均平凡）

类型特性工具完善
1. C++17 新增的 std::is_aggregate 类型特征，结合 std::is_trivial 可更精确判断类型性质：

struct Aggregate { int x; };

static_assert(std::is_aggregate_v<Aggregate>); // C++17

static_assert(std::is_trivial_v<Aggregate>); // 成立

`std::is_trivial<T>`

检测是否平凡

struct NonTrivial {

NonTrivial() {} // 非平凡构造函数

};

static_assert(!std::is_trivial_v<NonTrivial>); // 不成立

`std::is_trivially_copyable<T>`

检测是否可平凡复制

与结构化绑定

平凡类型可直接解构：

1 2	TrivialType obj{10, 20.5}; auto& [x, y] = obj; // 合法（若成员均为 public）

与内联变量

平凡类型支持内联初始化：

1	inline TrivialType globalObj{5, 6.28}; // C++17 内联变量

结构化绑定
嵌套命名空间
std::filesystem
std::variant
std::variant 和 std::visit
std::any
文件系统库
constexpr 的改进
[[nodiscard]] 属性
折叠表达式（Fold Expressions）
std::byte
std::apply
概述
支持 Lambda 和函数对象
结合结构化绑定
处理成员函数
元编程模板
std::invoke
概述
支持所有可调用类型
成员函数的调用方式
完美转发参数
与std::apply 结合
动态内存分配对齐控制
constexpr 静态数据成员
标准库新增
std::from_chars 和 std::to_chars
std::sample
std::scoped_lock
std::not_fn
平凡类类型
概述
定义
示例
检查类型
平凡类型的关键用途
C++17相关
std::is_trivial<T>
std::is_trivially_copyable<T>
与结构化绑定
与内联变量

本文为原创文章，版权归Aet所有，欢迎分享本文，转载请保留出处！

Bingliaolong 关注：0 粉丝：0 最后编辑于：2025-03-21

Everything will be better.

C++17_第三篇

结构化绑定

嵌套命名空间

std::filesystem

std::variant

std::variant 和 std::visit

std::any

文件系统库

constexpr 的改进

[[nodiscard]] 属性

折叠表达式（Fold Expressions）

std::byte

std::apply

概述

支持 Lambda 和函数对象

结合结构化绑定

处理成员函数

元编程模板

std::invoke

概述

支持所有可调用类型

成员函数的调用方式

完美转发参数

与std::apply 结合

动态内存分配对齐控制

constexpr 静态数据成员

标准库新增

std::from_chars 和 std::to_chars

std::sample

std::scoped_lock

std::not_fn

平凡类类型

概述

定义

示例

检查类型

平凡类型的关键用途

C++17相关

std::is_trivial<T>

std::is_trivially_copyable<T>

与结构化绑定

与内联变量

你可能也喜欢

热评文章

发表评论

标签云集

`std::filesystem`

`std::variant`

`std::variant` 和 `std::visit`

`std::any`

`constexpr` 的改进

`[[nodiscard]]` 属性

`std::byte`

`std::apply`

支持 `Lambda` 和函数对象

`std::invoke`

与`std::apply` 结合

`constexpr` 静态数据成员

`std::from_chars` 和 `std::to_chars`

`std::sample`

`std::scoped_lock`

`std::not_fn`

`C++17`相关

`std::is_trivial<T>`

`std::is_trivially_copyable<T>`