这篇文章主要介绍“C++11、C++14、C++17、C++20常用新特性有哪些”,在日常操作中,相信很多人在C++11、C++14、C++17、C++20常用新特性有哪些问题上存在疑惑,小编查阅了各式资料,整理出简单好用的操作方法,希望对大家解答”C++11、C++14、C++17、C++20常用新特性有哪些”的疑惑有所帮助!接下来,请跟着小编一起来学习吧!
C++11
自动类型推断(auto关键字):C++11引入了auto关键字,可以根据变量初始值自动推导出变量类型。例如:
auto i = 42; // i被推导为int类型 auto d = 3.14; // d被推导为double类型
基于范围的for循环(range-based for loop):可以方便地遍历容器中的元素,例如:
std::vector<int> v = {1, 2, 3, 4, 5}; for (auto& i : v) { i *= 2; }
lambda表达式:lambda表达式可以用来定义匿名函数,方便地传递函数对象,例如:
auto f = [](int x, int y) -> int { return x + y; }; int result = f(3, 4); // result = 7
移动语义和右值引用(move semantics和rvalue references):通过右值引用可以实现资源的有效移动而不是复制,提高程序的效率,例如:
std::vector<int> v1 = {1, 2, 3, 4, 5}; std::vector<int> v2 = std::move(v1); // v2接管了v1的资源,v1变为无效状态
智能指针(smart pointers):C++11引入了三种智能指针:unique_ptr、shared_ptr和weak_ptr,可以更好地管理动态内存,避免内存泄漏和悬空指针,例如:
std::unique_ptr<int> p(new int(42)); std::shared_ptr<int> q = std::make_shared<int>(42); std::weak_ptr<int> r = q;
空指针常量(nullptr):C++11引入了nullptr关键字,用于表示空指针,避免了NULL宏带来的一些问题,例如:
void f(int* p) {} f(nullptr); // 可以显式地传递空指针
右值引用与移动构造函数:右值引用可以方便地实现移动构造函数和移动赋值运算符,用于高效地处理临时对象和避免复制开销,例如:
class MyVector { public: MyVector(MyVector&& other) noexcept { // 移动构造函数 } MyVector& operator=(MyVector&& other) noexcept { // 移动赋值运算符 return *this; } };
初始化列表:可以方便地初始化数组和容器,例如:
std::vector<int> v = {1, 2, 3, 4, 5}; std::map<std::string, int> m = {{"one", 1}, {"two", 2}, {"three", 3}};
类型别名(type alias):可以使用using关键字定义类型别名,例如:
using IntVec = std::vector<int>; IntVec v = {1, 2, 3, 4, 5};
模板别名(template alias):可以使用using关键字定义模板别名,例如:
template <typename T> using Vec = std::vector<T>; Vec<int> v = {1, 2, 3, 4, 5};
constexpr函数和变量:可以在编译期计算出值,例如:
constexpr int fib(int n) { return (n <= 1) ? 1 : fib(n-1) + fib(n-2); } constexpr int x = fib(10); // 编译期计算出x的值为89
变长参数模板(variadic templates):可以接受任意数量和类型的参数,例如:
template <typename... Args> void print(Args... args) { std::cout << sizeof...(args) << std::endl; // 打印参数个数 } print(1, 2, 3); // 打印3 print("hello", 3.14); // 打印2
C++14
泛型lambda表达式:可以使用auto关键字在lambda表达式中推断参数类型,例如:
auto sum = [](auto x, auto y) { return x + y; }; std::cout << sum(1, 2) << std::endl; // 输出3 std::cout << sum(1.5, 2.5) << std::endl; // 输出4.0
return type deduction for normal functions(函数返回类型推断):可以使用auto关键字让编译器自动推断函数的返回类型,例如:
auto add(int x, int y) { return x + y; // 返回类型会自动推断为int }
模板变量(template variable):可以使用关键字template定义模板变量,例如:
template <typename T> constexpr T pi = T(3.1415926535897932385); std::cout << pi<double> << std::endl; // 输出3.14159...
静态断言(static_assert)的增强:可以在静态断言中加入一个字符串提示,例如:
static_assert(sizeof(int) == 4, "int必须是4字节"); // 如果sizeof(int)不等于4,会输出提示信息
字符串字面量的增强:可以使用单引号(')包围字符,例如:
constexpr char operator""_c(char c) { return c; } // 将字符转化为字符 std::cout << 'a'_c << std::endl; // 输出字符'a'
按值捕获的增强:可以使用关键字init来对按值捕获的变量进行初始化,例如:
int x = 1, y = 2; auto f = [x, y = x + 1] { return x + y; }; std::cout << f() << std::endl; // 输出4
变量模板(variable template):可以使用关键字template定义变量模板,例如:
template <typename T> constexpr T pi = T(3.1415926535897932385); std::cout << pi<double> << std::endl; // 输出3.14159...
内存模型的增强:增加了对内存模型的规定,例如:
std::atomic<int> x = 0; // 原子变量 #pragma omp parallel for for (int i = 0; i < 1000; ++i) { x.fetch_add(1); // 线程安全的对x进行加一操作 } std::cout << x << std::endl; // 输出1000
C++17
结构化绑定(Structured Binding):可以使用auto关键字对一个结构体或元组进行结构化绑定,例如:
std::pair<int, int> p = {1, 2}; auto [x, y] = p; // 结构化绑定 std::cout << x << " " << y << std::endl; // 输出1 2
if语句和switch语句的初始化:可以在if语句和switch语句的判断条件中进行变量初始化,例如:
if (int x = get_value(); x > 0) { // 在if语句中初始化变量x std::cout << "x is positive" << std::endl; }
类模板的参数推断(Class Template Argument Deduction,CTAD):可以让编译器自动推断类模板的模板参数,例如:
std::pair p{1, 2}; // 编译器可以自动推断出std::pair<int, int>
constexpr if:可以在编译期进行条件判断,根据判断结果选择不同的代码路径,例如:
template <typename T> void foo(T t) { if constexpr (std::is_pointer_v<T>) { // 如果T是指针类型 std::cout << "t is a pointer" << std::endl; } else { // 如果T不是指针类型 std::cout << "t is not a pointer" << std::endl; } }
折叠表达式(Fold Expression):可以使用折叠表达式来简化代码,例如:
template <typename... Args> auto sum(Args... args) { return (args + ...); // 对args进行折叠求和 } std::cout << sum(1, 2, 3, 4) << std::endl; // 输出10
内联变量(Inline Variable):可以使用inline关键字来定义内联变量,例如:
inline int x = 1; // 定义一个内联变量x,初始值为1
嵌套命名空间(Nested Namespace):可以在命名空间中嵌套命名空间,例如:
namespace A { namespace B { void foo() { std::cout << "hello, world!" << std::endl; } } } A::B::foo(); // 调用函数foo
C++20
概念(Concepts):概念是一种新的语言结构,可以用来描述模板参数的要求,例如:
template <typename T> concept Integral = std::is_integral_v<T>; template <typename T> void foo(T t) requires Integral<T> { // 使用概念描述模板参数要求 std::cout << t << std::endl; } foo(1); // 调用foo函数
三方合并运算符(Three-way Comparison Operator):可以使用<=>运算符对两个对象进行三方比较,例如:
struct Point { int x, y; auto operator<=>(const Point& other) const { return std::tie(x, y) <=> std::tie(other.x, other.y); } }; bool operator==(const Point& lhs, const Point& rhs) { return lhs.x == rhs.x && lhs.y == rhs.y; } std::set<Point> s{{1, 2}, {2, 1}, {1, 1}, {2, 2}}; for (const auto& p : s) { std::cout << p.x << ", " << p.y << std::endl; }
输出结果为:
1, 1
1, 2
2, 1
2, 2
初始化的捕获列表(Init-Capture):可以在lambda表达式的捕获列表中进行初始化,例如:
int x = 1; auto lambda = [value = x * 2]() { // 在捕获列表中初始化变量value std::cout << value << std::endl; }; lambda(); // 调用lambda表达式
consteval函数:可以在编译期计算表达式的值,例如:
consteval int get_value() { return 42; } // 定义一个在编译期计算的函数 std::array<int, get_value()> arr; // 在编译期创建一个大小为42的数组
模块(Modules):可以使用模块来管理和组织代码,替代传统的头文件包含方式,例如:
// 定义一个模块 module my_module; export void foo() { std::cout << "hello, world!" << std::endl; } // 使用模块 import my_module; int main() { foo(); // 调用函数foo return 0; }