C++11 新特性：完整指南及示例

C++11 标准带来了许多重大改进，这些新特性显著提升了 C++ 的效率、安全性以及易用性。本文将深入探讨 C++11 中引入了的 20 个关键特性，并提供相应的示例代码。

1. 自动类型推导 (auto 关键字)

auto 关键字可以根据变量的初始值自动推断其类型，简化代码编写。

#include <iostream>

int main() {
  auto x = 10; // 推断类型为 int
  auto y = 3.14; // 推断类型为 double
  std::cout << x << ' ' << y << std::endl;
  return 0;
}

2. lambda 表达式

lambda 表达式允许在代码中直接定义匿名函数，方便进行函数式编程。

#include <iostream>
#include <algorithm>
#include <vector>

int main() {
  std::vector<int> numbers = {1, 2, 3, 4, 5};
  std::for_each(numbers.begin(), numbers.end(), [](int& n) { n *= 2; });
  for (int n : numbers) {
    std::cout << n << ' ';
  }
  return 0;
}

3. 右值引用 (rvalue reference)

&& 符号表示右值引用，允许对临时对象进行更有效的操作。

#include <iostream>

class MyClass {
public:
  MyClass(const MyClass& other) {
    std::cout << "Copy constructor called" << std::endl;
  }
  MyClass(MyClass&& other) {
    std::cout << "Move constructor called" << std::endl;
  }
};

int main() {
  MyClass obj1;
  MyClass obj2(std::move(obj1));
  return 0;
}

4. 移动语义 (move semantics)

移动语义允许将对象的数据快速转移到另一个对象，避免不必要的复制操作。

#include <iostream>
#include <vector>

class MyClass {
public:
  MyClass(const MyClass& other) {
    std::cout << "Copy constructor called" << std::endl;
  }
  MyClass(MyClass&& other) {
    std::cout << "Move constructor called" << std::endl;
  }
};

int main() {
  std::vector<MyClass> vec;
  vec.push_back(MyClass()); // Move constructor is called
  return 0;
}

5. 统一初始化 (uniform initialization)

使用 {} 初始化对象，使得初始化方式更加统一。

#include <iostream>

struct MyStruct {
  int x;
  double y;
};

int main() {
  MyStruct s = {10, 3.14}; // 统一初始化
  std::cout << s.x << ' ' << s.y << std::endl;
  return 0;
}

6. 空指针常量 (nullptr)

nullptr 用于表示空指针，避免与 0 混淆，提高代码可读性。

#include <iostream>

int main() {
  int* ptr = nullptr; // 指向空地址
  if (ptr == nullptr) {
    std::cout << "ptr is null" << std::endl;
  }
  return 0;
}

7. 委托构造函数 (delegating constructors)

委托构造函数可以调用同一类的其他构造函数，简化构造函数的定义。

#include <iostream>

class MyClass {
public:
  MyClass(int x) : MyClass(x, 0) { }
  MyClass(int x, int y) : m_x(x), m_y(y) { }
private:
  int m_x, m_y;
};

int main() {
  MyClass obj1(10); // 委托构造函数调用 MyClass(10, 0)
  return 0;
}

8. 显式虚函数重载 (override 和 final 关键字)

override 和 final 关键字用于明确标记虚函数的重载和禁止子类重写。

#include <iostream>

class Base {
public:
  virtual void foo() = 0;
};

class Derived : public Base {
public:
  void foo() override { std::cout << "Derived::foo()" << std::endl; }
};

int main() {
  Derived obj;
  obj.foo();
  return 0;
}

9. 特殊成员函数默认生成 (default 关键字)

default 关键字用于显式地声明特殊成员函数的默认生成行为。

#include <iostream>

class MyClass {
public:
  MyClass() = default; // 默认构造函数
};

int main() {
  MyClass obj; // 调用默认构造函数
  return 0;
}

10. 静态断言 (static_assert 关键字)

static_assert 可以在编译时进行断言，确保代码的正确性。

#include <iostream>

int main() {
  static_assert(sizeof(int) == 4, "int size is not 4 bytes"); // 编译时断言
  return 0;
}

11. 变长参数模板 (variadic templates)

变长参数模板可以定义接受任意数量参数的函数和类模板。

#include <iostream>

template<typename... Args>
void print(Args... args) {
  ((std::cout << args << ' '), ...);
  std::cout << std::endl;
}

int main() {
  print(1, 2.3, "hello");
  return 0;
}

12. 线程支持 (thread 库)

C++11 提供了 thread 库，方便创建和管理线程。

#include <iostream>
#include <thread>

void print_thread(const std::string& message) {
  std::cout << message << std::endl;
}

int main() {
  std::thread t(print_thread, "Hello from thread!");
  t.join(); // 等待线程执行完毕
  return 0;
}

13. 原子操作 (atomic 库)

atomic 库提供原子操作，确保多线程环境下的数据一致性。

#include <iostream>
#include <atomic>
#include <thread>

std::atomic<int> counter(0);

void increment_counter() {
  for (int i = 0; i < 1000000; ++i) {
    counter++;
  }
}

int main() {
  std::thread t1(increment_counter);
  std::thread t2(increment_counter);
  t1.join();
  t2.join();
  std::cout << "Counter value: " << counter << std::endl;
  return 0;
}

14. 右值引用绑定 (std::bind 函数)

std::bind 函数可以将函数参数绑定到特定值，方便进行函数回调。

#include <iostream>
#include <functional>

void print_value(int x) {
  std::cout << x << std::endl;
}

int main() {
  auto bound_func = std::bind(print_value, 10);
  bound_func(); // 调用绑定后的函数
  return 0;
}

15. 基于范围的 for 循环 (range-based for loop)

基于范围的 for 循环简化了遍历容器的操作。

#include <iostream>
#include <vector>

int main() {
  std::vector<int> numbers = {1, 2, 3, 4, 5};
  for (int n : numbers) {
    std::cout << n << ' ';
  }
  return 0;
}

16. 智能指针 (smart pointers)

智能指针自动管理内存，避免内存泄漏。

#include <iostream>
#include <memory>

class MyClass {
public:
  MyClass() {
    std::cout << "Constructor called" << std::endl;
  }
  ~MyClass() {
    std::cout << "Destructor called" << std::endl;
  }
};

int main() {
  std::unique_ptr<MyClass> ptr(new MyClass());
  return 0;
}

17. std::chrono 时间库

std::chrono 库提供了精确的时间测量和操作功能。

#include <iostream>
#include <chrono>

int main() {
  auto start = std::chrono::high_resolution_clock::now();
  // 代码执行部分
  auto end = std::chrono::high_resolution_clock::now();
  auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
  std::cout << "Duration: " << duration.count() << " milliseconds" << std::endl;
  return 0;
}

18. constexpr 函数

constexpr 函数可以在编译时进行求值，提高代码效率。

#include <iostream>

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

int main() {
  int result = square(5); // 编译时计算
  std::cout << result << std::endl;
  return 0;
}

19. Unicode 字符串字面量

C++11 支持 Unicode 字符串字面量，方便处理多语言文本。

#include <iostream>

int main() {
  std::string str = u"你好，世界！"; // Unicode 字符串字面量
  std::cout << str << std::endl;
  return 0;
}

20. 新的容器和算法

C++11 引入了新的容器和算法，例如 unordered_map, unordered_set, array, forward_list 等，进一步丰富了 C++ 标准库。

总结

C++11 是 C++ 语言的一次重大更新，引入了许多关键特性，提升了 C++ 的效率、安全性以及易用性。本文仅列举了 C++11 中的一部分新特性，更详细的内容请参考 C++11 标准文档或相关书籍。