当前位置：首页 > news >正文

最常使用的现代C++新特性介绍

news 来源：原创 2025/4/29 15:20:24

现代 C++泛指的是从 C++11 之后的 C++标准. 从 C++11 开始, C++标准委员会实行班车制, 没三年发布一个新版本, 如果一个功能在新版本发布之前已经准备好, 则可以加入该版本中, 否则延后到下一个版本.

语言核心

自 C++11 开始, 语言语法层面加了许多语法糖, 还有增加了一些新语法.使得 C++语言更加简洁, 更加易读, 同时更不容易出错.

`auto`自动类型推导

auto允许程序员在声明变量的时候让编译器自动推导变量的类型, 而不需要显式声明变量的类型.

#include <string>

int main() {
  auto x = 1;
  auto s = "Hello";
  auto str = std::string("World");

  // C++11 之前
  std::string::iterator it1 = str.begin();
  // C++11 之后
  auto it = str.begin();
}

在`if/switch`中声明变量

增加了语法糖, 允许在if/switch中声明一个变量, 这样一方面简化写法, 另一方面限制了变量的可见范围, 提高安全性.

#include <fcntl.h>
#include <unistd.h>

#include <iostream>

char getOption() { return 'y'; }
int main() {
  if (auto ret = open("output.txt", O_RDONLY); ret != -1) {
    std::cout << "open file success" << std::endl;
    close(ret);
  }

  switch (auto c = getOption(); c) {
    case 'y':
      [[fallthrough]];
    case 'Y':
      std::cout << "yes" << std::endl;
      break;
    default:
      break;
  }
}

Range based for loop

增加了语法糖, 可以简化for循环写法, 并同时提升安全性.

#include <vector>
#include <print>

int main() {
  // 遍历 vector
  std::vector v{1, 2, 3};
  for (auto num : v) {
    std::println("{}", num);
  }

  // 遍历数组
  int array[] = {1, 2, 3};
  for (auto num : array) {
    std::println("{}", num);
  }
}

结构化绑定

#include <map>
#include <print>
#include <string>

int main() {
  std::map<std::string, int> map = {{"a", 1}, {"b", 2}};
  for (auto [key, value] : map) {
    std::println("{}:{}", key, value);
  }

  // bind to tuple
  auto tuple = std::make_tuple(1, 2, 3);
  auto [a, _, c] = tuple;
  std::println("a={}", a);
}

统一初始化

支持通过花括号{}初始化任意类型的变量. 对泛型编程的场景帮助很大.

#include <string>
#include <vector>

int main() {
  int a{0};
  std::string str{"Hello"};

  struct S {
    std::string name;
    float num;
    S(std::string s, float f) : name(s), num(f) {}
  };
  S s1{"Alan", 2.7};

  std::vector<S> v{s1, {"Bob", 85.9}};
}

进一步阅读: C++ 类成员初始化发展历程(从 C++11 到 C++20)

移动语义

移动语义是 C++11 引入的, 主要用来减少不必要的拷贝, 提升性能. 对于一些临时变量, 或者说不会再使用的变量, 则可以采用移动语义来减少拷贝.

#include <string>
#include <vector>

std::string GetStr() { return "Hello"; }
int main() {
  std::vector<std::string> vec;
  auto s = GetStr();

  vec.emplace_back(s);             // copy
  vec.emplace_back(s + "World");   // move
  vec.emplace_back(GetStr());      // move
  vec.emplace_back(std::move(s));  // move
  return 0;
}

进一步阅读: C++ 必知必会: 移动语义(Move Semantics)

lambdas 表达式

在编程中经常会用到一些临时函数或者工具函数, 只在局部使用, 并且功能简单. 以往的方式会造成声明语使用位置相距比较远, 影响可读性. lambda 表达式可以允许我们定义一个临时的函数, 并且可以省略函数名.

#include <algorithm>
#include <string>
#include <vector>

int main() {
  struct Record {
    std::string s1;
    std::string s2;
  };

  std::vector<Record> v = {{"A", "1"}, {"B", "0"}, {"a", "2"}};
  std::sort(v.begin(), v.end(), [](const auto& p1, const auto& p2) {
    return p1.s1 < p2.s1 || (p1.s1 == p2.s1 && p1.s2 < p2.s2);
  });
}

进一步阅读: C++ Lambda 表达式: 简洁与高效的完美结合

`constexpr`

constexpr 用来声明一个常量表达式, 可以在编译期计算出结果, 并且可以避免运行时计算. 相比起宏定义, constexpr 更加类型安全, 因为本质上讲define是字符串替换, 没有类型检查.

#define SIZE 64
constexpr int size = 64;

进一步阅读:

C++ constexpr, consteval 和 constinit 简要介绍
C++ 中的 const 和 constexpr: 深入对比与最佳实践

标准库

多线程编程

线程(std::thread/std::jthread). C++11 引入了线程, 并在 C++20 加入了满足 RAII 要求的jthread. 详情参考: C++20 std::jthread 完全指南 - 简化多线程编程与线程管理
原子变量(std::atomic): 是一种特殊的变量类型, 它支持原子操作, 这些操作在多线程环境下是不可分割的, 也就是不会被其他线程的操作打断. 这有助于避免多线程访问共享资源时产生的数据竞争问题, 保证数据安全. 进一步阅读: Modern C++ 中的 std::atomic 简介
互斥锁(std::mutex): 是一种同步机制, 它保证多个线程对共享资源的访问是互斥的. 进一步阅读: 现代 C++锁介绍
Latch 和 Barrier: 线程同步机制, 它们可以确保多个线程在某个事件发生之前不会继续执行. 进一步阅读: C++ Latch 和 Barrier: 新手指南

工具类

string_view: 轻量级视图, 它只包含对数据的引用, 不包含数据本身. 可以简单理解为包含了字符串的指针和长度. 详情参考: 深入理解 C++ std::string_view — 高效字符串操作的利器
optional: 顾名思义, 这个工具包含的数据可能为空, 通常用于表示一个可选的值. 进一步阅读: 现代 C++ 必备知识: 解锁 std::optional, std::variant 和 std::any
variant: 是对于传统的union的一种更安全的替代. 可以保存多个类型的值, 但是只能存储其中一个.
any: any相对于一个特定类型的值就好比void *对于一种特定类型的指针. any可以被赋值为任何类型, 但是只能读取为原始类型.
expected: 对于返回值+错误提示的一种通用表示, 在成功的情况下返回一个可用的值, 否则返回对应的错误类型. 进一步阅读: 解读 C++23 std::expected 函数式写法