目录

1. 命名空间

1.1 使用命名空间的目的

1.2 命名空间定义 

1.3 命名空间使用

2. 缺省参数

2.1 缺省参数概念

2.2 缺省参数分类

2.3 实际案例

2.4 注意事项 

3. 函数重载

3.1 函数重载概念

3.2 函数重载原理 

4. 引用

4.1 引用的概念

4.2 引用的特性

4.3 使用场景

4.4 常引用(权限变化) 

4.5 引用和指针的区别 

5. 内联函数

5.1 概念

5.2 特性 

5.3 面试题

6. auto

7. 范围for

8. nullptr

---

1. 命名空间

1.1 使用命名空间的目的

在C/C++中，变量、函数和类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多重名冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染。

---

<code>#include <stdio.h>

#include <stdlib.h>

int rand = 10;

int main()

{

printf("%d\n", rand);

return 0;

}

在C语言中，这个整型变量rand和函数rand()名字冲突了，只能其中一个改名字。

1.2 命名空间定义 

定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{} 中即为命名空间的成员。

1. 命名空间中可以定义变量/函数/类型

namespace lyh

{

int rand = 10;

int Add(int left, int right)

{

return left + right;

}

struct Node

{

struct Node* next;

int val;

};

}

使用方法

结构体类型的使用需要特别记忆一下。

int main()

{

printf("%d\n", lyh::rand);

printf("%d\n", lyh::Add(1, 2));

struct lyh::Node node;

return 0;

}

2. 命名空间可以嵌套

namespace N1

{

int a;

int b;

int Add(int left, int right)

{

return left + right;

}

namespace N2

{

int c;

int d;

int Sub(int left, int right)

{

return left - right;

}

}

}

3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。

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

1.3 命名空间使用

namespace lyh

{

int a;

int b;

}

1. 不展开，都要加命名空间名称及作用域限定符。

int main()

{

printf("%d\n", lyh::a);

printf("%d\n", lyh::b);

return 0;

}

2. 部分展开，展开的不用加命名空间名称及作用域限定符。

using lyh::b;

int main()

{

printf("%d\n", lyh::a);

printf("%d\n", b);

return 0;

}

3. 全展开，都不用加命名空间名称及作用域限定符。

using namespace lyh;

int main()

{

printf("%d\n", a);

printf("%d\n", b);

return 0;

}

---

2. 缺省参数

2.1 缺省参数概念

缺省参数是声明或定义函数时为函数的参数指定一个默认值。

在调用该函数时，如果没有指定实参则采用该形参的默认值，否则使用指定的实参。

void Func(int a = 0)

{

cout<<a<<endl;

}

int main()

{

Func(); // 没有传参时，使用参数的默认值，a=0

Func(10); // 传参时，使用指定的实参，a=10

return 0;

}

2.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;

}

int main()

{

Func();

//只能从左往右显示传参。

Func(1);

Func(1, 2);

Func(1, 2, 3);

return 0;

}

2. 半缺省参数

部分参数缺省，缺省参数必须从右往左给出。

void Func(int a, int b = 10, int c = 20)

{

cout<<"a = "<<a<<endl;

cout<<"b = "<<b<<endl;

cout<<"c = "<<c<<endl;

}

int main()

{

Func(1);

Func(1, 2);

Func(1, 2, 3);

return 0;

}

2.3 实际案例

假如有一个场景要你开空间，这里分为两种情况，1.你知道开多少，2.你不知道开多少，这里就可以使用缺省参数。

再开空间之前你需要传入一个关于空间大小的参数，给空间大小参数一个默认值，你知道你就传，你不知道就用默认的。 

2.4 注意事项 

1. 缺省参数不能在函数声明和定义中同时出现。规定声明给即可。

<code> //a.h

void Func(int a = 10);

// a.cpp

void Func(int a = 20)

{}

// 注意：如果声明与定义都有缺省值，恰巧两个缺省值不同，那编译器就无法确定到底该用那个缺省值。

2. 缺省值必须是常量或者全局变量。

3. C语言不支持缺省参数(编译器不支持)。

---

3. 函数重载

3.1 函数重载概念

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

1. 参数类型不同

int Add(int left, int right)

{

return left + right;

}

double Add(double left, double right)

{

return left + right;

}

2. 参数个数不同

void f(int a)

{

...

}

void f(int a, int b)

{

...

}

3. 参数类型顺序不同

void f(int a, char b)

{

...

}

void f(char a, int b)

