C++_11特性

Hush_NUIST

于 2024-08-26 10:14:10 发布

阅读量596

点赞数 27

文章标签： c++ 开发语言笔记 c#

本文链接：https://blog.csdn.net/qq_39969848/article/details/141555096

版权

在C++的演变过程中，C++11 是一个非常重要的标准，它引入了许多新的特性和改进，极大地增强了C++的功能和易用性。在面试中提到C++11特性，通常指的是面试者对C++11标准中新增功能的理解和使用。这些特性主要包括以下几个方面：

1. 自动类型推导（`auto` 和 `decltype`）

auto: 编译器根据变量的初始化表达式自动推导类型。

auto x = 10;  // x 被推导为 int 类型
auto y = 3.14;  // y 被推导为 double 类型

decltype: 用于推导表达式的类型，通常用于函数返回类型或复杂的类型推导。
```
int a = 10;
decltype(a) b = 20;  // b 的类型是 int
```

2. 范围for循环（Range-based for Loop）

允许更简洁地遍历容器中的元素。

std::vector<int> vec = {1, 2, 3, 4, 5};
for (auto &v : vec) {
    std::cout << v << " ";
}

3. 智能指针（`std::shared_ptr` 和 `std::unique_ptr`）

std::shared_ptr: 用于多个所有者共享同一个对象的所有权，自动管理内存释放。

std::unique_ptr: 独占所有权的智能指针，不允许复制，但可以转移所有权。

std::shared_ptr<int> sp = std::make_shared<int>(10);
std::unique_ptr<int> up = std::make_unique<int>(20);

4. 右值引用和移动语义（Rvalue References and Move Semantics）

右值和左值

左值（lvalue）：通常指内存中的一个位置，可以对其取地址，例如变量。左值可以出现在赋值语句的左侧。
```
int a = 10; // a 是左值
```
右值（rvalue）：不存储在特定的内存地址中，通常是临时的值，如常量、表达式的结果。右值只能出现在赋值语句的右侧。
```
int b = a + 5; // a + 5 是右值
```

右值引用（`T&&`）

C++11 引入了 右值引用，即 T&&，可以引用右值（如临时对象）。右值引用允许你捕获临时对象，并进行“移动”操作，而不是复制操作，这对于提升性能非常有用。

std::string s1 = "Hello";
std::string s2 = std::move(s1);  // s1 的内容被“移动”到 s2，而不是复制

在上面的例子中，std::move 将 s1 转换为右值引用，触发 std::string 的移动构造函数，而不是拷贝构造函数。因此，s2 直接获取了 s1 内部资源，s1 变为空的或者无效的。这种“移动”避免了内存的分配与拷贝，从而提升性能。

移动语义（Move Semantics）

移动语义是指通过右值引用优化资源的传递。对于需要大量资源的对象（如动态内存），移动语义允许我们将资源从一个对象“移动”到另一个对象，而无需进行昂贵的复制操作。

class MyClass {
public:
    MyClass(MyClass&& other) {  // 移动构造函数
        data = other.data;
        other.data = nullptr;  // 将资源转移给当前对象，并将原对象置为空
    }
    // 其他代码...
private:
    int* data;
};

5. Lambda 表达式（Lambda Expressions）

Lambda 表达式是一种匿名函数（没有名字的函数），可以在函数内部定义并使用。它们非常适合需要短小的函数作为参数传递的场合，例如回调函数。

基本语法

auto lambda = [](int x, int y) -> int {
    return x + y;
};
int result = lambda(5, 3);  // result = 8

[]：捕获列表，用于捕获上下文中的变量。
(int x, int y)：参数列表，定义传递给Lambda表达式的参数。
-> int：可选的返回类型，如果省略，编译器会自动推导。
{ return x + y; }：函数体，执行逻辑。

捕获变量

Lambda 表达式可以捕获函数外部的变量，有三种主要方式：

值捕获（copy）：将变量复制到Lambda内部，Lambda中的值与外部变量独立。
```
int a = 5;
auto lambda = [a]() { return a + 10; };
```
引用捕获（reference）：捕获变量的引用，Lambda内部的修改会影响外部变量。
```
int a = 5;
auto lambda = [&a]() { a += 10; };
lambda();  // a 现在是 15
```

隐式捕获：可以捕获所有外部变量。

auto lambda = [=]() { return a + b; }; // 以值捕获所有外部变量
auto lambda = [&]() { a += b; }; // 以引用捕获所有外部变量

6. 线程和并发支持（Thread and Concurrency Support）

C++11 引入了原生的多线程支持，主要通过 <thread> 和 <mutex> 等标准库。

`std::thread`

std::thread 用于创建和管理线程。你可以通过以下方式创建一个新线程：

void printMessage() {
    std::cout << "Hello from thread!" << std::endl;
}

int main() {
    std::thread t(printMessage);  // 创建一个线程，执行 printMessage 函数
    t.join();  // 等待线程结束
    return 0;
}

t.join()：主线程等待子线程 t 执行完毕。如果没有调用 join() 或 detach()，在主线程结束时会抛出异常。

