C++初级（命名空间，缺省参数，重载函数，引用，引用和指针的对比）

                                                                       命名空间

---

        C++命名空间是一种用于组织代码和避免命名冲突的机制。它允许将相关的类、函数、变量等实体分组到一个命名空间中，从而将它们与其他代码隔离开来。

通过使用命名空间，我们可以创建一个独特的作用域，其中存放着特定命名空间中定义的实体。这样，即使在不同的命名空间中存在相同名称的实体，它们也不会发生冲突。

命名空间可以帮助我们编写模块化的代码，增加代码的可读性和可维护性。它还可以提供更好的代码组织，使代码结构更清晰，方便开发者进行组织和管理。

在C++中，使用namespace关键字来定义命名空间，例如：

namespace MyNamespace {
    // 命名空间中的代码
    int x;
    void foo();
    class MyClass {
        // 类的定义
    };
}

当在代码中使用命名空间中的实体时，需要使用命名空间名称::实体名称的方式进行限定，例如：

int main() {
    MyNamespace::foo(); // 调用命名空间中的函数
    MyNamespace::MyClass obj; // 创建命名空间中的类的实例

    return 0;
}

除了限定方式，还可以使用using关键字引入命名空间中的具体实体，使得在代码中可以直接使用实体名称，而无需限定命名空间，例如：

using MyNamespace::foo; // 引入命名空间中的函数
using MyNamespace::MyClass; // 引入命名空间中的类

int main() {
    foo(); // 直接调用函数
    MyClass obj; // 直接创建类的实例

    return 0;
}

 

---

缺省参数

---

缺省参数（Default Parameters）是C++函数的一项特性，它允许在函数定义时给函数的参数指定默认值。这样，在调用函数时，如果没有提供相应参数的值，那么函数将使用默认值作为参数的值。

缺省参数的语法形式是在函数声明或定义中为参数指定默认值，例如：

int addNumbers(int a, int b = 0);

在上面的例子中，函数addNumbers有两个参数：a和b。参数b被指定了默认值为0。这意味着，如果在函数调用时只提供了一个参数，那么第二个参数将默认为0：

int result1 = addNumbers(5, 3); // a = 5, b = 3
int result2 = addNumbers(7); // a = 7, b = 0 (默认值被使用)

在函数定义时，缺省参数只能从右向左连续出现。也就是说，如果一个参数被指定了默认值，那么它之后的所有参数都必须有默认值。例如：

// 有效的缺省参数使用
void printValues(int a, int b = 0, float c = 1.5);

// 无效的缺省参数使用（b之后的参数c没有默认值）
void printValues(int a = 5, int b, float c = 1.5);

需要注意的是，一旦函数的声明中指定了默认参数值，那么该函数的后续声明和定义中都不能再次为该参数指定默认值。只有函数的第一次声明可以包含默认参数。

使用缺省参数可以增加函数的灵活性，简化函数调用时的参数传递。然而，过多的缺省参数可能会导致代码理解和维护的困难，因此需要根据实际情况谨慎使用。

 

---

 重载函数

---

函数重载（Function Overloading）是C++中的一种特性，它允许使用相同的函数名字定义多个具有不同参数列表的函数。通过函数重载，可以根据不同的参数类型、个数或顺序来调用不同的函数实现。

函数重载的特点和要求如下：

1. 函数名相同：重载函数具有相同的函数名字，但参数列表必须不同。
2. 参数列表不同：重载函数的参数列表必须不同，可以通过参数的类型、个数或顺序来区分不同的函数。
3. 返回类型不同不足以决定函数重载：C++不允许仅根据返回类型的差异来进行函数重载，因为函数的返回类型通常不能用于区分重载函数。
4. 作用域不同不足以决定函数重载：函数的作用域（全局作用域、类作用域等）不会影响函数重载，相同的函数名和参数列表仍然被视为重载函数。

下面是一个函数重载的示例：

// 重载函数 add，根据参数类型的不同有不同的行为
int add(int a, int b) {
    return a + b;
}

float add(float a, float b) {
    return a + b;
}

