C++17 为 C++ 语言带来了许多功能。本文深入研究其中的三个，它们有助于使编码更容易、更简洁、更直观和正确。

 开始。结构化绑定适用于许多情况，本文介绍几种情况可以使代码更简洁、更简单。介绍 

，可以删除习惯键入的模板参数。最后介绍用“

”更好控制对象范围，并允许定义它们所属的值。

结构化绑定允许一次性定义多个对象，其方式比以前的 C++ 版本更自然。从 C++11 到 C++17，这个概念本身并不新鲜。C++17以前，始终可以从函数返回多个值并使用

std::tuple<char, int, bool> mytuple()
{
    char a = 'a';
    int i = 123;
    bool b = true;
    return std::make_tuple(a, i, b);
}

这返回三个不同类型的变量。要从 C++17 之前调用函数访问这些函数，要如下内容：

char a;
int i;
bool b;

std::tie(a, i, b) = mytuple();

其中必须在用前定义变量并预先了解类型。

但是使用结构化绑定，可以简单执行为：

这是一种更好的语法，几乎尽可能用

那么，什么可以与结构化绑定初始化一起使用呢？基本上任何复合类型

。让我们看看它可能有用的几种情况。

这是一次性将复合类型的各个部分（如

等）分配给不同变量并自动分配正确类型的简单方法。例如，如果把数据插入到

std::map<char,int> mymap;
auto mapret = mymap.insert(std::pair('a', 100));

可能有人想知道上面的代码为什么没有明确说明配对的类型，这就是后面要讲的 

 了，请接着往下阅读。因此，为了确定数据插入是否成功，可以从插入方法返回的内容

问题在于，读者应该需要查找什么才能确定是否插入成功。但是使用结构化绑定，这将变成：

auto [itelem, success] = mymap.insert(std::pair(’a’, 100));
If (!success) {
    // Insert failure
}

用于表示插入成功。变量的类型是从赋值中自动推断出来的——这在阅读代码时更有意义。

 作为本文最后一节的内容，这里先睹为快，由于 C++17 现在具有

if (auto [itelem, success] = mymap.insert(std::pair(‘a’, 100)); success) {
    // Insert success
}

结构化绑定也适用于范围。因此，考虑到前面的 

 定义，在 C++17 之前是使用如下所示的代码对其进行迭代：

for (const auto& entry : mymap) {
    // Process key as entry.first
    // Process value as entry.second
}

for (const auto& entry : mymap) {
    auto& key = entry.first;
    auto& value = entry.second;
    // Process entry
}

但是结构化绑定允许更直接地编写它：

for (const auto&[key, value] : mymap) {
    // Process entry using key and value
}

更具指导意义，并且不需要额外的变量定义。

等进行初始化，我们可以以这种方式进行直接初始化吗？

auto a = ‘a’;
auto i = 123;
auto b = true;

auto [a, i, b] = tuple(‘a’, 123, true);    // With no types needed for the tuple!

 定义得就像使用了上面的单独定义一样。

这真的是对之前定义的改进吗？已经在一行中完成了本来需要三行才能完成的工作，但为什么要这样做呢？考虑以下代码：

{
    istringstream iss(head);
    for (string name; getline(iss, name); )
    // Process name
}

 语句之外和它自己的块内声明，以便将范围限制在所需的范围内。

 循环。始终可以初始化相同类型的多个变量。例如：

for (int i = 0, j = 100; i < 42; ++i, --j) {
    // Use i and j
}

for (int i = 0, char ch = ‘ ‘; i < 42; ++i) {    // Does not compile
    // Use i and ch
}

使用结构化绑定，我们就可以这样编写：

for (auto[iss, name] = pair(istringstream(head), string {}); getline(iss, name); ) {
    // Process name
}

for (auto[i, ch] = pair(0U, ‘ ‘); i < 42; ++i) {  // The 0U makes i an unsigned int
    // Use i and ch
}

），并且还可以自动确定它们的类型。

if (auto [a, b] = myfunc(); a < b) {
    // Process using a and b
}

注意，并不能用结构化绑定做所有事情，试图让它们适应每种情况会使代码更加复杂。比如：

if (auto [box, bit] = std::pair(std::stoul(p), boxes.begin()); (bit = boxes.find(box)) != boxes.end()){
    // Process if using both box and bit variables
}

返回的初始值。对于那些不熟悉它的人来说，

是一个函数，它以类型作为其第一个参数（还有其他可选参数

），并将其内容解析为指定基数的整数（默认为 10），该函数作为无符号长整型值返回。

 语句的条件测试部分设置的。这突出显示了以这种方式使用结构化绑定的约束。我们真正想写的是：

