C++11中的新特性有哪些

简要回答

C++11 引入了大量新特性以提升代码的 效率、可读性、安全性和并发性，主要包括：

自动类型推导：auto

范围 for 循环：for (auto x : container)

右值引用和移动语义：T&&

智能指针：std::unique_ptr、std::shared_ptr

多线程库：std::thread、std::mutex

Lambda 表达式：[]{} 语法

constexpr 编译期常量

初始化列表 {} 语法

强类型枚举 enum class

新的标准容器（如 std::unordered_map）

模板改进（变参模板等）

安全性 nullptr、static_assert、delegating constructor 等

详细回答

1. 类型推导：auto 和 decltype

用 auto 让编译器自动推导变量类型。

用 decltype 获取表达式的类型。

auto x = 42;              // int
decltype(x + 3.14) y = 0; // double

2. Lambda 表达式（匿名函数）

简洁定义函数逻辑，常用于算法和回调。

auto add = [](int a, int b) { return a + b; };
std::cout << add(3, 4); // 输出 7

3. 右值引用 & 移动语义（T&&）

提高性能，避免不必要的拷贝。

std::vector<int> a = std::move(b);
// b的内容被移动到a

4. 智能指针（RAII 管理资源）

std::unique_ptr<int> ptr(new int(5));
std::shared_ptr<int> sp = std::make_shared<int>(10);

5. 多线程库（并发支持）

std::thread t([](){ std::cout << "Hello Thread"; });
t.join();

6. 新的循环方式（范围for）

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

7. 初始化列表 & 统一初始化语法

std::vector<int> v{1, 2, 3}; // 初始化列表
int x{5};                    // 强制初始化

8. constexpr 常量表达式

constexpr int square(int x) { return x * x; }

9. 强类型枚举

enum class Color { Red, Green, Blue };

10.其他重要特性

nullptr 替代 NULL

static_assert 编译期断言

委托构造函数

默认和删除函数（=default, =delete）

变参模板

• 适用场景

特性	使用场景
auto	简化模板类型变量声明
Lambda	STL算法（如 std::sort）
右值引用	大对象移动，提高性能
智能指针	避免内存泄露
多线程	并发计算或I/O任务
constexpr	编译期常量，如数组大小
enum class	避免命名冲突，类型安全

代码示例

#include <iostream>
#include <vector>
#include <memory>
#include <thread>
#include <cassert>
#include <unordered_map>

// 1. 类型推导: auto 和 decltype
void type_deduction() {
    auto x = 42;              // int
    decltype(x + 3.14) y = 0; // double
    std::cout << "Type deduction - y type: " << typeid(y).name() << ", value: " << y << std::endl;
}

// 2. Lambda 表达式
void lambda_demo() {
    auto add = [](int a, int b) { return a + b; };
    auto square = [](int x) -> int { return x * x; };

    std::cout << "Lambda - add(3,4): " << add(3, 4)
              << ", square(5): " << square(5) << std::endl;
}

// 3. 右值引用 & 移动语义
void move_semantics() {
    std::vector<int> a{1, 2, 3};
    std::vector<int> b = std::move(a); // 移动构造

    std::cout << "Move semantics - b size: " << b.size()
              << ", a size after move: " << a.size() << std::endl;
}

// 4. 智能指针
void smart_pointers() {
    std::unique_ptr<int> uptr(new int(5));
    std::shared_ptr<int> sptr1 = std::make_shared<int>(10);
    auto sptr2 = sptr1; // 共享所有权

    std::cout << "Smart pointers - *uptr: " << *uptr
              << ", *sptr1: " << *sptr1
              << ", use_count: " << sptr1.use_count() << std::endl;
}

// 5. 多线程
void threading_demo() {
    auto worker = []() {
        std::cout << "Thread ID: " << std::this_thread::get_id() << " working..." << std::endl;
    };

    std::thread t1(worker);
    std::thread t2(worker);

    t1.join();
    t2.join();
}

// 6. 范围for循环
void range_based_for() {
    std::vector<int> vec{1, 2, 3, 4, 5};
    std::cout << "Range-based for: ";
    for (auto& v : vec) {
        v *= 2; // 修改元素
        std::cout << v << " ";
    }
    std::cout << std::endl;
}

// 7. 初始化列表 & 统一初始化
void uniform_initialization() {
    std::vector<int> v{1, 2, 3}; // 初始化列表
    int x{5};                    // 直接初始化
    int y{};                     // 值初始化 (0)

    std::cout << "Uniform init - x: " << x << ", y: " << y << std::endl;
}

// 8. constexpr
constexpr int factorial(int n) {
    return n <= 1 ? 1 : n * factorial(n - 1);
}

// 9. 强类型枚举
enum class Color { Red, Green, Blue };

// 10. 其他重要特性
class MyClass {
public:
    MyClass() = default; // 默认构造函数
    MyClass(const MyClass&) = delete; // 禁用拷贝

    void foo() {
        static_assert(sizeof(int) >= 4, "int must be at least 4 bytes");
    }
};

void variadic_template() {
    auto print = [](auto&&... args) {
        (std::cout << ... << args) << std::endl; // C++17折叠表达式
    };
    print(1, " hello ", 3.14, '!');
}

int main() {
    type_deduction();
    lambda_demo();
    move_semantics();
    smart_pointers();

    std::cout << "\nStarting threads..." << std::endl;
    threading_demo();

    range_based_for();
    uniform_initialization();

    std::cout << "Constexpr factorial(5): " << factorial(5) << std::endl;

    Color c = Color::Red;
    std::cout << "Enum class value: " << static_cast<int>(c) << std::endl;

    MyClass obj;
    // MyClass obj2 = obj; // 错误: 拷贝构造函数被删除

    variadic_template();

    // nullptr 示例
    int* ptr = nullptr;
    assert(ptr == nullptr);

    return 0;
}

知识拓展

• 知识图解

• 面试官可能追问

Q1：auto 和 decltype 有什么区别？

auto 是类型推导变量类型，decltype 是获取表达式的确切类型。

Q2：为什么需要右值引用？

为了实现移动语义，减少资源的拷贝，提高性能。

Q3：Lambda表达式可以捕获哪些内容？

可以捕获值、引用、this指针，还支持默认捕获 [=]、[&] 等。

Q4：智能指针和原始指针的区别？

智能指针自动释放资源，防止内存泄露，原始指针需要手动管理。