// 重载函数 add，根据参数个数的不同有不同的行为
int add(int a, int b, int c) {
    return a + b + c;
}

通过函数重载，可以根据不同的参数类型或个数来选择合适的函数进行调用：

int result1 = add(2, 3);           // 调用第一个重载函数
float result2 = add(1.5f, 2.5f);   // 调用第二个重载函数
int result3 = add(1, 2, 3);        // 调用第三个重载函数

函数重载可以提高代码的可读性和灵活性，减少类似功能的函数的命名冲突。但在使用函数重载时，需要注意参数的类型、个数和顺序，以避免歧义和错误的调用。

 

---

引用

---

在C++中，引用（Reference）是一种指向已存在的变量的别名。引用提供了一种简洁而方便的方式来间接访问变量，同时也可以用来实现参数传递和函数返回值等特性。以下是关于C++引用的一些特点和使用方式：

1. 引用的声明：引用使用&符号进行声明，将引用指定为已存在变量的别名。例如：

   int num = 10;  // 声明一个整型变量
   int& ref = num;  // 声明一个整型引用，并将其指向num

2. 别名：引用被视为变量的别名，通过引用对变量的操作实际上是对原始变量的操作。例子：

   int num = 10;
   int& ref = num;
   
   ref = 20;   // num的值现在为20
   num = 30;   // ref的值现在为30

3. 必须初始化：引用在声明时必须进行初始化，且一旦初始化完成，不可更改绑定的变量。例如：

   int num = 10;
   int& ref = num;  // 正确，引用绑定到num变量
   int& ref2;      // 错误，引用必须进行初始化

4. 引用作为函数参数：引用常用于函数参数，可以通过引用参数实现对实参的修改。函数通过引用传递参数时，对参数的修改将直接影响原始变量的值。例如：

   void increment(int& value) {
       value++;   // 修改原始变量的值
   }
   
   int num = 5;
   increment(num);  // num的值现在为6

5. 引用作为函数返回值：可以将引用作为函数的返回值类型，从而实现对函数外部变量的访问和修改。例如：

   int& getNum() {
       static int num = 10;
       return num;  // 返回对静态变量的引用
   }
   
   int& ref = getNum();
   ref = 20;  // 修改静态变量的值

   通过使用引用，我们可以方便地在函数中修改实参的值、很好地处理大型结构的参数传递以及实现函数链式调用等。

   需要注意的是，引用不能指向空值（NULL），且引用本身不占用存储空间。                                     

   ---

   引用和指针的对比

   ---

引用和指针是C++中两种不同的概念，它们有着相似的功能，但也存在一些重要的区别。下面是引用和指针之间的比较：

1. 语法和操作：

   • 引用：引用使用&符号进行声明，并通过引用名称直接访问所引用的变量。引用在声明时必须进行初始化，并且绑定之后不能再重新指向其他变量。
   • 指针：指针使用*符号进行声明，并通过对指针进行解引用操作(*ptr)来访问所指向的变量。指针可以在运行时改变指向的变量。

2. 空值（NULL）：

   • 引用：引用不允许指向空值（NULL），必须始终引用某个已存在的对象。
   • 指针：指针可以指向空值（NULL），即指针变量不指向任何有效的内存地址。

3. 初始化：

   • 引用：引用在声明时必须进行初始化，并且一旦绑定到某个变量，就不能再改变其绑定。
   • 指针：指针在声明时可以不进行初始化，也可以在后续的操作中重新指向不同的变量。

4. 空间占用：

   • 引用：引用本身不占用额外的存储空间，它只是作为所引用变量的别名存在。
   • 指针：指针变量占用额外的存储空间，用于存储所指向的变量的内存地址。

5. 用途：

   • 引用：引用常用于函数参数传递、函数返回值类型以及实现操作符重载等情况。
   • 指针：指针在动态内存分配、数据结构操作以及实现复杂的内存管理等方面有着更大的灵活性。

选择使用引用还是指针取决于具体的需求和场景。引用通常更直观易懂，同时也具有一定的限制和安全性；指针则更加灵活，但需要注意处理空指针和指针的生命周期管理。