if (const auto [box, bit] = std::pair(std::stoul(p), boxes.find(box)); bit != boxes.end()){
    // This doesn’t compile
    // Process if using both box and bit variables
}

类型说明符中声明的变量不能出现在它自己的初始值设定项中！这是可以理解的。

）。这不一定会影响性能（无论如何，它只在循环开始时执行一次），因为将尽可能使用移动语义。但需要注意，如果使用的类型是不可移动的（例如，

），那么这可能会产生性能“hit”，具体取决于复制操作涉及的内容。

不要预先判断编译器和预先优化代码！如果性能不符合要求，则使用分析器查找瓶颈，否则就是在浪费开发时间。只需编写最简单、最干净的代码即可。

模板参数推导是模板化类在不明确说明类型的情况下确定构造函数传递的参数类型的能力。

在 C++17 之前，要构造模板化类的实例，必须显式声明参数的类型（或使用其中一个支持函数

类的实例，并使用 2 和 4.5 进行初始化。或者实现此目的的另一种方法是：

这两种方法都有各自的缺点。创建“make 函数”是不清楚的、人为的，并且与非模板类的构造方式不一致。

等在标准库中可用，但对于用户定义的类型来说，情况更糟：必须编写自己的

应该是不必要的，因为它们可以从参数的类型中推断出来——就像模板函数一样。

因此，在 C++17 中，已取消指定模板化类构造函数类型的要求。这意味着现在可以这样写：

auto p = std::pair(2, 4.5);
// 或
std::pair p(2, 4.5);

这是期望能够定义的逻辑方式！

函数可以使用模板参数推导（以及函数返回类型的

auto mytuple()
{
    char a = 'a';
    int i = 123;
    bool b = true;
    return std::tuple(a, i, b);  // No types needed
}

这是一种更简洁的编码方式。在这种情况下，甚至可以将其包装为：

auto mytuple()
{
    return std::tuple(‘a’, 123, true);  // Auto type deduction from arguments
}

语句中进行可选的变量初始化，类似于 

 语句中使用的初始化。例如：

for (int a = 0; a < 10; ++a) {
    // for body
}

的范围仅限于 for 语句。但下面的代码：

{
    auto a = getval();
    if (a < 10) {
    // Use a
    }
}

仅在 if 语句中使用，但如果想限制其范围，则必须在其自己的块中定义变量。在 C++17 中，这可以写成：

if (auto a = getval(); a < 10) {
    // Use a
}

它遵循与 for 语句相同的初始化语法：初始化部分与选择部分用分号

分隔。同样的初始化语法也可以与 

switch (auto ch = getnext(); ch) {
    // case statements as needed
}

这一切都很好地帮助C++变得更加简洁，直观和正确！有多少人编写过这样的代码：

int a;
if ((a = getval()) < 10) {
    // Use a
}

...

// Much further on in the code – a has the same value as previously

if (a == b) {
    //...
}

没有正确初始化（错误），但由于早期的定义而没有被编译器拾取。这仍在范围内，因为它没有在自己的

块中定义。如果这在 C++17 中，可以这样写：

if (auto a = getval(); a < 10) {
    // Use a
}

... // Much further on in the code - a is not now defined

if (a == b) {
    // ...
}

然后，这将被编译器拾取并报告为错误。修复编译器错误的成本远低于未知运行时问题！

已经了解了结构化绑定如何允许单个声明声明一个或多个局部变量，这些变量可以具有不同的类型，并且其类型始终使用单个

，它们可以从复合类型中分配。

模板参数推导允许避免编写冗余的模板参数和辅助函数来推导它们。选择初始化使 

 语句一致，并避免了变量作用域过大的陷阱。

3个令人惊叹的C++17功能，让代码变得更简洁

本文介绍几种情况可以使代码更简洁、更简单。介绍 模板参数推导，可以删除习惯键入的模板参数。

数据库

C++17引入结构化绑定、模板参数推导和选择初始化三大特性，显著提升代码简洁性与安全性。结构化绑定支持自动解构复合类型，模板参数推导简化模板类构造，选择初始化优化变量作用域控制。这些改进使C++编码更高效直观，同时减少潜在错误。

编译器

5位重磅专家聚焦 AI 时代开发者核心成长需求，带你深入解锁全栈进化、人机协作关键路径！点击报名到场：<a href="https://cloud.tencent.com/developer/salon/salon-2403/signup" target="_blank">https://cloud.tencent.com/developer/salon/salon-2403/signup</a><br/> 
 <img src="https://qcloudimg.tencent-cloud.cn/raw/487c82639d2338df3ef66dfb1450601a.png"/>

腾讯技术创作特训营「年度论坛」正在报名中！

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

3个令人惊叹的C++17功能，让代码变得更简洁

3个令人惊叹的C++17功能，让代码变得更简洁

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