C++14新特性详解：语言改进与标准库扩展

C++14新特性详解：语言改进与标准库扩展 #

C++14 包含以下新的语言特性：

C++14 包含以下新的库特性：

C++14 语言特性 #

二进制字面量 #

二进制字面量提供了一种方便的方式来表示二进制数。可以使用 ' 分隔数字。

0b110 // == 6
0b1111'1111 // == 255

泛型 lambda 表达式 #

C++14 现在允许在参数列表中使用 auto 类型说明符，从而支持多态 lambda 表达式。

auto identity = [](auto x) { return x; };
int three = identity(3); // == 3
std::string foo = identity("foo"); // == "foo"

lambda 捕获初始化器 #

这允许创建使用任意表达式初始化的 lambda 捕获。捕获值的名称不需要与任何外部作用域中的变量相关，并且会在 lambda 体内部引入一个新的名称。初始化表达式在 lambda 创建时 而不是 调用时 进行求值。

int factory(int i) { return i * 10; }
auto f = [x = factory(2)] { return x; }; // 返回 20

auto generator = [x = 0] () mutable {
  // 如果没有 `mutable`，则无法编译，因为我们在每次调用时修改了 x
  return x++;
};
auto a = generator(); // == 0
auto b = generator(); // == 1
auto c = generator(); // == 2

由于现在可以将值 移动（或 转发）到 lambda 中，而不仅仅是通过拷贝或引用捕获，因此我们可以捕获那些只能通过值捕获的移动独占类型。注意在以下示例中，task2 的捕获列表中左侧的 p 是 lambda 体内部的一个新变量，而不是原始的 p。

auto p = std::make_unique<int>(1);

auto task1 = [=] { *p = 5; }; // 错误：std::unique_ptr 不能被拷贝
// vs.
auto task2 = [p = std::move(p)] { *p = 5; }; // OK：p 被移动构造到闭包对象中
// task2 创建后，原始的 p 已为空

使用这种引用捕获可以与引用的变量有不同的名称。

auto x = 1;
auto f = [&r = x, x = x * 10] {
  ++r;
  return r + x;
};
f(); // 将 x 设置为 2，并返回 12

返回类型推导 #

在 C++14 中，使用 auto 作为返回类型时，编译器会尝试为你推导类型。对于 lambda 表达式，现在可以使用 auto 推导其返回类型，从而可以返回推导出的引用或右值引用。

// 推导返回类型为 `int`
auto f(int i) {
 return i;
}

template <typename T>
auto& f(T& t) {
  return t;
}

// 返回一个引用到推导出的类型
auto g = [](auto& x) -> auto& { return f(x); };
int y = 123;
int& z = g(y); // 引用到 `y`

decltype(auto) #

decltype(auto) 类型说明符也像 auto 一样推导类型。然而，它在推导返回类型时会保留引用和 cv 限定符，而 auto 则不会。

const int x = 0;
auto x1 = x; // int
decltype(auto) x2 = x; // const int
int y = 0;
int& y1 = y;
auto y2 = y1; // int
decltype(auto) y3 = y1; // int&
int&& z = 0;
auto z1 = std::move(z); // int
decltype(auto) z2 = std::move(z); // int&&

// 注意：这对于泛型代码尤其有用！

// 返回类型为 `int`
auto f(const int& i) {
 return i;
}

// 返回类型为 `const int&`
decltype(auto) g(const int& i) {
 return i;
}

int x = 123;
static_assert(std::is_same<const int&, decltype(f(x))>::value == 0);
static_assert(std::is_same<int, decltype(f(x))>::value == 1);
static_assert(std::is_same<const int&, decltype(g(x))>::value == 1);

详见：decltype (C++11)。

放宽 constexpr 函数的限制 #

在 C++11 中，constexpr 函数体只能包含非常有限的语法，包括（但不限于）：typedef、using 和一个 return 语句。C++14 中，允许的语法大幅扩展，包括常见的语法，如 if 语句、多个 return、循环等。

constexpr int factorial(int n) {
  if (n <= 1) {
    return 1;
  } else {
    return n * factorial(n - 1);
  }
}
factorial(5); // == 120

变量模板 #

C++14 允许对变量进行模板化：

template<class T>
constexpr T pi = T(3.1415926535897932385);
template<class T>
constexpr T e  = T(2.7182818284590452353);

[[deprecated]] 属性 #

C++14 引入了 [[deprecated]] 属性，用于表明某个单元（函数、类等）不推荐使用，并可能引发编译警告。如果提供了原因，将会包含在警告中。

[[deprecated]]
void old_method();
[[deprecated("Use new_method instead")]]
void legacy_method();

C++14 库特性 #

标准库类型的用户自定义字面量 #

为标准库类型提供了新的用户自定义字面量，包括为 chrono 和 basic_string 提供的内置字面量。这些字面量可以是 constexpr，因此可以在编译时使用。这些字面量的一些用途包括编译时整数解析、二进制字面量和虚数字面量。

using namespace std::chrono_literals;
auto day = 24h;
day.count(); // == 24
std::chrono::duration_cast<std::chrono::minutes>(day).count(); // == 1440

编译时整数序列 #

类模板 std::integer_sequence 表示一个编译时整数序列。在此基础上有一些辅助工具：

  • std::make_integer_sequence<T, N> - 创建一个类型为 T 的 0, ..., N - 1 序列。
  • std::index_sequence_for<T...> - 将模板参数包转换为整数序列。

将数组转换为元组：

template<typename Array, std::size_t... I>
decltype(auto) a2t_impl(const Array& a, std::integer_sequence<std::size_t, I...>) {
  return std::make_tuple(a[I]...);
}

template<typename T, std::size_t N, typename Indices = std::make_index_sequence<N>>
decltype(auto) a2t(const std::array<T, N>& a) {
  return a2t_impl(a, Indices());
}

std::make_unique #

std::make_unique 是创建 std::unique_ptr 实例的推荐方式，原因如下：

  • 避免使用 new 操作符。
  • 避免在指定指针所持有的底层类型时重复代码。
  • 最重要的是，它提供了异常安全性。假设我们像这样调用一个函数 foo：
foo(std::unique_ptr<T>{new T{}}, function_that_throws(), std::unique_ptr<T>{new T{}});

编译器可以自由地先调用 new T{}，然后调用 function_that_throws()，依此类推……由于我们在第一个 T 的构造中分配了堆内存，因此这里引入了内存泄漏。使用 std::make_unique，我们可以获得异常安全性：

foo(std::make_unique<T>(), function_that_throws(), std::make_unique<T>());

有关 std::unique_ptr 和 std::shared_ptr 的更多信息，请参阅 智能指针 (C++11) 部分。

致谢 #

© 2025 C++ 编程指南 | 沪ICP备2023022925号-2