auto
在C++11中，auto关键字的引入使得类型推导变得更加简洁和灵活。auto允许编译器根据初始化表达式自动推导变量的类型，从而减少了手动指定类型的负担。以下是关于C++11中auto的几个关键点：
1. 基本用法
使用auto时，变量的类型由其初始化表达式决定。例如：
cpp
auto x = 42; // x 被推导为 int
auto y = 3.14; // y 被推导为 double
auto name = "Alice"; // name 被推导为 const char*
2. 通过函数返回类型推导
auto同样可以用于函数的返回类型，结合->符号，这种写法在使用复杂类型时特别有用。例如：
auto add(int a, int b) -> int {
return a + b;
}
从C++14开始，还引入了返回值类型推导的特性，可以更加简洁地书写返回类型：
auto add(int a, int b) {
return a + b; // 自动推导为 int
}
3. 对于容器的使用
在处理 STL 容器时，auto 可以极大简化代码。例如，使用 auto 遍历一个 vector：
#include <vector>
#include <iostream>
int main() {
std::vector<int> vec = {1, 2, 3, 4, 5};
for (auto it = vec.begin(); it != vec.end(); ++it) {
std::cout << *it << " ";
}
return 0;
}
4. 类型推导的重要性
简化代码：使用 auto 可以减少冗长的类型声明，使代码更加简洁。
类型安全：类型仍然在编译时确认，这确保了类型安全性。
与模板和复杂类型的兼容性：auto 尤其适用于模板编程和与复杂类型（如 lambda 表达式、迭代器等）结合时。
5. 注意事项
auto 需要初始化：使用 auto 声明的变量必须在同一行进行初始化。
类型限制：auto 的推导是根据初始化表达式，不能用于未声明类型（如没有初始化的变量）。
常量性：如果想要推导一个常量类型，可以使用 const auto。
示例
以下是一个综合示例，展示了如何在C++11中使用auto：
#include <iostream>
#include <vector>
#include <string>
int main() {
// 使用 auto 定义变量
auto i = 10;
auto d = 5.5;
auto str = std::string("Hello, C++11!");
std::cout << i << ", " << d << ", " << str << std::endl;
// 使用 auto 遍历 vector
std::vector<int> numbers = {1, 2, 3, 4, 5};
for (auto num : numbers) {
std::cout << num << " ";
}
return 0;
}
decltype
通过以上示例，可以看到auto的灵活性和易用性在实际编程中的优势。
decltype 是 C++11 中引入的一种关键字，主要用于查询变量或表达式的类型，并在编译时确定其类型。decltype 的主要优势在于它能够根据给定的变量或表达式，在没有实际计算该表达式的情况下返回其类型。这使得在类型推导、模板编程和复杂类型处理时更加灵活和强大。
基本用法
decltype 的基本语法是：
decltype(expression)
其中 expression 是要查询类型的变量或表达式。
示例
基础变量类型查询:
int x = 10;
decltype(x) a; // a 的类型为 int
表达式类型查询:
double y = 5.5;
decltype(x + y) b; // b 的类型为 double，因为 x + y 的类型为 double
结合指针和引用:
int z = 15;
decltype(&z) ptr; // ptr 的类型为 int*
追踪返回类型
在C++中，追踪返回类型（Trailing Return Type）是一种使返回类型可在函数体后面声明的语法功能。这种语法在C++11中引入，通常与auto关键字一起使用，使得在定义模板函数、lambda 表达式或具有复杂返回类型的函数时更加灵活。
基本语法
追踪返回类型的语法形式为：
auto functionName(parameters) -> returnType {
// function body
}
基本示例:
#include <iostream>
auto add(int a, int b) -> int {
return a + b;
}
int main() {
std::cout << "Sum: " << add(3, 4) << std::endl;
return 0;
}
在此例中，add函数的返回类型被声明在函数体之后。
在模板中的使用:
追踪返回类型在模板中尤其有用，因为模板参数可能会影响返回类型。例如，以下是一个使用追踪返回类型的模板函数：
#include <iostream>
#include <vector>
#include <iterator>
template<typename T>
auto getSecondElement(const std::vector<T>& vec) -> T {
return vec[1]; // 返回第二个元素
}
int main() {
std::vector<int> numbers = {1, 2, 3};
std::cout << "Second Element: " << getSecondElement(numbers) << std::endl;
return 0;
}
结合复杂类型:
追踪返回类型可以帮助处理复杂的返回类型，例如使用迭代器：
#include <iostream>
#include <vector>
auto findMax(const std::vector<int>& vec) -> std::vector<int>::const_iterator {
return std::max_element(vec.begin(), vec.end());
}
int main() {
std::vector<int> numbers = {1, 3, 2, 5, 4};
auto maxIt = findMax(numbers);
std::cout << "Maximum Element: " << *maxIt << std::endl;
return 0;
}
优点
清晰性：在某些情况下，将返回类型放在参数列表之后提供了更好的可读性，特别是在需要表示复杂类型时。
与auto结合使用：可以利用auto来简化函数定义，同时将类型放在后面声明。
模板编程：使得模板函数的返回类型定义更加灵活。
注意事项
追踪返回类型的语法结构虽然不同，但与常规返回类型声明并不相冲突。
在使用追踪返回类型时，确保返回类型与函数体内实际返回的类型相匹配，以避免编译错误。
追踪返回类型在C++的现代编程中非常有用，帮助开发者更灵活地定义函数返回类型，特别是在处理复杂或依赖于模板参数的类型时。
初始化
C++11 引入了多种新的初始化方式，使得对象的创建和初始化变得更加直观和灵活。以下是 C++11 中的一些重要初始化方法：
1. 列表初始化 (Aggregate Initialization)
使用花括号 {} 进行初始化，可以初始化基本类型、结构体和数组等。
// 基本类型
int a{5}; // a 被初始化为 5
// 结构体
struct Point {
int x;
int y;
};
Point p{1, 2}; // p.x 为 1，p.y 为 2
// 数组
int arr[3]{1, 2, 3}; // 数组被初始化为 {1, 2, 3}
2. 统一初始化
统一初始化允许使用统一语法来初始化不同类型的对象，避免了某些隐式转换的问题。
#include <iostream>
#include <vector>
int main() {
// 防止窄化转换
// int b{3.14}; // 错误，不能将 double 转换为 int
std::vector<int> vec{1, 2, 3, 4}; // 使用列表初始化
for (const auto& num : vec) {
std::cout << num << " ";
}
return 0;
}
3. auto 与列表初始化
在 C++11 中，可以与 auto 结合使用，通过列表初始化来推导类型。
auto x{10}; // x 是 int 类型
auto y{3.14}; // y 是 double 类型
auto z{"Hello"}; // z 是 const char* 类型
4. std::initializer_list
C++11 提供了 std::initializer_list 支持用于构造和初始化对象，特别是对于容器类。
#include <iostream>
#include <initializer_list>
class MyClass {
public:
MyClass(std::initializer_list<int> list) {
for (auto& elem : list) {
std::cout << elem << " "; // 打印初始化列表中的元素
}
std::cout << std::endl;
}
};
int main() {
MyClass obj{1, 2, 3, 4, 5}; // 使用初始化列表
return 0;
}
5. 通过构造函数初始化
可以在用户定义的类型中使用构造函数进行初始化。
class Rectangle {
public:
Rectangle(int w, int h) : width(w), height(h) {}
void display() {
std::cout << "Width: " << width << ", Height: " << height << std::endl;
}
private:
int width, height;
};
int main() {
Rectangle rect{10, 20}; // 使用列表初始化调用构造函数
rect.display();
return 0;
}
6. 结构体或类的默认成员初始化
在 C++11 中，可以在类定义中直接为成员提供默认值。
class Point {
public:
int x = 0; // 默认初始化为 0
int y = 0; // 默认初始化为 0
Point(int x_, int y_) : x{x_}, y{y_} {} // 构造函数初始化
};
int main() {
Point p{1, 2}; // 使用构造函数初始化
std::cout << "Point(" << p.x << ", " << p.y << ")" << std::endl;
return 0;
}
总结
C++11 提供多种初始化方式，包括列表初始化、统一初始化以及通过构造函数的初始化。这些特性增强了代码的安全性和可读性，减少了许多潜在的错误。使用统一的初始化语法为不同类型的对象赋值，使得 C++ 语言变得更加灵活和强大。
基于范围的for循环
基于范围的 for 循环（range-based for loop）是 C++11 引入的一种简化的循环结构，主要用于遍历容器（如数组、向量、列表等）中的元素。这个特性能够使得代码更加简洁和可读。
1. 基本语法
基本的循环语法如下：
for (declaration : collection) {
// 处理每个元素
}
declaration 是对每个元素的声明。
collection 是要遍历的容器（如数组、向量等）。
2. 示例
以下是一些使用范围基于 for 循环的示例：
遍历数组
#include <iostream>
int main() {
int arr[] = {1, 2, 3, 4, 5};
for (int x : arr) {
std::cout << x << " "; // 输出每个元素
}
std::cout << std::endl;
return 0;
}
遍历 std::vector
#include <iostream>
#include <vector>
int main() {
std::vector<int> vec = {10, 20, 30, 40, 50};
for (int x : vec) {
std::cout << x << " "; // 输出每个元素
}
std::cout << std::endl;
return 0;
}
遍历 std::string
#include <iostream>
#include <string>
int main() {
std::string str = "Hello";
for (char ch : str) {
std::cout << ch << " "; // 输出每个字符
}
std::cout << std::endl;
return 0;
}
3. 使用引用
使用引用可以避免复制容器中的元素，尤其是当元素比较大时。例如：
#include <iostream>
#include <vector>
int main() {
std::vector<std::string> fruits = {"apple", "banana", "cherry"};
for (const std::string& fruit : fruits) {
std::cout << fruit << " "; // 使用引用
}
std::cout << std::endl;
return 0;
}
4. 修改元素
需要注意的是，默认情况下，基于范围的 for 循环是只读的。如果你需要修改元素，使用非常量引用：
#include <iostream>
#include <vector>
int main() {
std::vector<int> numbers = {1, 2, 3, 4, 5};
for (int& num : numbers) {
num *= 2; // 修改每个元素
}
// 输出修改后的元素
for (const int& num : numbers) {
std::cout << num << " "; // 输出：2 4 6 8 10
}
std::cout << std::endl;
return 0;
}
总结
基于范围的 for 循环使得遍历集合变得更简单和直观，增强了代码的可读性。通过使用引用，可以有效地避免不必要的拷贝，提高性能。如果只需要读取元素，使用 const 引用则是一个好的实践。
静态断言（static_assert）
静态断言（static_assert）是 C++11 引入的一种用于在编译时进行条件检查的功能。它允许程序员在编译阶段验证某个条件是否为真，如果条件不满足，编译器会生成错误信息，从而帮助开发者早期发现潜在的问题。
语法
static_assert(condition, "error message");
condition：一个编译时可计算的常量表达式，返回 true 或 false。
“error message”：字符串，用于描述断言失败时的错误信息。
示例
基本示例
#include <iostream>
int main() {
static_assert(sizeof(int) == 4, "Integers are not 4 bytes on this platform");
std::cout << "Size of int is 4 bytes." << std::endl;
return 0;
}
在这个例子中，如果 int 的大小不是 4 字节，编译器会生成错误，并输出指定的错误消息。
类型检查示例
#include <type_traits>
template <typename T>
void check_type() {
static_assert(std::is_integral<T>::value, "Template type must be an integral type");
}
int main() {
check_type<int>(); // 通过
// check_type<double>(); // 这将导致编译错误
return 0;
}
在这个示例中，check_type 函数模板使用 static_assert 检查传入的类型 T 是否是整型。如果传入的类型不是整型（例如 double），编译时会产生错误。
使用场景
类型验证：确保模板参数满足特定条件。
常量值检查：验证常量值是否符合特定要求，例如检查数组大小。
宏定义验证：确保特定宏在编译时被定义。
注意事项
static_assert 只在编译时生效，不能用于运行时条件。
断言失败时，错误信息将帮助快速定位问题。
总结
静态断言是 C++ 中一个很有用的特性，可以有效提高代码的安全性和可维护性。通过在编译阶段验证条件，开发者能更早发现问题并进行修复。
noexcept
noexcept 是 C++11 引入的一个运算符，用于指示某个函数或表达式不会抛出异常。使用 noexcept 可以帮助编译器进行优化，并在某些情况下提高程序的运行效率。此外，它也可以在捕获异常时提供更明确的意图。
1. 语法
void func() noexcept;
或对于某些表达式：
void func() noexcept(condition);
condition：一个编译时常量表达式。如果 condition 为真，则函数标记为 noexcept。
2. 使用示例
基本示例
#include <iostream>
void safeFunction() noexcept {
// 该函数不会抛出异常
std::cout << "This function is noexcept." << std::endl;
}
void riskyFunction() {
// 可能抛出异常的函数
throw std::runtime_error("Error occurred!");
}
int main() {
safeFunction();
try {
riskyFunction();
} catch (const std::exception& e) {
std::cout << "Caught an exception: " << e.what() << std::endl;
}
return 0;
}
在此示例中，safeFunction 被标记为 noexcept，表示它不应抛出异常，而 riskyFunction 可能会抛出异常。
使用与条件
#include <iostream>
#include <vector>
template<typename T>
void process(std::vector<T>& vec) noexcept(vec.empty()) {
// 仅在 vec 非空时可调用
if (!vec.empty()) {
std::cout << "Processing vector." << std::endl;
}
}
这里，process 函数根据 vec.empty() 的返回结果，决定是否被标记为 noexcept。
3. 优势
性能优化：由于编译器知道函数不会抛出异常，因此在某些情况下可以优化代码生成。
代码安全性：对于某些标准库组件（如 std::vector），使用 noexcept 会影响其某些操作的性能，因此在设计时可以减少隐式的拷贝或移动操作。
明确意图：通过标记意图，增加代码的可读性。
4. 注意事项
如果一个被声明为 noexcept 的函数确实抛出了异常，程序将调用 std::terminate()，这通常会导致程序异常终止。
不能将 noexcept 应用于析构函数，因为析构函数必须在异常情况下完成清理操作。
通常建议在异常不会发生的情况下使用 noexcept，如简单的 getter 函数或特殊情况下效能关键的函数。
总结
noexcept 是 C++ 中用于函数异常安全性的工具，通过明确指示函数不会抛出异常，提供了更好的性能和代码可读性。合理使用 noexcept 使得函数的异常处理更加明确，有助于提升程序的健壮性和效率。
nullptr
nullptr 是 C++11 引入的一个关键字，用于表示空指针。它的主要目的是替代以往使用的 NULL 宏，从而提供更安全和更清晰的指针初始化和比较。
1. 特性与优势
类型安全：nullptr 是一个具有特定类型的字面量（std::nullptr_t），它可以被隐式转换为任何类型的指针，且不能被隐式转换为整型。这避免了使用 NULL 时可能出现的类型歧义和错误。
更好的可读性：使用 nullptr 明确表示指针的空值，增加代码的可读性，意图更加清晰。
2. 使用示例
赋值和比较
#include <iostream>
void function(int* ptr) {
if (ptr == nullptr) {
std::cout << "Pointer is null." << std::endl;
} else {
std::cout << "Pointer is valid." << std::endl;
}
}
int main() {
int* p1 = nullptr; // 使用 nullptr 初始化指针
int value = 42;
int* p2 = &value;
function(p1); // 输出: Pointer is null.
function(p2); // 输出: Pointer is valid.
return 0;
}
在这个例子中，nullptr 被用来初始化指针 p1，使得其明确为空。
3. 对比 NULL
传统上，NULL 通常被定义为 0 或 (void*)0，这可能导致不必要的类型转换，造成潜在的错误。使用 nullptr 则消除了这种模糊性。
#include <iostream>
void function(int* ptr) {
if (ptr == 0) { // 使用 0
std::cout << "Pointer is null." << std::endl;
}
}
int main() {
int* p = nullptr; // 使用 nullptr
function(p); // 更加清晰安全的空指针表示
return 0;
}
在这段代码中，使用 nullptr 代替 0 更加明确了目的。
4. 重要的注意事项
不可隐式转换：nullptr 不会隐式转换为整数类型，避免了潜在的错误。
与函数重载结合使用：由于其类型安全性，nullptr 在函数重载中能够帮助编译器选择正确的重载版本。
5. 总结
nullptr 是一个现代 C++ 的重要特性，提供了一种安全、清晰的方式来表示空指针，取代了传统的 NULL。它的引入有助于减少指针使用中的错误，提高代码的可维护性和可读性。在现代 C++ 编程中，推荐使用 nullptr 进行空指针的表示。
强类型枚举
强类型枚举（Scoped Enum 或 Enum Class）是在 C++11 中引入的一种枚举类型，用于提高枚举的类型安全性和可读性。与传统的枚举（通常称为普通枚举）相比，强类型枚举在多个方面有所改进。
1. 语法
强类型枚举的定义使用 enum class 关键字，基本语法如下：
enum class EnumName {
Value1,
Value2,
Value3
};
2. 特性与优势
类型安全：强类型枚举的枚举值不会隐式转换为整数类型，因此可以避免类型混淆和潜在错误。
作用域限制：强类型枚举的枚举值是作用域限定的，只有通过枚举类型名称才能访问，避免了与其他枚举或变量的命名冲突。
明确性：使用 enum class 定义的枚举比传统枚举更加明确，增加代码的可读性。
3. 使用示例
定义与使用
#include <iostream>
enum class Color {
Red,
Green,
Blue
};
int main() {
Color col = Color::Red;
if (col == Color::Red) {
std::cout << "The color is red." << std::endl;
}
return 0;
}
在这个例子中，Color 是一个强类型枚举，Red、Green 和 Blue 是其枚举值。需要通过 Color:: 访问这些值，保持了作用域的清晰性。
强类型枚举与整数区分
#include <iostream>
enum class Direction {
Up,
Down,
Left,
Right
};
int main() {
Direction dir = Direction::Up;
// 下面的代码会导致编译错误，因为不能隐式转换成 int
// int intDir = dir;
return 0;
}
如上所示，强类型枚举无法隐式转换为整数，这增强了类型安全性，避免了可能的逻辑错误。
4. 明确指定底层类型
强类型枚举还允许指定底层整数类型：
enum class Status : uint8_t {
Success = 0,
Error = 1,
Pending = 2
}
;
这允许开发者控制枚举占用的内存大小，并确保其符合特定标准。
5. 总结
强类型枚举（enum class）是 C++11 中的重要特性，可提高程序的类型安全性、可读性和维护性。它通过限制作用域、禁止隐式转换和控制底层数据类型，避免了传统枚举可能引起的问题。在现代 C++ 编程中，推荐使用强类型枚举来替代传统枚举。
常量表达式
常量表达式（Constant Expression）是指在编译时能够被求值的表达式。在 C++ 中，常量表达式可以在编译时进行计算，而不需要在运行时进行评估。这在优化程序性能和内存使用方面具有重要意义。
1. 特性
在编译时求值：常量表达式的值在编译阶段已确定，因此在程序运行时不会产生额外的计算开销。
可用于定义常量：常量表达式可以用来初始化常量变量、数组大小、模板参数等。
支持的内容：常量表达式可以由字面量、常量变量、常量函数、以及某些算术运算组成。
2. C++11 引入的 constexpr
C++11 引入了 constexpr 关键字，用于声明常量表达式类型的变量、函数和构造函数。
使用示例
声明常量表达式变量
constexpr int max_size = 100; // 常量表达式
使用常量表达式函数
#include <iostream>
constexpr int square(int x) {
return x * x; // 常量表达式函数
}
int main() {
constexpr int value = square(10); // 编译时求值
std::cout << "Square of 10 is: " << value << std::endl;
return 0;
}
在上面的例子中，函数 square 被声明为 constexpr，其可以在编译时计算，并赋值给 constexpr 变量 value。
3. 注意事项
复杂度限制：constexpr 函数的内容有限制，它们只能包含可被编译器在编译时求值的表达式。C++14 及之后的版本对 constexpr 函数做了一些扩展，例如允许使用条件语句和循环。
constexpr int factorial(int n) {
return n <= 1 ? 1 : n * factorial(n - 1);
}
作用域：只有在 constexpr 作用域内定义的变量和函数才被视为常量表达式，具有其独特的作用域限制。
- C++20 引入的变化
在 C++20 中，constexpr 的支持进一步增强，可以使用 dynamic memory allocation，这使得常量表达式的应用范围变得更广。
5. 应用场景
模板编程：常量表达式非常适用于模板参数，允许在编译时决定类型和大小。
性能优化：使用常量表达式可以减少运行时开销，尤其是在处理常量数据时。
6. 总结
常量表达式在 C++ 中是一个强大而灵活的特性，通过 constexpr 的引入，开发者可以更好地利用编译时计算，提高程序性能和内存利用率。在现代 C++ 中，合理使用常量表达式有助于编写更高效、更安全的代码。
用户定义字面量
用户定义字面量（User-Defined Literals）是 C++11 引入的一项特性，允许开发者为字面量（如整数、浮点数、字符和字符串等）定义新的类型和解析方式，从而使代码更加直观和易于理解。
1. 基本概念
用户定义字面量的目标是通过指定后缀（suffixed）来扩展字面量的语义。开发者可以根据需要定义如何将特定字面量转换为特定类型。
2. 语法
用户定义字面量的基本语法如下：
type operator "" _suffix(value)
type：返回的类型。
suffix：后缀，可以是一个字母序列。
value：输入的字面量值，可以是整数、浮点数等的数据类型，也可以是字符串。
3. 示例
3.1 整数字面量
以下是一个简单的用户定义字面量示例，它将整数字面量转化为以小时为单位的时间：
#include <iostream>
constexpr long long operator "" _h(unsigned long long hours) {
return hours * 3600; // 将小时转换为秒
}
int main() {
long long seconds = 2_h; // 2 小时转换为秒
std::cout << "2 hours is " << seconds << " seconds." << std::endl;
return 0;
}
3.2 浮点字面量
可以对浮点数进行类似的用户定义字面量：
#include <iostream>
constexpr double operator "" _m(long double meters) {
return meters * 100.0; // 将米转换为厘米
}
int main() {
double centimeters = 1.5_m; // 1.5 米转换为厘米
std::cout << "1.5 meters is " << centimeters << " centimeters." << std::endl;
return 0;
}
3.3 字符串字面量
对于字符串字面量，可以定义一个转换为自定义类型的用户定义字面量：
#include <iostream>
#include <string>
struct MyString {
std::string value;
MyString(const char* str) : value(str) {}
void print() const { std::cout << value << std::endl; }
};
MyString operator "" _myString(const char* str, std::size_t) {
return MyString(str);
}
int main() {
MyString myStr = "Hello, User-Defined Literals"_myString;
myStr.print(); // 输出: Hello, User-Defined Literals
return 0;
}
4. 注意事项
后缀规范：用户定义字面量的后缀必须由 ASCII 字母组成，不能以数字开头。
冲突问题：如果定义的用户字面量与内置字面量发生冲突，后者的优先级较高，可能会造成名称冲突的错误。
常量表达式：用户定义字面量可以是常量表达式，但需要遵循特定的逻辑和规则。
5. 总结
用户定义字面量为 C++ 提供了一种强大的扩展能力，使得可以在代码中更直观地表示特定的数值或字符串类型。通过自定义字面量，可以增强代码的可读性和可维护性，使得对特定单位和数据类型的使用更加自然。
原生字符串字面值
原生字符串字面值（Raw String Literals）是 C++11 引入的一项特性，使得在字符串中可以包含不需要转义的字符，从而简化包含复杂文本、特殊字符（如反斜杠、引号等）和多行文本的处理。
1. 语法
原生字符串字面值的语法如下：
R"delimiter(内容)delimiter"
R"：表示开始原生字符串的标记。
delimiter：可选的分隔符，用于定义字符串的边界。可以是任意的字符序列，帮助处 理字符串中可能的括号和引号。
内容：包含在括号中的字符串内容。
"delimiter"：表示结束原生字符串的标记。
2. 特点
不需要转义：在原生字符串中，反斜杠（\）和其他特殊字符不会被解释为转义字符。
支持多行：原生字符串可以跨多行，适合表示大段文本。
自定义分隔符：可以使用指定的分隔符，避免与字符串内容冲突。
3. 示例
以下是几个原生字符串字面值的常见用法示例：
3.1 基本示例
#include <iostream>
int main() {
const char* rawStr = R"(Hello, "World"!\nThis is a raw string.)";
std::cout << rawStr << std::endl;
return 0;
}
输出：
Hello, "World"!\nThis is a raw string.
在这个示例中，\n 被直接输出，而不是作为换行符。
3.2 包含多个特殊字符
#include <iostream>
int main() {
std::string path = R"(C:\Program Files\MyApp\)";
std::cout << "File path: " << path << std::endl;
return 0;
}
输出：
File path: C:\Program Files\MyApp\
此处路径中的反斜杠不需要转义。
3.3 使用分隔符
#include <iostream>
int main() {
std::string complexStr = R"foo(
This is a complex string that might contain:
- "quotes"
- (parentheses)
- \backslashes\
)foo";
std::cout << complexStr << std::endl;
return 0;
}
输出：
This is a complex string that might contain:
- "quotes"
- (parentheses)
- \backslashes\
在这个示例中，使用 foo 作为分隔符，避免字符串内部的括号或引号干扰。
4. 适用场景
原生字符串字面值非常适用于以下场景：
需要大量使用特殊字符的场景，如正则表达式。
包含多行文本（如 SQL 查询、JSON 数据等）。
改进代码的可读性，避免大量的转义字符。
5. 总结
原生字符串字面值在 C++11 中为处理字符串提供了更大的灵活性。通过使用原生字符串，开发者可以在字符串中直接使用各种字符而无需担心转义，从而在处理复杂字符串时提高了代码的可读性和维护性。
委托构造
在 C++ 中，“委托构造”（delegating constructors）是指一个构造函数调用另一个构造函数。委托构造通常用于简化代码，避免重复的初始化逻辑。当一个构造函数的实现依赖于另一个构造函数时，委托构造可以帮助实现代码重用。
委托构造的语法
委托构造的语法是通过在构造函数的初始化列表中调用另一个构造函数。C++11 引入了委托构造功能，允许一个构造函数直接调用同一类中的其他构造函数。
示例代码
#include <iostream>
using namespace std;
class MyClass {
public:
int a, b;
// 构造函数1：接受一个参数
MyClass(int x) : a(x), b(0) {
cout << "构造函数1：a = " << a << ", b = " << b << endl;
}
// 构造函数2：接受两个参数，委托给构造函数1
MyClass(int x, int y) : MyClass(x) {
b = y;
cout << "构造函数2：a = " << a << ", b = " << b << endl;
}
// 构造函数3：没有参数，委托给构造函数2
MyClass() : MyClass(10, 20) {
cout << "构造函数3：a = " << a << ", b = " << b << endl;
}
};
int main() {
MyClass obj1(5); // 调用构造函数1
MyClass obj2(5, 10); // 调用构造函数2
MyClass obj3; // 调用构造函数3
return 0;
}
输出：
构造函数1：a = 5, b = 0
构造函数2：a = 5, b = 10
构造函数3：a = 10, b = 20
解释：
MyClass(int x)：这是构造函数1，它初始化 a 为 x，并将 b 默认初始化为 0。
MyClass(int x, int y)：这是构造函数2，它使用委托构造的方式，调用了构造函数1，并将 b 设置为 y。
MyClass()：这是构造函数3，它通过委托调用构造函数2，传入默认值 10 和 20。
委托构造的特点
代码重用：通过委托构造，可以避免在多个构造函数中重复相同的初始化逻辑。
简化代码：简化了多个构造函数的实现，增强了可维护性。
只支持同一类中的构造函数：委托构造只能调用同一类中的其他构造函数，不能调用基类或外部类的构造函数。
注意事项
委托构造的调用必须出现在初始化列表中，不能在构造函数体内。
委托构造无法循环调用，即构造函数 A 调用构造函数 B，构造函数 B 又调用构造函数 A，这是不允许的。
委托构造是一种非常实用的技术，特别是在具有多个构造函数且构造逻辑有很多重复时，可以显著提高代码的简洁性和可读性。
继承控制：final和override
在 C++ 中，final 和 override 是用于控制继承和虚函数行为的两个关键字，它们分别用于确保类的接口的正确性、保护派生类和基类之间的关系，增强代码的可维护性。它们是在 C++11 标准中引入的。
1. override
override 关键字用于在派生类中标记一个虚函数，表示该函数覆盖了基类的一个虚函数。使用 override 可以确保编译器在编译时验证派生类的函数确实是对基类虚函数的重写。
特点：
强制要求派生类中的函数必须与基类中的虚函数匹配（即签名必须相同）。
如果基类没有虚函数，或者基类中的虚函数签名与派生类中的不匹配，编译器将报错。
它有助于避免错误，例如误打错函数名或参数不匹配。
示例代码：
#include <iostream>
using namespace std;
class Base {
public:
virtual void foo() {
cout << "Base::foo()" << endl;
}
};
class Derived : public Base {
public:
// 使用 override 确保该函数覆盖了基类的虚函数
void foo() override {
cout << "Derived::foo()" << endl;
}
};
int main() {
Derived d;
d.foo(); // 调用 Derived 类中的 foo()
return 0;
}
输出：
Derived::foo()
如果没有 override：
如果我们不使用 override，而误改了函数签名或参数列表（例如改变了参数类型），编译器不会给出错误提示，这可能会导致潜在的错误。
class Derived : public Base {
public:
// 错误：参数类型不同，编译器不会报错，可能导致问题
void foo(int x) {
cout << "Derived::foo()" << endl;
}
};
如果使用 override，编译器会检测到这个错误，并给出一个清晰的编译错误消息。
2. final
final 关键字用于防止类或虚函数被进一步继承或覆盖。
1. final 用于类
当 final 关键字用于类时，表示该类不能被继承。它将阻止其他类从这个类派生。
示例代码：
class Base final { // 这个类不能被继承
public:
void foo() {
cout << "Base::foo()" << endl;
}
};
// 错误：不能从 Base 类继承，因为它是 final
class Derived : public Base { // 编译错误
void foo() {}
};
2. final 用于虚函数
当 final 关键字用于虚函数时，表示该函数不能在派生类中被重写（覆盖）。如果派生类尝试重写该函数，编译器将报错。
示例代码：
class Base {
public:
virtual void foo() final { // 该虚函数不能被覆盖
cout << "Base::foo()" << endl;
}
};
class Derived : public Base {
public:
// 错误：无法覆盖 Base 类中的 foo() 函数，因为它是 final
void foo() override {
cout << "Derived::foo()" << endl;
}
};
结合使用 final 和 override
final 和 override 可以结合使用。例如，可以在派生类中标记某个虚函数为 final，表示这个函数不能再被进一步覆盖。
示例代码：
class Base {
public:
virtual void foo() {
cout << "Base::foo()" << endl;
}
};
class Derived : public Base {
public:
void foo() override final { // 重写并标记为 final，禁止在更派生的类中覆盖
cout << "Derived::foo()" << endl;
}
};
class FurtherDerived : public Derived {
public:
// 错误：不能覆盖 foo()，因为它在 Derived 中被标记为 final
void foo() override {
cout << "FurtherDerived::foo()" << endl;
}
};
总结：
override: 用于派生类中，标识一个虚函数重写了基类的虚函数。它确保函数签名匹配，避免重写错误。
final:
用于类时，表示该类不能被继承。
用于虚函数时，表示该函数不能被派生类重写。
这两个关键字有助于增强代码的可读性和可维护性，同时提高编译时错误的检测，避免运行时错误。
= default 函数
在 C++11 中，引入了 = default 语法，它允许显式地定义一个特殊的函数：默认构造函数、拷贝构造函数、移动构造函数、析构函数等，而不需要手动实现这些函数的具体细节。= default 使得代码更加简洁，并且可以保持编译器自动生成的行为。
= default 语法的作用
默认构造函数：如果没有显式定义构造函数，编译器会自动生成一个默认构造函数。但是，如果你显式定义了其他构造函数，编译器不会再自动生成默认构造函数。如果你希望编译器生成默认构造函数，可以使用 = default。
拷贝构造函数和移动构造函数：同理，编译器也可以自动生成拷贝构造函数和移动构造函数。如果你需要显式声明它们并让编译器自动生成实现，可以使用 = default。
析构函数：编译器也可以自动生成析构函数。如果没有特殊需求，可以让编译器自动生成析构函数。
使用示例
1. 默认构造函数
#include <iostream>
using namespace std;
class MyClass {
public:
// 使用 = default 显式声明默认构造函数
MyClass() = default;
};
int main() {
MyClass obj; // 调用默认构造函数
return 0;
}
2. 拷贝构造函数
#include <iostream>
using namespace std;
class MyClass {
public:
// 使用 = default 显式声明拷贝构造函数
MyClass(const MyClass&) = default;
};
int main() {
MyClass obj1;
MyClass obj2 = obj1; // 调用拷贝构造函数
return 0;
}
3. 移动构造函数
#include <iostream>
using namespace std;
class MyClass {
public:
// 使用 = default 显式声明移动构造函数
MyClass(MyClass&&) = default;
};
int main() {
MyClass obj1;
MyClass obj2 = std::move(obj1); // 调用移动构造函数
return 0;
}
4. 析构函数
#include <iostream>
using namespace std;
class MyClass {
public:
// 使用 = default 显式声明析构函数
~MyClass() = default;
};
int main() {
MyClass obj; // 析构函数在对象销毁时被调用
return 0;
}
为什么使用 = default？
简化代码：如果你没有特别的需求，可以让编译器自动生成常见的函数，而不需要自己编写冗余的代码。
明确意图：使用 = default 可以明确告诉编译器你希望某个函数被自动生成。尤其是在继承关系中，显式地使用 = default 可以避免编译器错误地生成某些函数。
控制特殊函数的生成：通过 = default，你可以精确地控制编译器是否生成某些特殊函数。如果你想让编译器生成拷贝构造函数或移动构造函数，而不需要手动编写，它提供了一个简洁的方式。
避免编译器自动删除：在某些情况下，编译器可能会自动删除某些函数（例如，拷贝构造函数和析构函数）。通过 = default，你可以确保这些函数是自动生成的，而不会被编译器错误地删除。
特别注意
禁止编译器生成函数：如果你想禁用某个函数的自动生成，可以使用 = delete（例如，禁用拷贝构造函数或移动构造函数）。
class MyClass {
public:
MyClass(const MyClass&) = delete; // 禁止拷贝构造函数
MyClass& operator=(const MyClass&) = delete; // 禁止拷贝赋值运算符
}
;
= default 和 = delete 都可以显式声明在类中，但二者不能共存于同一个函数，因为它们代表了完全相反的行为。
总结
= default 是一种显式声明自动生成特殊成员函数（如构造函数、析构函数、拷贝构造函数等）的方式。
它使代码更加简洁，确保编译器按照默认方式生成这些函数，并且明确表达了开发者的意图。
你可以使用 = default 来指定哪些函数由编译器自动生成，而不是手动实现这些函数的具体内容。
= delete
在 C++ 中，= delete 是一种显式地禁止某个函数的使用的机制。它用于禁用某些特定函数的自动生成或显式声明，使得这些函数无法被调用。通常，= delete 用来阻止编译器生成或使用某些不符合设计要求的特殊成员函数，例如拷贝构造函数、拷贝赋值运算符、移动构造函数等。
使用 = delete 的目的
禁止某些函数的生成：有时候，你可能不希望编译器为某个类生成默认的拷贝构造函数或移动构造函数，或者其他成员函数。在这种情况下，可以通过 = delete 来显式禁止它们。
防止不合适的函数调用：在一些情况下，为了确保类的对象不会被拷贝或移动，或者某些操作不应该发生，可以通过 = delete 来禁用某些操作符或构造函数。
提高代码的安全性：通过禁止某些操作，可以避免潜在的错误，例如无意中拷贝对象时发生的问题。
使用场景和示例
1. 禁止拷贝构造函数和拷贝赋值运算符
有时，我们希望禁止对象被拷贝。此时，可以显式声明拷贝构造函数和拷贝赋值运算符为 delete，这样编译器就不会自动生成这些函数，并且如果代码中尝试拷贝对象时会出现编译错误。
#include <iostream>
using namespace std;
class MyClass {
public:
MyClass() = default; // 默认构造函数
// 禁用拷贝构造函数和拷贝赋值运算符
MyClass(const MyClass&) = delete;
MyClass& operator=(const MyClass&) = delete;
void display() {
cout << "MyClass object!" << endl;
}
};
int main() {
MyClass obj1;
// MyClass obj2 = obj1; // 错误：拷贝构造函数被删除
// obj1 = obj2; // 错误：拷贝赋值运算符被删除
return 0;
}
在上面的例子中，拷贝构造函数和拷贝赋值运算符被显式删除，因此任何尝试拷贝 MyClass 对象的代码都会在编译时产生错误。
2. 禁止移动构造函数和移动赋值运算符
类似地，如果你不希望类的对象能够被移动（例如，出于资源管理等考虑），可以通过 = delete 来禁止移动构造函数和移动赋值运算符。
#include <iostream>
using namespace std;
class MyClass {
public:
MyClass() = default; // 默认构造函数
// 禁用移动构造函数和移动赋值运算符
MyClass(MyClass&&) = delete;
MyClass& operator=(MyClass&&) = delete;
void display() {
cout << "MyClass object!" << endl;
}
};
int main() {
MyClass obj1;
// MyClass obj2 = std::move(obj1); // 错误：移动构造函数被删除
// obj1 = std::move(obj2); // 错误：移动赋值运算符被删除
return 0;
}
在这个例子中，MyClass 类禁止了移动构造函数和移动赋值运算符，因此不能将一个对象的资源"移动"到另一个对象中。
3. 禁止某些操作符
有时，可能需要禁用某些操作符。例如，禁止使用 == 运算符或其他自定义运算符：
#include <iostream>
using namespace std;
class MyClass {
public:
MyClass() = default;
// 禁用等于运算符
bool operator==(const MyClass&) = delete;
void display() {
cout << "MyClass object!" << endl;
}
};
int main() {
MyClass obj1, obj2;
// bool result = (obj1 == obj2); // 错误：== 运算符被删除
return 0;
}
这里，我们禁用了 operator== 运算符，任何尝试使用 == 比较 MyClass 对象的代码都会产生编译错误。
4. 禁止类的默认构造
如果你希望禁止某个类的默认构造函数，可以使用 = delete 来显式删除该构造函数。例如，在某些场景下你可能希望对象必须通过带参数的构造函数进行初始化，而不能无参数地创建对象。
#include <iostream>
using namespace std;
class MyClass {
public:
// 禁用默认构造函数
MyClass() = delete;
MyClass(int x) {
cout << "MyClass created with value: " << x << endl;
}
};
int main() {
// MyClass obj1; // 错误：默认构造函数被删除
MyClass obj2(10); // 正常：使用带参数的构造函数
return 0;
}
总结
= delete 用于显式禁用某些函数，使得这些函数不可用。
常见的应用场景包括禁止拷贝构造函数、拷贝赋值运算符、移动构造函数、移动赋值运算符等，防止对象被拷贝或移动。
使用 = delete 可以防止某些不符合设计要求的操作发生，提高代码的安全性和可控性。
你可以用它来禁用构造函数、运算符、成员函数等，以确保对象的使用符合特定的约束。
通过这种机制，可以有效地控制类的行为，并确保不希望发生的操作不会被编译器生成或执行。
模板的别名
在 C++ 中，模板的别名（Template Aliases）是使用 using 关键字为模板类型创建简化或更具描述性的名称。模板别名可以帮助提高代码的可读性和可维护性，尤其在模板类型复杂或者模板类型参数较多时，使用别名可以减少冗长的代码。
1. 模板别名的基本用法
模板别名可以通过 using 关键字来定义。它允许你为现有的模板类型或模板类创建一个新的名称。
示例 1: 简单的模板别名
#include <iostream>
#include <vector>
// 定义模板别名
template <typename T>
using Vec = std::vector<T>;
int main() {
// 使用别名
Vec<int> v; // 相当于 std::vector<int>
v.push_back(10);
std::cout << v[0] << std::endl; // 输出 10
return 0;
}
在上面的例子中，Vec 是 std::vector 的别名，可以用 Vec 来代替 std::vector。这种方式简化了代码，尤其在模板类型非常长的情况下。
示例 2: 多参数模板别名
模板别名也可以用来为带有多个模板参数的模板类型创建别名。
#include <iostream>
#include <map>
// 定义模板别名
template <typename Key, typename Value>
using MyMap = std::map<Key, Value>;
int main() {
// 使用别名
MyMap<int, std::string> my_map;
my_map[1] = "apple";
my_map[2] = "banana";
for (const auto& [key, value] : my_map) {
std::cout << key << ": " << value << std::endl;
}
return 0;
}
在这个例子中，MyMap<Key, Value> 是 std::map<Key, Value> 的别名，简化了模板使用。
2. 模板别名与类型别名的区别
模板别名与类型别名（using 声明）是不同的概念。类型别名是为现有类型创建简短的名称，而模板别名是为模板类型或模板类创建别名。
示例：类型别名
using IntVector = std::vector<int>; // 类型别名
IntVector v; // 使用类型别名
示例：模板别名
template <typename T>
using Vec = std::vector<T>; // 模板别名
Vec<int> v; // 使用模板别名
3. 模板别名的应用场景
模板别名在以下几种情况下特别有用：
简化冗长的模板类型：当模板类型名称过长或含有多个模板参数时，使用模板别名可以让代码更加简洁和易读。
增强代码可读性：通过使用描述性的别名，代码的意图可以更容易理解。
模板元编程：在复杂的模板元编程中，模板别名可以用来简化类型推导和转换。
示例：模板元编程中使用模板别名
#include <iostream>
#include <type_traits>
// 定义模板别名
template <typename T>
using AddPointer = T*; // 为指针类型创建模板别名
int main() {
AddPointer<int> ptr = nullptr; // 使用别名，等价于 int* ptr = nullptr;
std::cout << std::is_pointer<decltype(ptr)>::value << std::endl; // 输出 1 (true)
return 0;
}
在此例中，AddPointer 是 int* 的模板别名，可以更清晰地表达意图。
4. 模板别名与模板特化
模板别名也可以用于模板特化的场景，来为特定类型的模板创建别名。
示例：模板特化与模板别名
#include <iostream>
#include <vector>
// 默认模板别名
template <typename T>
using Vec = std::vector<T>;
// 特化为 int 类型时，使用不同的容器
template <>
using Vec<int> = std::deque<int>;
int main() {
Vec<int> v1; // 特化为 std::deque<int>
Vec<double> v2; // 默认为 std::vector<double>
std::cout << "Types created successfully!" << std::endl;
return 0;
}
在这个例子中，我们对 Vec 使用了特化，使得 Vec 实际上变成了 std::deque。
5. 模板别名的注意事项
模板别名并不改变原模板类型的行为，它只是为原模板创建了一个新的名字。
对于一些复杂的模板类型，使用模板别名可以使得类型推导更直观。
总结
模板别名是 C++ 中一种有用的特性，它允许我们为模板类型或模板类创建简短且具描述性的名称，简化代码书写和提升代码的可读性。通过 using 关键字，我们能够轻松地创建模板别名，避免冗长的类型名称，并帮助维护和理解复杂的模板代码。