命名空间

命名空间(namespace)是C++中用于解决名称冲突问题的重要机制。

命名空间的作用：

1. 避免命名冲突：命名空间提供了一种将全局作用域划分成更小的作用域的机制，用于避免不同的代码中可能发生的命名冲突问题；

2. 组织代码：将相关的实体放到同一个命名空间；

3. 版本控制：不同版本的代码放到不同的命名空间中；

   下面引用当前流行的命名空间使用指导原则：

   1. 提倡在已命名的名称空间中定义变量，而不是直接定义外部全局变量或者静态全局变量。

   2. 如果开发了一个函数库或者类库，提倡将其放在一个命名空间中。

   3. 对于using 声明，首先将其作用域设置为局部而不是全局。

   4. 包含头文件的顺序可能会影响程序的行为，如果非要使用using编译指令，建议放在所有#include预编译指令后。

命名空间的基本概念：

命名空间提供了一种将全局作用域划分为不同区域的方法，防止不同库之间的名称冲突。

11
1
// 定义命名空间
2
namespace MyNamespace {
3
    int value = 100;
4
    void function() {
5
        // 函数实现
6
    }
7
    
8
    class MyClass {
9
        // 类定义
10
    };
11
}

命名空间的访问方式

直接使用完全限定名称

7
1
int main() {
2
    // 使用作用域解析运算符::访问命名空间成员
3
    int x = MyNamespace::value;
4
    MyNamespace::function();
5
    MyNamespace::MyClass obj;
6
    return 0;
7
}

使用using声明

9
1
using MyNamespace::value;  // 只引入特定成员
2
using MyNamespace::function;
3

4
int main() {
5
    int x = value;  // 直接使用，无需前缀
6
    function();     // 直接使用，无需前缀
7
    MyNamespace::MyClass obj;  // 未引入的成员仍需前缀
8
    return 0;
9
}

使用using指令

8
1
using namespace MyNamespace;  // 引入整个命名空间
2

3
int main() {
4
    int x = value;     // 直接使用
5
    function();        // 直接使用
6
    MyClass obj;       // 直接使用
7
    return 0;
8
}

嵌套命名空间

命名空间可以嵌套定义：

13
1
namespace Outer {
2
    int x = 10;
3
    
4
    namespace Inner {
5
        int y = 20;
6
    }
7
}
8

9
int main() {
10
    int a = Outer::x;
11
    int b = Outer::Inner::y;
12
    return 0;
13
}

命名空间别名

可以为长命名空间名称创建别名：

11
1
namespace VeryLongNamespaceName {
2
    void function() { }
3
}
4

5
// 创建别名
6
namespace Short = VeryLongNamespaceName;
7

8
int main() {
9
    Short::function();  // 使用别名
10
    return 0;
11
}

匿名命名空间

匿名命名空间中的成员具有文件作用域，类似于static：

8
1
namespace {
2
    int hidden_value = 42;  // 只在当前文件可见
3
}
4

5
int main() {
6
    int x = hidden_value;  // 可直接访问
7
    return 0;
8
}

解析规则

当使用一个名称时，C++按以下顺序查找：

1. 当前作用域

2. 外层作用域

3. 使用using声明引入的名称

4. 使用using指令引入的命名空间

5. 全局作用域

命名空间的跨模块调用：

命名空间中的实体跨模块调用时，要在新的源文件中再次定义同名的命名空间，在其中通过extern引入实体。

进行联合编译时，这两次定义被认为是同一个命名空间。

const关键字

const关键字是C++中非常重要的一个关键字，它用于声明常量，保证数据不被修改。

基本用法

定义常量

3
1
const int MAX_SIZE = 100;  // 定义整型常量
2
const double PI = 3.14159; // 定义浮点型常量
3
const char* MESSAGE = "Hello"; // 定义字符串常量

与指针结合使用

xxxxxxxxxx
14
1
// 指向常量的指针（不能通过指针修改所指向的内容）
2
const int* p1 = &value;  // 或 int const* p1 = &value;
3
// *p1 = 20;  // 错误！不能修改所指向的内容
4
p1 = &other;  // 正确，可以改变指针指向
5

6
// 常量指针（指针本身是常量，不能改变指向）
7
int* const p2 = &value;
8
*p2 = 20;     // 正确，可以修改所指向的内容
9
// p2 = &other;  // 错误！不能改变指针指向
10

