C++11 - 现代 C++ 的开端
C++11：现代 C++ 的开端
C++11 是 C++ 历史上最重要的标准之一，它彻底改变了 C++ 的编程方式，被称为"现代 C++"的起点。
自动类型推导（auto）
auto x = 42; // int
auto y = 3.14; // double
auto z = std::vector<int>{1, 2, 3}; // std::vector<int>
// 范围 for 循环
std::vector<int> vec = {1, 2, 3, 4, 5};
for (auto& elem : vec) {
elem *= 2;
}Lambda 表达式
// 基本语法
auto lambda = [](int x, int y) { return x + y; };
int result = lambda(3, 4); // 7
// 捕获变量
int a = 10;
auto captureByValue = [a](int x) { return x + a; };
auto captureByRef = [&a](int x) { a += x; };
// 捕获所有
auto captureAll = [=](int x) { return x + a; };
auto captureAllRef = [&](int x) { a += x; };智能指针
#include <memory>
// unique_ptr：独占所有权
std::unique_ptr<int> ptr1 = std::make_unique<int>(42);
// std::unique_ptr<int> ptr2 = ptr1; // 编译错误
// shared_ptr：共享所有权
std::shared_ptr<int> ptr3 = std::make_shared<int>(42);
std::shared_ptr<int> ptr4 = ptr3; // 引用计数 +1
// weak_ptr：弱引用，不增加引用计数
std::weak_ptr<int> ptr5 = ptr3;右值引用与移动语义
// 移动构造函数
class MyClass {
public:
MyClass(MyClass&& other) noexcept
: data_(std::move(other.data_)) {
other.data_ = nullptr;
}
// 移动赋值运算符
MyClass& operator=(MyClass&& other) noexcept {
if (this != &other) {
delete data_;
data_ = std::move(other.data_);
other.data_ = nullptr;
}
return *this;
}
private:
int* data_;
};
// std::move
std::string str1 = "Hello";
std::string str2 = std::move(str1); // str1 现在为空std::function 和 std::bind
#include <functional>
int add(int a, int b) { return a + b; }
// std::function：可调用对象的包装器
std::function<int(int, int)> func = add;
int result = func(3, 4); // 7
// std::bind：绑定参数
auto add5 = std::bind(add, std::placeholders::_1, 5);
int result2 = add5(10); // 15
// 绑定成员函数
struct Calculator {
int multiply(int a, int b) { return a * b; }
};
Calculator calc;
auto multiplyBy2 = std::bind(&Calculator::multiply, &calc, std::placeholders::_1, 2);
int result3 = multiplyBy2(5); // 10std::unordered_map 和 std::unordered_set
#include <unordered_map>
#include <unordered_set>
// 哈希表
std::unordered_map<std::string, int> scores;
scores["Alice"] = 90;
scores["Bob"] = 85;
// 查找
if (scores.find("Alice") != scores.end()) {
std::cout << "Alice's score: " << scores["Alice"] << "\n";
}
// unordered_set
std::unordered_set<int> uniqueValues = {1, 2, 2, 3, 3, 3};
// uniqueValues = {1, 2, 3}std::tuple
#include <tuple>
// 创建 tuple
std::tuple<int, double, std::string> t{42, 3.14, "hello"};
// 获取元素
std::get<0>(t); // 42
std::get<1>(t); // 3.14
std::get<2>(t); // "hello"
// 结构化绑定（C++17）
auto [id, value, name] = t;
// 连接 tuple
auto combined = std::tuple_cat(t, std::make_pair(true, 'a'));std::chrono
#include <chrono>
// 时间点
auto now = std::chrono::system_clock::now();
// duration
using namespace std::chrono_literals;
auto duration = 100ms; // 100 毫秒
auto seconds = 2s; // 2 秒
auto minutes = 5min; // 5 分钟
// 睡眠
std::this_thread::sleep_for(500ms);
// 计时
auto start = std::chrono::high_resolution_clock::now();
// ... 执行操作
auto end = std::chrono::high_resolution_clock::now();
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);std::array
#include <array>
// 固定大小数组
std::array<int, 5> arr = {1, 2, 3, 4, 5};
// 访问元素
arr[0] = 10;
arr.at(1) = 20;
// 迭代
for (const auto& elem : arr) {
std::cout << elem << " ";
}
// 大小
std::cout << "Size: " << arr.size() << "\n"; // 5
// 前后元素
std::cout << "Front: " << arr.front() << "\n";
std::cout << "Back: " << arr.back() << "\n";
// 填充
arr.fill(0);std::forward_list
#include <forward_list>
// 单向链表
std::forward_list<int> list = {1, 2, 3, 4, 5};
// 在前面插入
list.push_front(0);
// 在指定位置后插入
auto it = list.begin();
list.insert_after(it, 100);
// 删除元素
list.pop_front();
list.erase_after(it);
// 遍历
for (const auto& elem : list) {
std::cout << elem << " ";
}
// 检查是否为空
if (list.empty()) {
std::cout << "List is empty\n";
}std::random
#include <random>
// 随机数引擎
std::random_device rd; // 硬件随机数生成器
std::mt19937 gen(rd()); // Mersenne Twister 引擎
// 均匀分布
std::uniform_int_distribution<> dis(1, 100);
int randomInt = dis(gen); // 1-100 之间的随机整数
// 浮点数分布
std::uniform_real_distribution<> disReal(0.0, 1.0);
double randomDouble = disReal(gen);
// 正态分布
std::normal_distribution<> normal(5.0, 2.0);
double normalValue = normal(gen);
// 伯努利分布
std::bernoulli_distribution bernoulli(0.5);
bool coinFlip = bernoulli(gen);std::regex
#include <regex>
// 正则表达式匹配
std::string text = "Hello, World! 123";
std::regex pattern(R"(\d+)"); // 匹配数字
std::smatch matches;
if (std::regex_search(text, matches, pattern)) {
std::cout << "Found: " << matches[0] << "\n"; // 123
}
// 正则表达式替换
std::string result = std::regex_replace(text, std::regex(R"(\d+)"), "NUM");
std::cout << result << "\n"; // Hello, World! NUM
// 正则表达式迭代
std::regex word_pattern(R"(\w+)");
std::sregex_iterator it(text.begin(), text.end(), word_pattern);
std::sregex_iterator end;
for (; it != end; ++it) {
std::cout << it->str() << "\n";
}范围 for 循环
std::vector<int> vec = {1, 2, 3, 4, 5};
// 只读
for (const auto& elem : vec) {
std::cout << elem << " ";
}
// 修改
for (auto& elem : vec) {
elem *= 2;
}
// 数组
int arr[] = {1, 2, 3};
for (auto& x : arr) {
x *= 2;
}初始化列表
// 统一初始化
int x{42};
std::vector<int> vec{1, 2, 3, 4, 5};
std::map<std::string, int> m{
{"apple", 1},
{"banana", 2}
};
// 防止窄化转换
// int y{3.14}; // 编译错误nullptr
void func(int* ptr) {}
void func(int x) {}
func(nullptr); // 调用 func(int*)
// func(NULL); // 可能有歧义
int* ptr = nullptr;constexpr
constexpr int factorial(int n) {
return n <= 1 ? 1 : n * factorial(n - 1);
}
constexpr int result = factorial(5); // 编译期计算类型别名
using String = std::string;
using IntVector = std::vector<int>;
// 模板别名
template<typename T>
using Vec = std::vector<T>;
Vec<int> v; // std::vector<int>委托构造函数
class MyClass {
public:
MyClass(int x, int y) : x_(x), y_(y) {}
// 委托给上面的构造函数
MyClass(int x) : MyClass(x, 0) {}
MyClass() : MyClass(0, 0) {}
private:
int x_, y_;
};override 和 final
class Base {
public:
virtual void func() {}
virtual void finalFunc() final {}
};
class Derived : public Base {
public:
void func() override {} // 明确表示重写
// void finalFunc() override {} // 编译错误，final 函数不能重写
};
class FinalClass final : public Base {
// 不能被继承
};enum class
enum class Color { Red, Green, Blue };
enum class Animal { Dog, Cat };
Color c = Color::Red;
// Color c2 = Red; // 编译错误，需要作用域
// if (c == Animal::Dog) {} // 编译错误，不同枚举类型不能比较
// 显式转换
int value = static_cast<int>(Color::Red); // 0静态断言
static_assert(sizeof(int) == 4, "int must be 4 bytes");
template<typename T>
void checkSize() {
static_assert(sizeof(T) >= 4, "Type must be at least 4 bytes");
}变参模板
// 打印任意数量的参数
template<typename... Args>
void print(Args... args) {
((std::cout << args << " "), ...); // 折叠表达式（C++17）
std::cout << "\n";
}
// 递归展开
template<typename T>
T sum(T first) {
return first;
}
template<typename T, typename... Args>
T sum(T first, Args... rest) {
return first + sum(rest...);
}
print(1, 2, 3, "hello"); // 1 2 3 hello
int total = sum(1, 2, 3, 4, 5); // 15常用特性总结
最常用的 C++11 特性：
auto类型推导- Lambda 表达式
- 智能指针（
unique_ptr,shared_ptr） - 范围 for 循环
nullptroverride关键字enum class
Related Articles
2025-08-08
cpp concept
C++20引入的concept是C++模板编程的一项重大特性，用于定义对模板参数的约束，提高模板代码的可读性、错误诊断和维护性。以下是对C++20 concept的详细讲解，包括其背景、语法、用途、设计理念以及实际应用。 1. 背景和动机 在C++20之前，模板编程虽然强大，但存在以下问题： 缺乏明确的约束：模板参数的类型要求通常通过文档或代码中的隐式假设来表达。如果模板的使用不符合要求，编译器会在实例化时产生难以理解的错误信息。 错误信息复杂：模板实例化失败时，编译器通常会输出冗长且晦涩的错误信息，难以快速定位问题。 代码可读性差：开发者需要通过模板元编程或SFINAE（Substitution Failure Is Not An Error）等技术间接约束模板参数，这增加了代码复杂度和学习成本。 concept的引入解决了这些问题，它允许开发者显式地定义模板参数的语义要求，使代码更清晰、错误信息更友好，同时提高编译器的诊断能力。 2. 什么是Concept？ concept是一个命名的约束集合，用于描述模板参数必须满足的条件。它可以看作是对类型或值的语义要求的一种形式化表...
2023-01-16
Cpp Callable Objects
在 C++ 中，Callable Object（可调用对象） 指的是任何可以像函数一样被调用的事物。简单来说，就是任何可以使用 () 运算符（Function Call Operator）的对象。 在现代 C++（C++11 及以后）中，可调用对象的概念非常重要，因为它是 STL 算法、线程（std::thread）以及回调机制的核心。 C++ 中的可调用对象主要分为以下 5 类。 1. 普通函数与函数指针 (Function Pointers) 这是最基础的形式，继承自 C 语言。 特点： 没有状态（Stateless），行为固定。 适用场景： 简单的回调，也就是所谓的 C 风格 API。 #include <print> void hello() { std::println("Hello from Function Pointer!"); } int main() { // 定义函数指针 void (*funcPtr)() = &hello; // & 是可选的 // 调...
2025-08-17
C++ optional & expected
在 C++ 中，std::optional 和 std::expected 是两个用于处理可能不存在的值或可能失败的操作的现代工具，它们在 C++17 和 C++23 中分别引入，提供了更安全和表达力更强的错误处理机制。以下是对它们的详细说明，包括定义、用途、特性、用法、差异以及实际代码示例。 1. std::optional 定义 std::optional 是 C++17 引入的标准库组件，定义在 <optional> 头文件中。它表示一个可能存在或不存在的值，类似于“可能有值，也可能为空”的概念。std::optional<T> 可以包含类型为 T 的值，或者为空（std::nullopt）。 用途 用于表示函数可能返回一个值，也可能不返回任何值。 替代传统的“特殊值”（如 nullptr、-1 等）来表示无值的情况，增强代码的可读性和类型安全性。 常用于需要明确区分“无值”和“有值”的场景，如查找操作、初始化状态等。 关键特性 类型安全：std::optional 明确表示值是否有效，避免了隐式的“魔法值”问题。 值语义：std::optio...
2022-12-03
C++ namespace
C++命名空间是语言的核心特性之一，用于解决名字冲突问题，尤其在大项目或使用多个库时。基于最新C++23标准，命名空间用法稳定，但结合模块（modules）使用更高效。下面直击要害，逐一拆解，包括[inline namespace]、匿名命名空间和命名空间别名。 参考：[cppreference.com] 1. 基本用法：声明与定义 命名空间通过namespace关键字声明，内容可以分散在多个文件中定义（如同函数定义）。 namespace MyLib { int add(int a, int b) { return a + b; } class Widget { public: void use(); }; } 使用方式： 限定名：MyLib::add(1, 2); 最安全，避免污染全局。 using声明：using MyLib::add; 只引入add，作用域内可用add(1,2)。 using指令：using namespace MyLib; 引入整个空...
2023-06-27
Useful Boost Libraries
基于 boost 1.82… timer 计时器 过去老的 boost/timer.hpp 已经废弃了，目前推荐使用的是 boost/timer/timer.hpp, 主要包括下面了2个类 class detail boost::timer::cpu_timer 计时器 boost::timer::auto_cpu_timer 计时器，基于cpu_timer实现，在析构的时候输出耗时 struct cpu_times { nanosecond_type wall; // 挂钟时间 nanosecond_type user; // 用户时间 nanosecond_type system; // 系统时间 void clear() {wall = user = system = 0LL; } }; 默认的输出格式为下： “%w s wall, %u s user + %s s system = %t s CPU (%p%)\n” format meaning ...
2026-01-18
C++17 - 重大更新
C++17：重大更新 C++17 带来了许多重要的新特性，显著提升了 C++ 的表达力和安全性。 结构化绑定 // 解构 pair std::pair<int, std::string> p{42, "hello"}; auto [id, name] = p; // 解构 tuple std::tuple<int, double, std::string> t{1, 3.14, "world"}; auto [x, y, z] = t; // 解构数组 int arr[3] = {1, 2, 3}; auto [a, b, c] = arr; // 解构结构体 struct Point { int x; int y; }; Point pt{10, 20}; auto [px, py] = pt; // 在范围 for 循环中使用 std::map<std::string, int> m{{"a", 1}, &...
CPP
