本文主要有关 C++11 的一些新特性。

自动类型推导 —— auto 关键字

auto 关键字允许编译器根据初始化表达式自动推导变量的类型，这使得代码更简洁，减少了重复的类型声明。

例如，

Plain Textauto x = 10; // x is an int

范围 for 循环

C++11 引入了更简洁的 for 循环语法，用于遍历容器中的元素。例如，

Plain Textstd::vector<int> vec = {1,2,3,4,5};
for (auto& elem: vec) {
	std::cout << elem << std::endl;
}

智能指针

C++11 引入了 std::unitque_ptr 和 std::shared_ptr 来自动管理动态内存，避免了手动释放内存可能带来的错误。

其中，

• std::unique_ptr: 独占所有权，确保一个指针只能指向一个资源。
• std::shared_ptr: 共享所有权，多个指针可以共享同一个资源。使用引用技术管理管理资源生命周期。

匿名函数

C++11 可以使用 Lambda 表达式来简洁地定义匿名函数。特别适合用于回调和简单的计算。

Plain Textauto add = [](int a, int b) -> int {
	return a + b;
};

std::cout << add(3,4) << std::endl;

移动语义与右值引用

C++11 引入了移动语义和右值引用（rvalue reference），通过 && 符号表示。移动语义允许程序避免不必要的拷贝，以提高性能。

所谓的右值引用指的是可以绑定到临时对象（也就是右值），并通过移动构造函数或移动赋值操作符转移资源。

Plain Textstd::vector<int> vec1 = {1,2,3};
std::vector<int> vec2 = std::move(vec1); 
// vec1 的资源被转移到 vec2，避免了拷贝

nullptr 关键字

C++11 引入了 nullptr 作为空指针的常量值，取代了 NULL， 提供了更强的类型安全性。

using 关键字与类型别名

using 关键字在 C++11 中可以用来创建类型别名，取代了传统的 typedef 语法，并且在模板场景中更加简洁。

Plain Textusing int_ptr = int*;

constexpr 关键字

constexpr 关键字用于定义编译期常量。与 const 不同的是，constexpr 保证了表达式是在编译期求值。

Plain Textconstexpr int square(int x) {
	return x * x;
}

constexpr int result = square(5); 
// 编译时计算 result 的值

变长模板参数

显式默认与删除函数

Plain Textauto x = 10; // x is an int

Plain Textstd::vector<int> vec = {1,2,3,4,5};
for (auto& elem: vec) {
	std::cout << elem << std::endl;
}

Plain Textauto add = [](int a, int b) -> int {
	return a + b;
};

std::cout << add(3,4) << std::endl;

Plain Textstd::vector<int> vec1 = {1,2,3};
std::vector<int> vec2 = std::move(vec1); 
// vec1 的资源被转移到 vec2，避免了拷贝

Plain Textusing int_ptr = int*;

Plain Textconstexpr int square(int x) {
	return x * x;
}

constexpr int result = square(5); 
// 编译时计算 result 的值

Plain Textauto x = 10; // x is an int

Plain Textstd::vector<int> vec = {1,2,3,4,5};
for (auto& elem: vec) {
	std::cout << elem << std::endl;
}

Plain Textauto add = [](int a, int b) -> int {
	return a + b;
};

std::cout << add(3,4) << std::endl;

Plain Textstd::vector<int> vec1 = {1,2,3};
std::vector<int> vec2 = std::move(vec1); 
// vec1 的资源被转移到 vec2，避免了拷贝

Plain Textusing int_ptr = int*;

Plain Textconstexpr int square(int x) {
	return x * x;
}

constexpr int result = square(5); 
// 编译时计算 result 的值

Plain Textauto x = 10; // x is an int

Plain Textstd::vector<int> vec = {1,2,3,4,5};
for (auto& elem: vec) {
	std::cout << elem << std::endl;
}

Plain Textauto add = [](int a, int b) -> int {
	return a + b;
};

std::cout << add(3,4) << std::endl;

Plain Textstd::vector<int> vec1 = {1,2,3};
std::vector<int> vec2 = std::move(vec1); 
// vec1 的资源被转移到 vec2，避免了拷贝

Plain Textusing int_ptr = int*;

Plain Textconstexpr int square(int x) {
	return x * x;
}

constexpr int result = square(5); 
// 编译时计算 result 的值

Plain Textauto x = 10; // x is an int

Plain Textstd::vector<int> vec = {1,2,3,4,5};
for (auto& elem: vec) {
	std::cout << elem << std::endl;
}

Plain Textauto add = [](int a, int b) -> int {
	return a + b;
};

std::cout << add(3,4) << std::endl;

Plain Textstd::vector<int> vec1 = {1,2,3};
std::vector<int> vec2 = std::move(vec1); 
// vec1 的资源被转移到 vec2，避免了拷贝

Plain Textusing int_ptr = int*;

Plain Textconstexpr int square(int x) {
	return x * x;
}

constexpr int result = square(5); 
// 编译时计算 result 的值

Plain Textauto x = 10; // x is an int

