一、命名空间

1.命名空间的作用

有大量的变量、函数和类的名称存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染。namespace关键字的出现就是针对这种问题的。

举例：头文件<stdlib.h>中有rand()函数，使用该头文件后，就不能定义全局的rand变量

所以就需要使用命名空间

2.命名空间的定义

定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员，可以是变量/函数/类型等。

一个命名空间定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中。

• 命名空间中可以定义变量/函数/类型
• 命名空间可以嵌套
• 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中
• 命名空间namespace只能在全局定义

举例：定义并使用命名空间

#include <stdio.h>
#include <stdlib.h>
//定义命名空间
namespace wmx
{
	int rand = 0;
}
int main()
{
	printf("%d\n", wmx::rand);//使用命名空间中的rand
	printf("随机数:%d\n", rand());//使用全局函数rand
	return 0;
}

查找优先级为：函数局部域 > 全局域 > （未展开的）命名空间域。

3.命名空间的使用方法

定义一个命名空间：

namespace N
{
    int a = 0;
    int b = 1;
}

使用方法一：加命名空间名称及作用域限定符(::)

int main()
{
    printf("%d\n", N::a);
    return 0;
}

使用方法二：使用using将命名空间中某个成员引入

using N::b;
int main()
{
    printf("%d\n", N::a);
    printf("%d\n", b);
    return 0；
}

使用方法三：使用 using namespace 命名空间名称 引入

using namespce N;
int main()
{
    printf("%d\n", N::a);
    printf("%d\n", b);
    return 0;
}

二、缺省参数

1.缺省参数概念

缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时，如果没有指定实
参则采用该形参的缺省值，否则使用指定的实参。

void Func(int a = 0)
{
    cout<<a<<endl;
}

int main()
{
    Func(); // 没有传参时，使用参数的默认值
    Func(10); // 传参时，使用指定的实参
    return 0;
}

2.缺省参数的分类

1)全缺省参数

void Func(int a = 10, int b = 20, int c = 30)
{
    cout<<"a = "<<a<<endl;
    cout<<"b = "<<b<<endl;
    cout<<"c = "<<c<<endl;
}

2)半缺省参数

void Func(int a, int b = 10, int c = 20)
{
    cout<<"a = "<<a<<endl;
    cout<<"b = "<<b<<endl;
    cout<<"c = "<<c<<endl;
}

3.缺省参数的说明

• 半缺省参数必须从右往左依次连续给出，不能间隔着给
• 缺省值必须是常量或者全局变量
• 缺省参数不能在函数声明和定义中同时出现（编译器无法确认使用哪个缺省值）
•  C语言不支持（编译器不支持）

错误示范：

//在a.h中
void Func(int a = 10);
//在a.cpp中
void Func(int a = 20)
{}
// 注意：如果生命与定义位置同时出现，恰巧两个位置提供的值不同，那编译器就无法确定到底该用哪个缺省值。

三、函数重载

1.函数重载概念

函数重载：是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这
些同名函数的形参列表(参数个数 或 类型 或 类型顺序)不同，常用来处理实现功能类似数据类型
不同的问题。

注意：

• 当两个函数的函数名相同时，如果两个函数的参数列表相同而返回类型不同，这种情况也不会构成函数重载。因为函数在被调用时，编译器不知道调用哪一个
• 在不同的作用域中，两个函数就算同名，参数列表相同还有返回类型相同，那也是不同的两个函数，不会造成冲突。

举例：

#include<iostream>
using namespace std;

// 1、参数类型不同
void Add(int a, int b)
{
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
}
void Add(double a, double b)
{
    cout << "a = " << a << endl;
    cout << "b = " << b << endl << endl;
}

// 2、参数个数不同
void f()
{
    cout << "f()" << endl;
}
void f(int a)
{
    cout << "f(int a)" << endl << endl;
}

// 3、参数类型顺序不同(等同于参数类型不同)
void f1(int a, char b)
{
    cout << "f(int a,char b)" << endl;
}
void f1(char b, int a)
{
    cout << "f(char b, int a)" << endl << endl;
}

int main()
{
    Add(10, 20);
    Add(10.1, 20.2);

    f();
    f(10);

    f1(10, 'a');
    f1('a', 10);

    return 0;
}

2.C++支持函数重载的原理

为什么C语言不支持函数重载？——>因为在编译过程中函数名修饰的差异

• 在C语言中，函数名直接用于链接，导致无法区分同名函数。
• 在 C++ 中，为了支持函数重载，编译器采用了函数名修饰机制。当编译器遇到一个函数声明时，会根据函数的名称和参数列表生成一个唯一的内部名称，使得不同参数列表的同名函数在链接时可以被正确区分。

总结：C语言没办法支持重载，因为同名函数没办法区分；而C++是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持重载。

注意：如果两个函数函数名和参数是一样的，返回值不同是不构成重载的，因为调用时编译器没办法区分。

例如：

采用C语言编译器：

采用C++编译器：

四、引用

1.引用的概念

引用是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。

使用方式：类型& 引用变量名(对象名) = 引用实体

注意：引用类型必须和引用实体是同种类型的

int a = 10;
int& ra = a;//<====定义引用类型

2.引用的特性