{

...

}

3.2 函数重载原理 

1. 一个程序要运行起来，需要经历以下几个阶段：预处理、编译、汇编、链接。

2. 编译进行了符号汇总，汇编形成符号表，链接进行了符号表的合并与重定位。

3. C++不像C语言直接把函数名当作符号，而是将函数名修饰后才变成符号。

4. 通过这里就理解了C语言没办法支持重载，因为同名函数没办法区分。而C++是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持了重载。

---

4. 引用

4.1 引用的概念

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

2. 类型& 引用变量名(对象名) = 引用实体。

void Test()

{

int a = 10;

int& ra = a;

}

3. 引用类型必须和引用实体是同种类型的。

4.2 引用的特性

1. 引用在定义时必须初始化。

2. 一个变量可以有多个引用。也可以对引用进行引用。

3. 引用一旦引用了一个实体，就不能引用其他实体。

void Test()

{

int a = 10;

int& ra; //没有初始化

int& ra = a;

int& rra = ra; //可以对引用进行引用

int x = 1;

ra = x; //这里是赋值

}

4.3 使用场景

1. 做参数

void Swap(int& left, int& right)

{

int temp = left;

left = right;

right = temp;

}

2. 做返回值

注意：如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用 引用返回，如果已经还给系统了，则必须使用传值返回。

4.4 常引用(权限变化) 

1. 在引用的过程中，权限可以平移，缩小，但不能放大。

<code>void Test()

{

const int a = 10;

int& ra = a; //这是权限放大，不行。

int b = a; //这是赋值，可以。

const int& ra = a; //这是权限平移。

int x = 10;

const int& rx = x; //这是权限缩小。

}

2. 临时变量具有常性。

void test()

{

int i = 12

double d = i;

double& rd = i; //这句会出错。

const double& rd = i;

}

因为这里会进行类型转换，将i拷贝给类型为double的临时变量，此时是对临时变量起别名。

---

func结束后，返回值会拷贝给一个临时变量，对临时变量起别名要注意常性。

4.5 引用和指针的区别 

在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。

在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。

他们的汇编代码是一样的。

---

引用和指针的不同点:

1. 引用概念上定义一个变量的别名，指针存储一个变量地址。

2. 引用在定义时必须初始化，指针没有要求。

3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体。

4. 没有NULL引用，但有NULL指针。

5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数

6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小。

7. 有多级指针，但是没有多级引用。

8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理。

9. 引用比指针使用起来相对更安全。

---

5. 内联函数

5.1 概念

以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。

如果在上述函数前增加inline关键字将其改成内联函数，在编译期间编译器会用函数体替换函数的调用。

5.2 特性 

1. inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会 用函数体替换函数调用。

缺陷：可能会使目标文件变大。

优势：少了调用开销，提高程序运行效率。

2. inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建 议：将函数规模较小、不是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。

3. 内联说明只是向编译器发出一个请求，编译器可以选择忽略这个请求。

4. inline不能声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址 了，链接就会找不到。

5.3 面试题

宏的优缺点？

优点： 1.没有类型限制。 2.针对频繁调用的小函数不用建立栈帧。

缺点： 1.不能调试宏(因为预编译阶段进行了替换) 。2.容易出错。 3.没有类型安全的检查 。

---

C++有哪些技术替代宏？

1. 常量定义 换用const enum。 2. 短小函数定义 换用内联函数。

---

6. auto

根据右边自动推导左边的类型。

<code>int main()

{

int a = 1;

auto b = a;

auto c = &a;

cout << typeid(b).name() << endl;

cout << typeid(c).name() << endl;

cout << typeid(d).name() << endl;

}

typeid可以查看变量的类型。 

---

auto不能推导的场景

1. auto不能作为函数的参数。

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

---

7. 范围for

void Test()

{

int array[] = { 1, 2, 3, 4, 5 };

for (int* p = array; p < array + sizeof(array)/ sizeof(array[0]); ++p)

{

cout << *p << endl;

}

for(auto e : array)

{

cout << e << " ";

}

cout << endl;

}

依次取数组中的数据赋值给e。

自动判断结束。

自动迭代。

---

8. nullptr

#ifndef NULL

#ifdef __cplusplus

#define NULL 0

#else

#define NULL ((void *)0)

#endif

#endif

 在C++中，NULL被定义为0。所以要表示空指针就使用nullptr。

1. 在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入 的。

2. 在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。

林宇恒/code-cpp (gitee.com)