Plain Textstd::vector<int> vec = {1,2,3,4,5};
for (auto& elem: vec) {
	std::cout << elem << std::endl;
}

Plain Textauto add = [](int a, int b) -> int {
	return a + b;
};

std::cout << add(3,4) << std::endl;

Plain Textstd::vector<int> vec1 = {1,2,3};
std::vector<int> vec2 = std::move(vec1); 
// vec1 的资源被转移到 vec2，避免了拷贝

Plain Textusing int_ptr = int*;

Plain Textconstexpr int square(int x) {
	return x * x;
}

constexpr int result = square(5); 
// 编译时计算 result 的值

Plain Textauto x = 10; // x is an int

Plain Textstd::vector<int> vec = {1,2,3,4,5};
for (auto& elem: vec) {
	std::cout << elem << std::endl;
}

Plain Textauto add = [](int a, int b) -> int {
	return a + b;
};

std::cout << add(3,4) << std::endl;

Plain Textstd::vector<int> vec1 = {1,2,3};
std::vector<int> vec2 = std::move(vec1); 
// vec1 的资源被转移到 vec2，避免了拷贝

Plain Textusing int_ptr = int*;

Plain Textconstexpr int square(int x) {
	return x * x;
}

constexpr int result = square(5); 
// 编译时计算 result 的值

Plain Textauto x = 10; // x is an int

Plain Textstd::vector<int> vec = {1,2,3,4,5};
for (auto& elem: vec) {
	std::cout << elem << std::endl;
}

Plain Textauto add = [](int a, int b) -> int {
	return a + b;
};

std::cout << add(3,4) << std::endl;

Plain Textstd::vector<int> vec1 = {1,2,3};
std::vector<int> vec2 = std::move(vec1); 
// vec1 的资源被转移到 vec2，避免了拷贝

Plain Textusing int_ptr = int*;

Plain Textconstexpr int square(int x) {
	return x * x;
}

constexpr int result = square(5); 
// 编译时计算 result 的值

Plain Textauto x = 10; // x is an int

Plain Textstd::vector<int> vec = {1,2,3,4,5};
for (auto& elem: vec) {
	std::cout << elem << std::endl;
}

Plain Textauto add = [](int a, int b) -> int {
	return a + b;
};

std::cout << add(3,4) << std::endl;

Plain Textstd::vector<int> vec1 = {1,2,3};
std::vector<int> vec2 = std::move(vec1); 
// vec1 的资源被转移到 vec2，避免了拷贝

Plain Textusing int_ptr = int*;

Plain Textconstexpr int square(int x) {
	return x * x;
}

constexpr int result = square(5); 
// 编译时计算 result 的值

Plain Textauto x = 10; // x is an int

Plain Textstd::vector<int> vec = {1,2,3,4,5};
for (auto& elem: vec) {
	std::cout << elem << std::endl;
}

Plain Textauto add = [](int a, int b) -> int {
	return a + b;
};

std::cout << add(3,4) << std::endl;

Plain Textstd::vector<int> vec1 = {1,2,3};
std::vector<int> vec2 = std::move(vec1); 
// vec1 的资源被转移到 vec2，避免了拷贝

Plain Textusing int_ptr = int*;

Plain Textconstexpr int square(int x) {
	return x * x;
}

constexpr int result = square(5); 
// 编译时计算 result 的值

Plain Textauto x = 10; // x is an int

Plain Textstd::vector<int> vec = {1,2,3,4,5};
for (auto& elem: vec) {
	std::cout << elem << std::endl;
}

Plain Textauto add = [](int a, int b) -> int {
	return a + b;
};

std::cout << add(3,4) << std::endl;

Plain Textstd::vector<int> vec1 = {1,2,3};
std::vector<int> vec2 = std::move(vec1); 
// vec1 的资源被转移到 vec2，避免了拷贝

Plain Textusing int_ptr = int*;

Plain Textconstexpr int square(int x) {
	return x * x;
}

constexpr int result = square(5); 
// 编译时计算 result 的值

Plain Textauto x = 10; // x is an int

Plain Textstd::vector<int> vec = {1,2,3,4,5};
for (auto& elem: vec) {
	std::cout << elem << std::endl;
}

Plain Textauto add = [](int a, int b) -> int {
	return a + b;
};

std::cout << add(3,4) << std::endl;

Plain Textstd::vector<int> vec1 = {1,2,3};
std::vector<int> vec2 = std::move(vec1); 
// vec1 的资源被转移到 vec2，避免了拷贝

Plain Textusing int_ptr = int*;

Plain Textconstexpr int square(int x) {
	return x * x;
}

constexpr int result = square(5); 
// 编译时计算 result 的值

Plain Textauto x = 10; // x is an int

Plain Textstd::vector<int> vec = {1,2,3,4,5};
for (auto& elem: vec) {
	std::cout << elem << std::endl;
}

Plain Textauto add = [](int a, int b) -> int {
	return a + b;
};

std::cout << add(3,4) << std::endl;