• 引用在定义时必须初始化
• 一个变量可以有多个引用
• 引用一旦引用一个实体，再不能引用其他实体

int a = 10;
// int& ra; // 该条语句编译时会出错
int& ra = a;
int& rra = a;

3.常引用

• 非const变量可以赋值给非const引用（权限的平移）
• const变量不能赋值给非const引用（权限的扩大）
• 非const变量/const变量可以赋值给const引用（权限的缩小/平移）
• 常量只能赋值给const引用（权限的平移）

总结：权限只能缩小

const int a = 10;
//int& ra = a; // 该语句编译时会出错，a为常量
const int& ra = a;

// int& b = 10; // 该语句编译时会出错，b为常量
const int& b = 10;

4.使用场景

1)作参数

void Swap(int& left, int& right)
{
    int temp = left;
    left = right;
    right = temp;
}

2)作返回值

如果函数返回时，如果返回对向为局部变量（出了函数，变量不存在），则必须使用传值返回；返回对象是全局变量/静态局部变量（变量一直存在），则可以使用引用返回。

原因：局部变量是在函数调用时在栈上分配的内存空间。当函数执行完毕后，这个局部变量的内存空间会被回收，引用指向的内存已经无效（与野指针类似），此时返回它的引用就会导致未定义行为。

int& test() 
{
    static int a = 20;//全局变量，可以返回
    return a;
}

5.传值、传引用效率比较

概念：

• 传值：传值是将实参的值复制一份传递给函数的形参。在函数内部对形参的修改不会影响到实参的值。
• 传引用：传引用是将实参的地址传递给函数的形参，形参实际上是实参的一个别名。在函数内部对形参的修改会直接影响到实参的值。

内存使用：

• 传值：需要为形参分配新的内存空间来存储实参的值。对于大型的对象或结构体，可能会消耗较多的内存进行复制操作。
• 传引用：不需要复制实参的值，只需要传递实参的地址，因此不会产生额外的内存开销。

效率：

• 传值：如果实参是大型对象，复制操作可能会比较耗时，特别是在频繁调用函数的情况下，会降低程序的性能。
• 传引用：由于不需要进行复制操作，函数调用的效率更高，特别是对于大型对象或频繁调用的函数，可以显著提高程序的运行速度。

五、内联函数

1.概念

以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开内联函数，不再进行函数调用，提升程序运行的效率。

未使用内联函数：

使用内联函数：

2.特性

• inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用。缺陷：可能会使目标文件变大；优势：少了调用开销，提高程序运行效率。
• inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模较小、不是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。
• inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。

3.补充

宏的优缺点？

    优点：
        1.增强代码的复用性。
        2.提高性能。
    缺点：
        1.不方便调试宏。（因为预编译阶段进行了替换）
        2.导致代码可读性差，可维护性差，容易误用。
        3.没有类型安全的检查 。

C++有哪些技术替代宏？
        1. 常量定义 换用const enum(枚举)
        2. 短小函数定义 换用内联函数

六、 auto关键字(C++11)

1.作用

随着程序越来越复杂，程序中用到的类型也越来越复杂，经常体现在：

• 类型难于拼写
• 含义不明确导致容易出错

在C++中，auto关键字的主要作用是进行自动类型推断。这意味着当使用auto来声明变量时，编译器会根据初始化表达式自动确定该变量的类型。

2.原理

当使用auto自动识别变量类型的时候，可以使用typeid(要识别类型的对象).name() 来获取一个对象的类型信息。所以，等号右边的变量必须是已初始化的。

auto不是一种类型的“声明”，而是一种类型的“占位符”，当编译器根据初始化表达式自动推断出变量的类型时，auto再替换成该类型。

int main()
{
	auto a = 2;
	auto b = 2.2;
	auto c = 3.f;
	auto p = &a;
	cout << typeid(a).name() << endl;//打印int
	cout << typeid(b).name() << endl;//打印double
	cout << typeid(c).name() << endl;//打印float
	cout << typeid(p).name() << endl;//打印int*
}

3.auto的使用

1)auto与指针和引用结合起来使用

用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须
加&

int main()
{
    int x = 10;
    auto a = &x;
    auto* b = &x;
    auto& c = x;
    cout << typeid(a).name() << endl;
    cout << typeid(b).name() << endl;
    cout << typeid(c).name() << endl;
    return 0;
}

2)在同一行定义多个变量

当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错。

auto a = 1, b = 2;
auto c = 3, d = 4.0; // 该行代码会编译失败，因为c和d的初始化表达式类型不同

4.auto不能推导的场景

1)auto不能作为函数的参数

// 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
void TestAuto(auto a)
{}

2)auto不能直接用来声明数组

void TestAuto()
{
    int a[] = {1,2,3};
    auto b[] = {4，5，6};
}

七、auto遍历数组

与迭代器有关

int array[] = { 1, 2, 3, 4, 5 };
for(auto& e : array)
{
    e *= 2;
}

八、C++中空指针的更迭

• 在C语言中，宏定义NULL为0(int类型)，会导致一些问题
• 在C++中，空指针被重新命名为nullptr(void*类型)

这样就避免了将nullptr与整数类型进行比较或赋值，不会出现类型不匹配的问题。