`std::mutex` 和 `std::lock_guard`

在多线程编程中，如果多个线程同时访问同一个共享资源（如全局变量或数据结构），就会产生竞态条件（race condition），可能导致数据不一致。

为了防止这种情况，可以使用 std::mutex 来锁定资源，确保同时只有一个线程可以访问该资源。

std::mutex mtx;
int sharedData = 0;

void increment() {
    std::lock_guard<std::mutex> lock(mtx);  // 自动管理锁的获取与释放
    sharedData++;
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);
    t1.join();
    t2.join();
    std::cout << "Final value: " << sharedData << std::endl;  // 输出 2
    return 0;
}

std::mutex：互斥量，用于锁定共享资源。
std::lock_guard：RAII风格的锁管理器，自动在作用域结束时释放锁。

7. 初始化列表（Initializer Lists）

允许使用统一的方式对容器或对象进行初始化。
```
std::vector<int> vec = {1, 2, 3, 4, 5};
```

8. `constexpr` 关键字

用于定义在编译期就可以求值的常量表达式，从而优化性能。

constexpr int square(int x) { return x * x; }
int arr[square(5)];  // 数组大小在编译期计算

9. `nullptr` 关键字

在 C++11 之前，我们通常使用 NULL 来表示空指针。

然而，在 C++ 中，NULL 的定义实际上是一个整数值 0，而不是一个真正的指针类型。

在函数重载和模板编程中这可能会导致一些问题和歧义。

为了解决这个问题，C++11 引入了一个新的关键字 nullptr，用于表示空指针。

nullptr 是一种特殊类型的字面值，类型为 std::nullptr_t，定义为: typedef decltype(nullptr) nullptr_t，可以隐式转换为任何指针类型。

与 NULL 不同，nullptr 是一个真正的指针类型，因此可以避免一些由于 NULL 是整数类型而引起的问题。

以下是 nullptr 和 NULL 之间区别的一些例子：

#函数重载
#include <iostream>

void foo(int x) {
 std::cout << "foo() called with an int: " << x << std::endl;
}

void foo(char* x) {
 std::cout << "foo() called with a char*: " << x << std::endl;
}

int main() {
 // foo(NULL); // 编译错误：因为 NULL 会被解析为整数 0，导致二义性
 foo(nullptr); // 无歧义：调用 void foo(char* x)
}

10. `enum class`（强类型枚举）

在C++11之前，C++的枚举类型存在一些局限性，其中最主要的问题是传统枚举的命名污染和隐式转换问题。C++11引入了 enum class（也称为强类型枚举），为枚举类型提供了更强的类型安全性和更好的作用域控制。

传统枚举的问题

在C++11之前，枚举的定义如下：

enum Color { Red, Green, Blue };

存在以下问题：

命名污染：枚举成员 Red、Green 和 Blue 直接在其作用域内可见，容易与其他枚举或变量名称发生冲突。

enum Color { Red, Green, Blue };
enum TrafficLight { Red, Yellow, Green };  // Red 和 Green 与 Color 枚举的成员冲突

隐式转换：传统枚举的枚举成员是整型值，可以隐式转换为整数类型。这种转换有时会导致错误和混淆。
```
enum Color { Red, Green, Blue };
Color c = Red;
int n = c;  // 隐式转换为整数
```

`enum class`（强类型枚举）

C++11引入了 enum class，它解决了传统枚举的这些问题：

定义和使用

enum class Color { Red, Green, Blue };

作用域控制：enum class 的枚举成员不再污染全局作用域，必须通过枚举类型名称来访问枚举成员。这种强类型控制避免了命名冲突。
```
Color c = Color::Red;
```
禁止隐式转换：enum class 的枚举类型是强类型的，不能隐式转换为整数或其他枚举类型。这种设计增加了类型安全性，避免了不必要的类型转换错误。

例子：避免命名冲突和隐式转换

#include <iostream>

enum class Color { Red, Green, Blue };
enum class TrafficLight { Red, Yellow, Green };

int main() {
    Color color = Color::Red;
    TrafficLight light = TrafficLight::Red;

    // 不能直接访问 Red 或 Green，必须指定所属的 enum class
    // int n = color; // 错误，不能隐式转换为整数

    if (color == Color::Red) {
        std::cout << "Color is Red" << std::endl;
    }

    if (light == TrafficLight::Red) {
        std::cout << "Traffic light is Red" << std::endl;
    }

    return 0;
}

`enum class` 的优点

作用域控制：枚举成员被限定在 enum class 定义的作用域内，防止命名冲突。
- Color::Red 和 TrafficLight::Red 属于不同的作用域，互不干扰。
强类型安全：枚举类型不再与整数类型混淆，不能隐式转换为其他类型，减少了意外的类型转换错误。
- Color 类型的枚举成员不能隐式转换为整数，这增加了代码的安全性和可读性。
自定义基础类型：可以为 enum class 指定基础类型（默认是 int），这对于需要优化内存使用的场景非常有用。
```
enum class Color : char { Red, Green, Blue };  // 枚举成员占用一个字节
```