一、命名空间
1.什么是命名空间
命名空间（namespace）是C++中的一种机制，用来解决不同代码库之间的命名冲突问题。
先来看一个例子：
#include <iostream>
void print()
{
std::cout << "Hello from print()" << std::endl;
}
// 假设这里有另一个库也定义了print函数
void print()
{
std::cout << "Hello from another print()" << std::endl;
}
int main()
{
print(); // 编译错误，函数名冲突
return 0;
}
这是在写大型项目时经常容易遇到的事情，假如这两个库分别由两个不同的人编写，可能这两个库的代码分别能在各自的环境中正常运行，但当代码提交到一起时，就会出现命名冲突问题问题。
为了解决这种问题，C++提出了命名空间的概念，就是通过把全局范围内的变量、函数和类等放在一个逻辑命名空间内，避免名字重叠。 就像这样：
#include <iostream>
namespace FirstLibrary
{
void print()
{
std::cout << "Hello from FirstLibrary::print()" << std::endl;
}
}
namespace SecondLibrary
{
void print()
{
std::cout << "Hello from SecondLibrary::print()" << std::endl;
}
}
int main()
{
FirstLibrary::print(); // 正常调用
SecondLibrary::print(); // 正常调用
return 0;
}
命名空间包含的成员可以是变量、函数、类和结构体、枚举、类型定义....你还可以套娃在命名空间空间中嵌套命名空间（很少这样做），例如：
namespace MyLibrary
{
int a = 10;
double b = 1.2;
int Add(int left, int right)
{
return left + right;
}
class MyClass
{
public:
void display()
{
// 方法实现
}
};
struct Poiont
{
int x;
int y;
};
enum MyEnum
{
VALUE1,
VALUE2
};
typedef int MyInt;
namespace MyLibrary_2
{
int a = 0;
}
//... ...
}2.如何访问命名空间的成员
2.1作用域展开符
即 直接在要访问的成员名称前加`::`。
`::`是作用域限定符，不作用域限定符则无法访问到该命名空间的成员，因为编译器默认只在全局范围中查找。
int main()
{
// 访问变量
std::cout << MyLibrary::a << std::endl;
// 调用函数
MyLibrary::Add(1,2);
// 使用类
MyLibrary::MyClass obj;
obj.display();
// 使用结构体
MyLibrary::Poiont s = { 1, 9 };
std::cout << "Point: x = " << s.x << ", y = " << s.y << std::endl;
// 使用枚举
MyLibrary::MyEnum e = MyLibrary::VALUE1;
std::cout << "MyEnum value: " << e << std::endl;
// 使用类型别名
MyLibrary::MyInt i = 100;
std::cout << "MyInt: " << i << std::endl;
// 调用嵌套命名空间的函数
std::cout << MyLibrary::MyLibrary_2::a << std::endl;
return 0;
} 
2.2命名空间展开
即 使用`using namespace`指令,命名空间展开可以分为全展开和半展开。
全展开：使用using namespace
using namespace MyLibrary;使用这条语句之后，MyLibrary中的所有成员均可直接访问，即不用在成员前加`::`
#include<iostream>
using namespace std;
int main()
{
cout << "using namespace std" << endl;
return 0;
}如上面这段代码，使用 using namespace std 将C++标准命名空间展开后，就可以直接访问std里面的cout和endl了
半展开：使用using
using MyLibrary::a;使用`using`引入特定的成员，这样在程序中即可直接访问该成员
2.3总结
这三种方式各有优劣，直接使用作用域限定符最为清晰明确，但较为冗长；
`using` 声明适合局部引入特定成员；
`using namespace` 指令则最简便，但可能引入命名冲突风险。
3.注意事项
- 命名空间会自动合并，这意味着可以定义多个同名的命名空间。
- 命名空间只能在全局定义！！
-
`using namespace` 不等于取消命名空间， 影响的是代码编译时候查找该变量的规则（即在指定命名空间和全局变量中寻找）， 比如在使用`using namespace std`后， 依然可以使用 `std :: cout` 来使用 `cout`
二、缺省参数
C++ 的缺省参数（也叫默认参数）是指在函数声明或定义时，给某些参数提供一个默认值。这样在调用函数时，如果不传递这些参数，函数会自动使用默认值。比如下面这段代码：
#include<iostream>
using namespace std;
// a = 0 b = 1 c = 2即为默认值，函数传参时可以选择不传值
void Func(int a = 0, int b = 1, int c = 2)
{
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl;
}
int main()
{
cout << "Func(1, 2)\n";
Func(1, 2);
cout << endl;
cout << "Func()\n";
Func();
return 0;
}
1.缺省参数分类
1.1全缺省参数
void Func(int a = 10, int b = 20, int c = 30)1.2半缺省参数
void Func(int a, int b = 10, int c = 20)2.使用缺省参数的注意事项
2.1申明缺省参数时从右到左
缺省参数必须从右到左依次出现，例如，不能先给 a 指定默认值而不给 b 默认值。
// 错误
void func(int a = 5, int b);
// 正确
void func(int a, int b = 10);
2.2传递参数时从左到右
不存在不连续的缺省值，即 例如在传参时不能省略第一个参数，而给出第二个参数
#include<iostream>
using namespace std;
void Func(int a = 0, int b = 1, int c = 2) // a = 0 是舔狗 没人的时候它就上
{
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl;
}
int main()
{
Func(, 2, 3); //这样是不正确的！
return 0;
} 
2.3如果申明和定义分离，则只在声明中写缺省参数
如果函数在头文件中声明并在源文件中定义，则缺省参数不能在函数声明和定义中同时出现，所以在函数声明的时候给缺省参数， 定义的时候不给缺省参数。
因为如果声明与定义位置同时出现，恰巧两个位置提供的值不同，编译器就无法确定到底该用哪个缺省值。
2.4缺省值必须是常量或者全局变量
这一点显然，给出的缺省值一定是一个固定的值，而不是一个变化的值，否则这个缺省值将毫无意义
三、函数重载
1.什么是函数重载
C++ 的函数重载是指在同一个作用域中，可以定义多个同名但参数不同的函数。编译器会根据调用时的实参类型和数量来决定调用哪个函数。这使得程序更具灵活性和可读性。
或许你已经发现了，在C++中，`std::cout` 不需要像 `printf()` 一样给定参数类型，它能自动判断参数类型输出，这其实就是一种函数重载。
在C语言中，由于不存在函数重载，我们只能通过区分函数名称来处理不同类型的数据
void printInt(int i)
{
printf("%d", i);
}
void printDouble(double f)
{
printf("%f", f);
}
void printString(char s[])
{
printf("%s", s);
}
有了函数重载之后：
void print(int i)
{
cout << "整数: " << i << endl;
}
void print(double f)
{
cout << "浮点数: " << f << endl;
}
void print(string s)
{
cout << "字符串: " << s << endl;
}
int main() {
print(10); // 调用 print(int)
print(3.14); // 调用 print(double)
print("Hello"); // 调用 print(string)
return 0;
}
我们只需定义一个函数名 print，根据不同的参数类型调用不同的实现，代码更简洁易读。
2.构成函数重载的关键点
- 函数名相同：所有重载函数必须有相同的名字。
但注意，函数重载强调在同一个作用域中，所以两个不同命名空间的同名函数不构成函数重载
- 参数不同：重载函数的参数类型、个数或顺序至少有一个不同。
- 返回类型：返回类型可以不同，但仅靠返回类型不同不能构成重载。