11
// 指向常量的常量指针（既不能修改指针，也不能修改所指内容）
12
const int* const p3 = &value;
13
// *p3 = 20;     // 错误！
14
// p3 = &other;  // 错误！

在函数中的应用

常量参数

xxxxxxxxxx
11
1
void display(const int value) {
2
    // value = 100;  // 错误！不能修改常量参数
3
    cout << value << endl;
4
}
5

6
void processArray(const int* arr, int size) {
7
    // arr[0] = 100;  // 错误！不能修改数组元素
8
    for (int i = 0; i < size; i++) {
9
        cout << arr[i] << " ";
10
    }
11
}

常量引用

xxxxxxxxxx
5
1
void processLargeObject(const BigObject& obj) {
2
    // 使用常量引用可以避免对象拷贝，同时防止修改
3
    // obj.modify();  // 错误！不能修改常量引用
4
    obj.display();    // 正确，可以调用不修改对象的方法
5
}

在类中的应用

常量成员变量

xxxxxxxxxx
12
1
class Circle {
2
private:
3
    const double PI = 3.14159;  // 常量成员变量
4
    double radius;
5
    
6
public:
7
    Circle(double r) : radius(r) {}
8
    
9
    double getArea() const {
10
        return PI * radius * radius;
11
    }
12
};

常量成员函数

xxxxxxxxxx
19
1
class Student {
2
private:
3
    string name;
4
    int age;
5
    
6
public:
7
    Student(string n, int a) : name(n), age(a) {}
8
    
9
    // 常量成员函数，不能修改类的成员变量
10
    string getName() const {
11
        // age++;  // 错误！常量成员函数不能修改成员变量
12
        return name;
13
    }
14
    
15
    // 非常量成员函数，可以修改类的成员变量
16
    void setAge(int a) {
17
        age = a;  // 正确
18
    }
19
};

常量对象

xxxxxxxxxx
3
1
const Student student("张三", 20);
2
cout << student.getName();  // 正确，可以调用常量成员函数
3
// student.setAge(21);      // 错误！常量对象不能调用非常量成员函数

const的高级用法

常量表达式（C++11）

xxxxxxxxxx
5
1
constexpr int factorial(int n) {
2
    return n <= 1 ? 1 : (n * factorial(n-1));
3
}
4

5
constexpr int result = factorial(5);  // 编译时计算

成员函数重载

xxxxxxxxxx
15
1
class MyString {
2
private:
3
    char* data;
4
    
5
public:
6
    // 非常量版本，返回可修改的引用
7
    char& operator[](size_t index) {
8
        return data[index];
9
    }
10
    
11
    // 常量版本，返回常量引用
12
    const char& operator[](size_t index) const {
13
        return data[index];
14
    }
15
};

const的好处

1. 增强代码安全性：防止意外修改数据

2. 提高代码可读性：明确表明哪些数据不应被修改

3. 编译器优化：编译器可以对常量进行更多优化

4. 接口设计：明确函数是否会修改传入的参数

const常量和宏定义常量的区别

