笔记大全

C11C14C17C20常用新特性有哪些

更新时间：2023-10-02

1. C++11 新特性

C++11 是 C++ 标准委员会在 2011 年发布的 C++ 标准，它引入了许多重要的新特性，其中一些被广泛使用。以下是一些 C++11 的常用特性：

//初始化列表
struct MyStruct {
  int x;
  double y;
  MyStruct(int a, double b) : x(a), y(b) {}
};
MyStruct s{ 42, 3.14 };

//自动类型推导
auto i = 42;
auto d = 3.14;

//Lambda表达式
std::vector<int> v{ 1, 2, 3 };
std::for_each(v.begin(), v.end(), [](int x){ std::cout << x << std::endl; });

//右值引用
void foo(std::string&&s) {
  std::cout << s << std::endl;
}
foo("Hello, world!");

//多线程
#include <thread>
#include <iostream>
void print_hello() {
  std::cout << "Hello, world!\n";
}
int main() {
  std::thread t(print_hello);
  t.join();
  return 0;
}

2. C++14 新特性

C++14 是在 C++11 基础上推出的一个新标准，主要着眼于优化现有的特性，提高代码的表现力和可读性。以下是一些 C++14 的常用特性：

//变长参数模板
template <typename... Ts>
void foo(Ts... args) {
  std::cout << sizeof...(args) << std::endl;
}
foo(1, 2.2, "hello"); //输出3

//泛型 Lambda
auto foo = [](auto x, auto y) { return x + y; };
std::cout << foo(1, 2) << std::endl; //输出3
std::cout << foo(1.1, 2.2) << std::endl; //输出3.3

//二进制字面量和分隔符
auto x = 0b1011'0010'1101'0110;
auto y = 1'000'000'000;

//后置返回类型
template <typename T, typename U>
auto add(T t, U u) -> decltype(t + u) {
  return t + u;
}

//constexpr 函数
constexpr int get_array_size(int n) {
  int a[n];
  return sizeof(a) / sizeof(int);
}
constexpr int size = get_array_size(42);

3. C++17 新特性

C++17 是在 C++14 基础上发布的新标准，引入了一些有趣的新特性，可以进一步提高代码的可靠性和可读性。以下是一些 C++17 的常用特性：

//简化的 if 语句和 switch 语句
if (int x = get_value(); x > 0) {
  std::cout << x << std::endl;
}

switch (int x = get_value(); x) {
  case 0: std::cout << "zero" << std::endl; break;
  case 1: std::cout << "one" << std::endl; break;
  default: std::cout << "other" << std::endl; break;
}

//折叠表达式
template <typename... Ts>
int sum(Ts... args) {
  return (args + ...);
}
std::cout << sum(1, 2, 3, 4) << std::endl; //输出10

//结构化绑定
std::pair<int, double> p{ 42, 3.14 };
auto [x, y] = p;
std::cout << x << " " << y << std::endl; //输出42 3.14

//if constexpr
template <typename T>
void foo(T t) {
  if constexpr(std::is_integral_v<T>) {
    std::cout << "integral type" << std::endl;
  } else {
    std::cout << "other type" << std::endl;
  }
}

//constexpr lambda
auto identity = [] (const auto& x) { return x; };
static_assert(identity(42) == 42);

4. C++20 新特性

C++20 是最新的 C++ 标准，引入了许多新特性，包括模块、概念、协程等，以及对现有特性的优化和改进。以下是一些 C++20 的常用特性：

//模块
module;
export module mymodule;
export int add(int x, int y) { return x + y; }

//概念
template <typename T> concept Integral = std::is_integral_v<T>;
template <Integral T> void foo(T t) { std::cout << "Integral" << std::endl; }
foo(42);

//协程
#include <iostream>
#include <coroutine>
struct my_coroutine {
  struct promise_type {
    int current_value;
    auto get_return_object() { return *this; }
    auto initial_suspend() { return std::suspend_never{}; }
    auto final_suspend() { return std::suspend_never{}; }
    void unhandled_exception() { std::terminate(); }
    void return_void() {}
    auto yield_value(int value) {
      current_value = value;
      return std::suspend_always{};
    }
  };
  my_coroutine(promise_type& promise) : promise_(promise) {}
  bool next() { return false; }
  promise_type& promise_;
};
my_coroutine::promise_type coro_promise;
my_coroutine coro(coro_promise);
coro.next();

//三位运算符
int number = 42;
std::string result = (number > 0) ? "positive" : "non-positive";

//constexpr std::string_view
constexpr std::string_view str = "hello, world";
std::cout << str.substr(0, 5) << std::endl; //输出hello

总结：C++11 至 C++20 的新特性不仅提高了代码的效率和可读性，而且使得 C++ 语言更加灵活和易于使用。程序员可以根据自己的需求选择适合的特性，以提高开发效率和代码可靠性。然而，在使用这些特性时需要注意规范和最佳实践，以避免出现意外的错误和不必要的问题。

c语言编程笔录