Plain Textstd::vector<int> vec1 = {1,2,3};
std::vector<int> vec2 = std::move(vec1); 
// vec1 的资源被转移到 vec2，避免了拷贝

Plain Textusing int_ptr = int*;

Plain Textconstexpr int square(int x) {
	return x * x;
}

constexpr int result = square(5); 
// 编译时计算 result 的值

Plain Textauto x = 10; // x is an int

Plain Textstd::vector<int> vec = {1,2,3,4,5};
for (auto& elem: vec) {
	std::cout << elem << std::endl;
}

Plain Textauto add = [](int a, int b) -> int {
	return a + b;
};

std::cout << add(3,4) << std::endl;

Plain Textstd::vector<int> vec1 = {1,2,3};
std::vector<int> vec2 = std::move(vec1); 
// vec1 的资源被转移到 vec2，避免了拷贝

Plain Textusing int_ptr = int*;

Plain Textconstexpr int square(int x) {
	return x * x;
}

constexpr int result = square(5); 
// 编译时计算 result 的值

Plain Textauto x = 10; // x is an int

Plain Textstd::vector<int> vec = {1,2,3,4,5};
for (auto& elem: vec) {
	std::cout << elem << std::endl;
}

Plain Textauto add = [](int a, int b) -> int {
	return a + b;
};

std::cout << add(3,4) << std::endl;

Plain Textstd::vector<int> vec1 = {1,2,3};
std::vector<int> vec2 = std::move(vec1); 
// vec1 的资源被转移到 vec2，避免了拷贝

Plain Textusing int_ptr = int*;

Plain Textconstexpr int square(int x) {
	return x * x;
}

constexpr int result = square(5); 
// 编译时计算 result 的值

Plain Textauto x = 10; // x is an int

Plain Textstd::vector<int> vec = {1,2,3,4,5};
for (auto& elem: vec) {
	std::cout << elem << std::endl;
}

Plain Textauto add = [](int a, int b) -> int {
	return a + b;
};

std::cout << add(3,4) << std::endl;

Plain Textstd::vector<int> vec1 = {1,2,3};
std::vector<int> vec2 = std::move(vec1); 
// vec1 的资源被转移到 vec2，避免了拷贝

Plain Textusing int_ptr = int*;

Plain Textconstexpr int square(int x) {
	return x * x;
}

constexpr int result = square(5); 
// 编译时计算 result 的值

Plain Textauto x = 10; // x is an int

Plain Textstd::vector<int> vec = {1,2,3,4,5};
for (auto& elem: vec) {
	std::cout << elem << std::endl;
}

Plain Textauto add = [](int a, int b) -> int {
	return a + b;
};

std::cout << add(3,4) << std::endl;

Plain Textstd::vector<int> vec1 = {1,2,3};
std::vector<int> vec2 = std::move(vec1); 
// vec1 的资源被转移到 vec2，避免了拷贝

Plain Textusing int_ptr = int*;

Plain Textconstexpr int square(int x) {
	return x * x;
}

constexpr int result = square(5); 
// 编译时计算 result 的值

Plain Textauto x = 10; // x is an int

Plain Textstd::vector<int> vec = {1,2,3,4,5};
for (auto& elem: vec) {
	std::cout << elem << std::endl;
}

Plain Textauto add = [](int a, int b) -> int {
	return a + b;
};

std::cout << add(3,4) << std::endl;

Plain Textstd::vector<int> vec1 = {1,2,3};
std::vector<int> vec2 = std::move(vec1); 
// vec1 的资源被转移到 vec2，避免了拷贝

Plain Textusing int_ptr = int*;

Plain Textconstexpr int square(int x) {
	return x * x;
}

constexpr int result = square(5); 
// 编译时计算 result 的值

Plain Textauto x = 10; // x is an int

Plain Textstd::vector<int> vec = {1,2,3,4,5};
for (auto& elem: vec) {
	std::cout << elem << std::endl;
}

Plain Textauto add = [](int a, int b) -> int {
	return a + b;
};

std::cout << add(3,4) << std::endl;

Plain Textstd::vector<int> vec1 = {1,2,3};
std::vector<int> vec2 = std::move(vec1); 
// vec1 的资源被转移到 vec2，避免了拷贝

Plain Textusing int_ptr = int*;

Plain Textconstexpr int square(int x) {
	return x * x;
}

constexpr int result = square(5); 
// 编译时计算 result 的值

Plain Textauto x = 10; // x is an int

Plain Textstd::vector<int> vec = {1,2,3,4,5};
for (auto& elem: vec) {
	std::cout << elem << std::endl;
}

Plain Textauto add = [](int a, int b) -> int {
	return a + b;
};

std::cout << add(3,4) << std::endl;

Plain Textstd::vector<int> vec1 = {1,2,3};
std::vector<int> vec2 = std::move(vec1); 
// vec1 的资源被转移到 vec2，避免了拷贝

Plain Textusing int_ptr = int*;

Plain Textconstexpr int square(int x) {
	return x * x;
}

constexpr int result = square(5); 
// 编译时计算 result 的值