const常量和宏定义常量(#define)是C++中两种定义常量的方式，它们有以下几个重要区别：

1.类型检查

• const常量：有类型检查，是强类型的

  xxxxxxxxxx
  1
  1
  const int MAX_SIZE = 100;  // 明确指定为int类型
  

• 宏定义：无类型检查，只是简单的文本替换

  xxxxxxxxxx
  1
  1
  #define MAX_SIZE 100  // 没有类型信息
  

2.内存分配

• const常量：会分配内存，是变量

  xxxxxxxxxx
  1
  1
  const int MAX_SIZE = 100;  // 在内存中有存储位置
  

• 宏定义：不分配内存，预处理阶段进行文本替换

  xxxxxxxxxx
  1
  1
  #define MAX_SIZE 100  // 预处理时直接替换为100
  

3.作用域

• const常量：遵循作用域规则

  xxxxxxxxxx
  4
  1
  void func() {
  2
      const int LOCAL_MAX = 10;  // 局部作用域
  3
  }
  4
  // LOCAL_MAX在这里不可见
  

• 宏定义：从定义处到文件结束或#undef处都有效

  xxxxxxxxxx
  2
  1
  #define GLOBAL_MAX 100  // 从这里开始有效
  2
  // 在整个文件中都可见，除非被#undef
  

4.调试

• const常量：可以在调试器中查看

• 宏定义：在预处理阶段被替换，调试时看不到原始定义

5.安全性

• const常量：更安全，可以避免一些意外错误

  xxxxxxxxxx
  1
  1
  const char* str = "Hello";  // 指向常量字符串的指针
  

• 宏定义：可能导致意外问题

  xxxxxxxxxx
  2
  1
  #define SQUARE(x) x*x
  2
  int result = SQUARE(2+3);  // 展开为2+3*2+3，结果为11而非25
  

6.指针操作

• const常量：可以获取地址

  xxxxxxxxxx
  2
  1
  const int MAX = 100;
  2
  const int* p = &MAX;  // 可以取地址
  

• 宏定义：无法获取地址

  xxxxxxxxxx
  2
  1
  #define MAX 100
  2
  // int* p = &MAX;  // 错误，相当于 int* p = &100;
  

7.复杂常量定义

• const常量：可以定义复杂类型的常量

  xxxxxxxxxx
  1
  1
  const struct Point { int x; int y; } origin = {0, 0};
  

• 宏定义：难以定义复杂类型

  xxxxxxxxxx
  1
  1
  #define ORIGIN {0, 0}  // 使用时需要指定类型
  

8.函数内联

• const常量：不会导致代码膨胀

• 宏定义：可能导致代码膨胀

在现代C++中，推荐使用const常量而非宏定义：

• 使用const定义常量值

• 使用constexpr定义编译期常量

• 使用inline函数替代宏函数

• 仅在特殊情况下使用宏定义（如条件编译）

new/delete表达式

new和delete是C++中用于动态内存管理的操作符，它们允许程序在运行时分配和释放内存。

new表达式

基本语法

xxxxxxxxxx
1
1
pointer_variable = new data_type;

分配单个对象

xxxxxxxxxx
6
1
int *p = new int;        // 分配一个int类型的内存空间
2
*p = 10;                 // 赋值
3
delete p;                // 释放内存
4

5
int *q = new int(20);    // 分配并初始化
6
delete q;

分配数组

xxxxxxxxxx
5
1
int *arr = new int[5];   // 分配包含5个int的数组
2
arr[0] = 10;
3
arr[1] = 20;
4
// ...
5
delete[] arr;            // 释放数组内存

分配对象

xxxxxxxxxx
8
1
class MyClass {
2
public:
3
    MyClass() { cout << "构造函数调用" << endl; }
4
    ~MyClass() { cout << "析构函数调用" << endl; }
5
};
6

7
MyClass *obj = new MyClass();  // 调用构造函数
8
delete obj;                    // 调用析构函数并释放内存

delete表达式

基本语法

xxxxxxxxxx
2
1
delete pointer_variable;    // 释放单个对象
2
delete[] array_pointer;     // 释放数组

注意事项

• 释放数组必须使用delete[]，否则只会调用第一个元素的析构函数

• 不能对同一内存空间delete两次（未定义行为）

• 可以对nullptr执行delete操作（无效果但安全）

new/delete的工作原理

new的执行过程

1. 调用operator new分配内存

2. 在分配的内存上调用构造函数

3. 返回对象的指针

delete的执行过程

1. 调用对象的析构函数

2. 调用operator delete释放内存

内存分配失败处理

异常处理

xxxxxxxxxx
7
1
try {
2
    int *huge_array = new int[10000000000];  // 尝试分配大量内存
3
    // 使用内存
4
    delete[] huge_array;
5
} catch (const std::bad_alloc& e) {
6
    cout << "内存分配失败: " << e.what() << endl;
7
}

nothrow形式

xxxxxxxxxx
4
1
int *p = new(nothrow) int[1000000000];
2
if (p == nullptr) {
3
    cout << "内存分配失败" << endl;
4
}

自定义内存管理

重载全局new/delete

xxxxxxxxxx
9
1
void* operator new(size_t size) {
2
    cout << "自定义new: 分配 " << size << " 字节" << endl;
3
    return malloc(size);
4
}
5

6
void operator delete(void* ptr) {
7
    cout << "自定义delete: 释放内存" << endl;
8
    free(ptr);
9
}

重载类的new/delete

xxxxxxxxxx
12
1
class MyClass {
2
public:
3
    void* operator new(size_t size) {
4
        cout << "MyClass::new: " << size << " 字节" << endl;
5
        return ::operator new(size);
6
    }
7
    
8
    void operator delete(void* ptr) {
9
        cout << "MyClass::delete" << endl;
10
        ::operator delete(ptr);
11
    }
12
};

常见问题

内存泄漏

xxxxxxxxxx
4
1
void memoryLeak() {
2
    int *p = new int;  // 分配内存
3
    // 没有对应的delete语句，导致内存泄漏
4
}

悬挂指针

xxxxxxxxxx
5
1
int *p = new int(10);
2
int *q = p;      // q指向同一块内存
3
delete p;        // 释放内存
4
p = nullptr;     // p置为nullptr
5
// *q = 20;      // 危险！q成为悬挂指针，访问已释放的内存

###

避免出现问题，使用智能指针:

xxxxxxxxxx
10
1
#include <memory>
2

3
// 使用unique_ptr
4
std::unique_ptr<int> p1(new int(10));
5
// 自动释放，无需手动delete
6

7
// 使用shared_ptr
8
std::shared_ptr<int> p2 = std::make_shared<int>(20);
9
std::shared_ptr<int> p3 = p2;  // 引用计数增加
10
// 当所有shared_ptr都销毁时，内存自动释放

new/delete与malloc/free的区别

1. new/delete会调用构造函数和析构函数，malloc/free不会

2. new返回正确类型的指针，malloc返回void*

3. new/delete可以被重载，malloc/free不能

4. 内存分配失败时，new抛出异常，malloc返回NULL

5. malloc/free是库函数，new/delete是表达式，后两者使用时不是函数的写法

6. malloc申请的空间不会进行初始化，获取到的空间是有脏数据的，但new表达式申请空间时可以直接初始化

7. malloc的参数是字节数，new表达式不需要传递字节数，会根据相应类型自动获取空间大小

引用

引用是已定义变量的别名，必须在定义时初始化，初始化后不能改变引用的对象。

xxxxxxxxxx
2
1
int a = 10;
2
int& ref = a;  // ref是a的引用，ref和a指向同一块内存

引用的特点

• 必须初始化

xxxxxxxxxx
3
1
int& ref;      // 错误！引用必须初始化
2
int a = 10;
3
int& ref = a;  // 正确

• 初始化后不能改变

xxxxxxxxxx
4
1
int a = 10;
2
int b = 20;
3
int& ref = a;  // ref引用a
4
ref = b;       // 这不是让ref引用b，而是将b的值赋给a

• 没有空引用,引用必须指向一个有效的对象，不存在空引用的概念。

• 没有引用的引用,C++不支持引用的引用。

• 没有指向引用的指针,不能创建指向引用的指针。

引用的主要用途

函数参数

xxxxxxxxxx
13
1
// 传值
2
void swap1(int a, int b) {
3
    int temp = a;
4
    a = b;
5
    b = temp;
6
}  // 不会改变原始值
7

8
// 传引用
9
void swap2(int& a, int& b) {
10
    int temp = a;
11
    a = b;
12
    b = temp;
13
}  // 会改变原始值

函数返回值

xxxxxxxxxx
9
1
int& getElement(vector<int>& vec, int index) {
2
    return vec[index];  // 返回引用
3
}
4

5
int main() {
6
    vector<int> numbers = {10, 20, 30};
7
    getElement(numbers, 1) = 50;  // 修改vector中的元素
8
    // numbers现在是 {10, 50, 30}
9
}

常量引用

xxxxxxxxxx
4
1
void printValue(const int& value) {
2
    // value = 100;  // 错误！不能修改常量引用
3
    cout << value << endl;
4
}

引用与指针的区别

1. 必须初始化：引用必须在定义时初始化，指针可以稍后初始化

2. 不能改变引用对象：引用一旦初始化，不能改变引用的对象；指针可以随时改变指向

3. 没有空引用：引用必须指向有效对象；指针可以为nullptr

4. 使用方式：引用使用时与普通变量相同；指针需要解引用操作

5. 内存占用：引用不占用额外内存；指针是一个变量，占用内存

xxxxxxxxxx
9
1
// 指针
2
int a = 10;
3
int* ptr = &a;
4
*ptr = 20;  // 通过指针修改a的值
5

6
// 引用
7
int b = 30;
8
int& ref = b;
9
ref = 40;   // 直接修改b的值

右值引用（C++11）

C++11引入了右值引用，用于支持移动语义和完美转发。

xxxxxxxxxx
2
1
// 右值引用
2
int&& rref = 10;  // 绑定到右值

移动语义

xxxxxxxxxx
8
1
class MyString {
2
public:
3
    // 移动构造函数
4
    MyString(MyString&& other) noexcept {
5
        data = other.data;
6
        other.data = nullptr;  // 资源转移
7
    }
8
};

完美转发

xxxxxxxxxx
4
1
template<typename T, typename Arg>
2
void wrapper(Arg&& arg) {
3
    T object(std::forward<Arg>(arg));  // 完美转发参数
4
}

注意事项

不要返回局部变量的引用

xxxxxxxxxx
4
1
int& getLocalRef() {
2
    int local = 10;
3
    return local;  // 错误！返回局部变量的引用
4
}

引用作为类成员

xxxxxxxxxx
6
1
class MyClass {
2
private:
3
    int& ref;  // 引用成员
4
public:
5
    MyClass(int& r) : ref(r) {}  // 必须在初始化列表中初始化
6
};

引用的本质:引用在底层实现上通常是通过指针实现的，但在语法层面上提供了更安全、更方便的使用方式。

强制转换

C++提供了多种类型转换机制，比传统C语言的类型转换更加安全和明确。

static_cast

static_cast 是最常用的类型转换操作符，主要用于：

• 基本数据类型之间的转换

• 有继承关系的类指针或引用之间的转换（向上转换安全，向下转换不检查）

• 任何类型转换为void类型

xxxxxxxxxx
5
1
double d = 3.14159;
2
int i = static_cast<int>(d);  // 将double转换为int
3

4
Base* basePtr = new Derived();
5
Derived* derivedPtr = static_cast<Derived*>(basePtr);  // 向下转换，不安全

dynamic_cast

dynamic_cast 主要用于有继承关系的类指针或引用之间的转换，特点是：

• 在运行时进行类型检查

• 只能用于含有虚函数的类

• 向下转换时，如果转换失败，对指针返回nullptr，对引用抛出异常

xxxxxxxxxx
8
1
Base* basePtr = new Derived();
2
Derived* derivedPtr = dynamic_cast<Derived*>(basePtr);  // 安全的向下转换
3

4
if (derivedPtr) {
5
    // 转换成功
6
} else {
7
    // 转换失败
8
}

const_cast

const_cast 用于移除或添加const/volatile限定符：

• 可以将const对象转换为非const对象

• 不能用于改变对象的类型

• 通常用于处理API不一致的情况

xxxxxxxxxx
3
1
const int a = 10;
2
int* ptr = const_cast<int*>(&a);  // 移除const限定
3
*ptr = 20;  // 危险操作！可能导致未定义行为

reinterpret_cast

reinterpret_cast 是最危险的转换操作符：

• 可以在任意指针类型之间转换

• 可以在指针和整数类型之间转换

• 不检查类型安全性，完全依赖程序员保证正确性

xxxxxxxxxx
3
1
int* p = new int(65);
2
char* ch = reinterpret_cast<char*>(p);  // 将int*转换为char*
3
std::cout << *ch;  // 可能输出'A'（ASCII 65）

传统C风格转换

C++仍然支持C风格的类型转换，但不推荐使用：

xxxxxxxxxx
3
1
double d = 3.14159;
2
int i = (int)d;  // C风格转换
3
int j = int(d);  // 函数式转换

各种转换的比较

• 优先使用C++风格的类型转换而非C风格转换

• 尽量避免使用reinterpret_cast和const_cast

• 对于类层次结构中的向下转换，优先使用dynamic_cast

• 对于简单的数值类型转换，使用static_cast

• 编写代码时尽量减少类型转换的需求

函数重载

函数重载是C++中一个重要的特性，它允许在同一作用域中定义多个同名函数，只要它们的参数列表不同。

函数重载允许同一个函数名有多个不同的实现，根据调用时提供的参数类型和数量来决定调用哪个函数。

xxxxxxxxxx
3
1
void print(int num);
2
void print(double num);
3
void print(const char* text);

函数重载的规则

必须有不同的参数列表

函数重载必须在以下至少一个方面有所不同：

• 参数数量不同

• 参数类型不同

• 参数顺序不同

xxxxxxxxxx
5
1
void func(int a);                  // 参数类型不同
2
void func(double a);
3
void func(int a, int b);           // 参数数量不同
4
void func(int a, double b);        // 参数类型不同
5
void func(double a, int b);        // 参数顺序不同

仅返回类型不同不构成重载

xxxxxxxxxx
2
1
int getValue();
2
double getValue();    // 错误！仅返回类型不同不构成重载

const修饰符可以构成重载

xxxxxxxxxx
2
1
void display(int* ptr);
2
void display(const int* ptr);    // 参数类型不同，构成重载

对于成员函数，const修饰符也可以构成重载：

xxxxxxxxxx
5
1
class MyClass {
2
public:
3
    void func();           // 非const成员函数
4
    void func() const;     // const成员函数，构成重载
5
};

解析过程

编译器如何选择调用哪个重载函数：

1. 精确匹配：寻找参数类型完全匹配的函数

2. 提升转换：如char到int，float到double的转换

3. 标准转换：如int到double，派生类到基类的转换

4. 用户定义的转换：通过转换构造函数或转换运算符

5. 可变参数函数：如果前面都没匹配到

函数重载的实际应用

标准库中的重载

xxxxxxxxxx
3
1
// 标准库中的min函数重载
2
int min(int a, int b);
3
double min(double a, double b);

构造函数重载

xxxxxxxxxx
7
1
class String {
2
public:
3
    String();                       // 默认构造函数
4
    String(const char* str);        // C风格字符串构造
5
    String(const String& other);    // 拷贝构造函数
6
    String(String&& other);         // 移动构造函数(C++11)
7
};

运算符重载

xxxxxxxxxx
5
1
class Complex {
2
public:
3
    Complex operator+(const Complex& other);
4
    Complex operator+(double real);
5
};

函数重载的注意事项

默认参数与重载

默认参数可能导致调用歧义：

xxxxxxxxxx
4
1
void show(int a = 10);
2
void show(int a, int b = 20);
3

4
show(5);    // 歧义！两个函数都可以匹配

函数重载与类型转换

当多个重载函数都可以通过类型转换匹配时，可能导致歧义：

xxxxxxxxxx
4
1
void process(int value);
2
void process(double value);
3

4
process('a');    // 'a'可以转换为int或double，但int是更好的匹配

重载与作用域

重载函数必须在同一作用域内：

xxxxxxxxxx
5
1
void display(int);
2

3
namespace A {
4
    void display(double);    // 不构成重载，在不同作用域
5
}

函数重载的作用

1. 提高代码可读性：使用相同的函数名表示相似的操作

2. 简化接口：不需要为相似功能创建不同的函数名

3. 类型安全：编译器会选择最匹配的函数

4. 便于维护：功能相似的函数集中在一起

函数重载与模板

函数重载和函数模板可以结合使用：

xxxxxxxxxx
7
1
// 具体函数
2
void print(int value);
3
void print(const char* text);
4

5
// 函数模板
6
template<typename T>
7
void print(const T& value);

当调用print函数时，编译器会优先选择具体函数，如果没有匹配的具体函数，才会实例化模板。

函数默认参数

默认参数是指在函数声明时为形参提供的默认值，当函数调用时如果没有提供该参数的值，则使用默认值。

xxxxxxxxxx
1
1
void printMessage(const char* message, int times = 1);

在这个例子中，times参数有默认值1，调用时可以省略该参数。

使用规则

1.默认参数必须从右向左提供

xxxxxxxxxx
5
1
// 正确
2
void func(int a, int b = 5, int c = 10);
3

4
// 错误
5
void func(int a = 1, int b, int c);

2.默认参数只能在声明或定义中指定一次

xxxxxxxxxx
7
1
// 在声明中指定
2
void func(int a, int b = 5);
3

4
// 在定义中不能再次指定
5
void func(int a, int b) {
6
    // 函数体
7
}

3.默认参数可以是常量、全局变量或函数调用

xxxxxxxxxx
6
1
const int DEFAULT_SIZE = 100;
2
int globalVar = 200;
3

4
void resize(int size = DEFAULT_SIZE);
5
void process(int value = getValue());
6
void configure(int setting = globalVar);

函数调用

使用默认参数的函数可以通过以下方式调用：

xxxxxxxxxx
5
1
void display(int a, int b = 5, int c = 10);
2

3
display(1);       // 等价于 display(1, 5, 10)
4
display(1, 2);    // 等价于 display(1, 2, 10)
5
display(1, 2, 3); // 所有参数都显式提供

默认参数与函数重载

默认参数和函数重载可能导致调用歧义：

xxxxxxxxxx
4
1
void print(int a);
2
void print(int a, int b = 10);
3

4
print(5); // 歧义！两个函数都可以匹配

类中的默认参数

在类中，成员函数也可以使用默认参数：

xxxxxxxxxx
8
1
class Rectangle {
2
public:
3
    void setDimensions(int length, int width = 10);
4
    int getArea() const;
5
private:
6
    int length;
7
    int width;
8
};

默认参数的计算时机

默认参数在函数调用时计算，而不是在函数定义时：

xxxxxxxxxx
9
1
int counter = 0;
2
void func(int value = counter++);
3

4
int main() {
5
    counter = 5;
6
    func();  // value = 5，调用后counter = 6
7
    func();  // value = 6，调用后counter = 7
8
    return 0;
9
}

默认参数的优缺点

优点：

• 提高代码可读性和灵活性

• 减少函数重载的需要

• 使API更易于使用

缺点：

• 可能导致函数调用歧义

• 修改默认值可能影响现有代码

• 在大型项目中可能难以追踪默认值的来源

bool类型

bool类型是C++中表示布尔值的基本数据类型，用于表示逻辑值：真(true)或假(false)。

bool类型在C++98标准中被引入，是C++的基本数据类型之一。

xxxxxxxxxx
2
1
bool flag = true;   // 真
2
bool test = false;  // 假

内存占用

• bool类型在大多数实现中占用1个字节（8位）的内存空间

• 虽然理论上只需要1位就能表示true/false，但为了内存对齐和访问效率，通常使用1字节

xxxxxxxxxx
8
1
#include <iostream>
2
using namespace std;
3

4
int main() {
5
    cout << "bool类型的大小: " << sizeof(bool) << " 字节" << endl;
6
    return 0;
7
}
8
// 输出: bool类型的大小: 1 字节

隐式类型转换

1.其他类型转换为bool

• 数值类型转换为bool：0转换为false，非0转换为true

• 指针类型转换为bool：nullptr转换为false，非空指针转换为true

xxxxxxxxxx
7
1
bool b1 = 42;       // true
2
bool b2 = 0;        // false
3
bool b3 = -3.14;    // true
4
bool b4 = nullptr;  // false
5

6
int* p = new int(5);
7
bool b5 = p;        // true

2.bool转换为其他类型

• bool转换为整型：true转换为1，false转换为0

• bool转换为浮点型：true转换为1.0，false转换为0.0

xxxxxxxxxx
6
1
bool flag = true;
2
int i = flag;      // i = 1
3
double d = flag;   // d = 1.0
4

5
bool test = false;
6
int j = test;      // j = 0

在条件语句中的应用

bool类型最常用于条件语句中：

xxxxxxxxxx
13
1
bool isValid = true;
2

3
if (isValid) {
4
    // 条件为真时执行
5
}
6

7
while (isValid) {
8
    // 条件为真时循环执行
9
}
10

11
// 条件表达式
12
int age = 20;
13
bool isAdult = (age >= 18);  // true

逻辑运算

bool类型可以进行逻辑运算：

xxxxxxxxxx
6
1
bool a = true;
2
bool b = false;
3

4
bool result1 = a && b;  // 逻辑与: false
5
bool result2 = a || b;  // 逻辑或: true
6
bool result3 = !a;      // 逻辑非: false

与C语言的区别

• C语言没有内置的bool类型，通常使用整型（0表示假，非0表示真）

• C99标准引入了_Bool类型和<stdbool.h>头文件，提供了bool、true、false的宏定义

• C++的bool是原生类型，不需要额外的头文件

inline函数

inline函数（内联函数）是C++中一种特殊的函数类型，它的主要目的是通过在调用点直接插入函数代码来避免函数调用的开销。

内联函数是一种对编译器的请求，希望编译器将函数调用替换为函数体代码，从而避免函数调用的开销。

xxxxxxxxxx
8
1
inline int max(int a, int b) {
2
    return (a > b) ? a : b;
3
}
4

5
int main() {
6
    int result = max(10, 20);  // 编译器可能会将这里替换为 int result = (10 > 20) ? 10 : 20;
7
    return 0;
8
}

inline函数的特点

1.性能优化

• 避免了函数调用的开销（压栈、跳转、返回等）

• 对于短小的函数特别有效

• 可能增加代码体积（代码膨胀）

2.只是对编译器的建议

• inline关键字只是对编译器的建议，不是强制命令

• 编译器可能会忽略内联请求，尤其是对于复杂函数

• 现代编译器有自己的内联启发式算法，可能会自动内联未标记为inline的函数

3.定义通常放在头文件中

• 内联函数的定义通常需要放在头文件中

• 这是因为编译器需要在每个调用点看到完整的函数定义

使用场景

适合内联的函数

• 简短的函数（几行代码）

• 频繁调用的函数

• 访问器和修改器（getter/setter）

• 小型工具函数

xxxxxxxxxx
5
1
inline void swap(int& a, int& b) {
2
    int temp = a;
3
    a = b;
4
    b = temp;
5
}

不适合内联的函数

• 包含循环或递归的函数

• 大型复杂函数

• 很少被调用的函数

• 包含大量局部变量的函数

隐式内联

类定义中直接定义的成员函数会被隐式地视为内联函数：

xxxxxxxxxx
16
1
class Point {
2
private:
3
    int x, y;
4
public:
5
    // 隐式内联
6
    int getX() { return x; }
7
    int getY() { return y; }
8
    
9
    // 显式内联
10
    inline void setX(int newX);
11
};
12

13
// 类外定义的成员函数需要显式声明为inline
14
inline void Point::setX(int newX) {
15
    x = newX;
16
}

inline与宏的比较

内联函数相比宏定义有以下优势：

• 类型安全

• 可以进行参数检查

• 可以使用局部变量

• 可以进行调试

• 遵循作用域规则

xxxxxxxxxx
7
1
// 宏定义（不推荐）
2
#define SQUARE(x) ((x) * (x))
3

4
// 内联函数（推荐）
5
inline int square(int x) {
6
    return x * x;
7
}

注意事项

内联函数的限制

• 不能包含复杂的控制流（如多重循环）

• 不能是递归函数

• 不能有过多的局部变量

• 不能使用静态变量（会影响内联决策）

内联与链接

• 内联函数通常具有内部链接

• 多个翻译单元中的同名内联函数必须完全相同

过度使用的问题

• 代码膨胀

• 指令缓存效率降低

• 编译时间增加

异常处理

异常处理是C++中处理程序运行时错误的一种机制，它允许程序在遇到错误时以结构化的方式响应。

异常处理包含三个主要部分：

• try块：包含可能引发异常的代码

• throw语句：用于抛出异常

• catch块：用于捕获并处理异常

xxxxxxxxxx
9
1
try {
2
    // 可能引发异常的代码
3
    if (某个错误条件) {
4
        throw 异常对象;  // 抛出异常
5
    }
6
}
7
catch (异常类型 变量名) {
8
    // 处理异常的代码
9
}

异常的抛出与捕获

抛出异常

可以抛出任何类型的异常：

xxxxxxxxxx
3
1
throw 100;                  // 抛出整数
2
throw "除数不能为零";        // 抛出字符串
3
throw std::runtime_error("内存分配失败");  // 抛出标准异常对象

捕获异常

使用catch块捕获异常：

xxxxxxxxxx
17
1
try {
2
    // 可能抛出异常的代码
3
}
4
catch (int e) {
5
    // 处理整数类型的异常
6
}
7
catch (const char* e) {
8
    // 处理字符串类型的异常
9
}
10
catch (const std::exception& e) {
11
    // 处理标准异常
12
    std::cout << "标准异常: " << e.what() << std::endl;
13
}
14
catch (...) {
15
    // 捕获任何类型的异常
16
    std::cout << "捕获到未知异常" << std::endl;
17
}

标准异常类

C++标准库提供了一系列异常类，都派生自std::exception基类：

xxxxxxxxxx
3
1
#include <stdexcept>  // 标准异常类
2
#include <new>        // bad_alloc异常
3
#include <typeinfo>   // bad_cast异常