初识C++

---

---

1、域

1. ‘::’ 域作用限定符

   1. 用于指定域
   2. 在左边什么都没有给的情况下，默认是全局域

2. 分类：全局域、局部域、命名空间域、类域

3. 在一个域中定义同一个关键字，会因为重复而产生错误

4. 编译器搜索原则

   1. 没有指定，先去当前局部域找，再去全局域找
   2. 指定了，那就去指定域找

示例：

int x = 0;

int main() {

	int x = 1;
	cout << x << endl;

	cout << ::x << endl;

	return 0;
}

结果：

​​

2、命名空间

1. 引入：

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

2. 定义：

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

   特点：

   1. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。ps：一个工程中的test.h和上面test.cpp中两个相同的命名空间会被合并成一个
   2. 命名空间中变量、函数、结构体都可以定义
   3. 命名空间中可以继续定义命名空间，但是在使用时需要详细指定

   示例：

   //正常的命名空间定义
   namespace aa {
   	int x = 12;
   
   	void search() {
   		cout << "hello world" << endl;
   	}
   
   	struct Node {
   		struct Node* a;
   		int val;
   	};
   }
   
   //同名命名空间
   namespace aa {
   	int y = 11;
   }
   
   //命名空间嵌套
   namespace bb {
   	int a = 1;
   	void search() {
   		cout << "hello world" << endl;
   	}
   
   	struct Node1 {
   		struct Node1* a;
   		int val;
   	};
   
   	namespace cc {
   		void search() {
   			cout << "hello world" << endl;
   		}
   
   		struct Node2 {
   			struct Node2* a;
   			int val;
   		};
   	}
   }
   

3. 使用：

   1. 加命名空间名称及作用域限定符（指定访问）

      int main() {
      	int x = 1;
      	int b = 6;
      
      	std :: cout << aa :: x << std :: endl;
      	std :: cout << x << std :: endl;
      	std :: cin >> x >> b;
      	std :: cout << x << b << std ::endl;
      
      	return 0;
      }
      

   2. 使用using将命名空间中某个成员引入（部分展开）

      using bb::cc::Node2;
      
      using std::cout;
      using std::endl;
      
      using bb::a;
      

   3. 使用using namespace 命名空间名称引入（全展开）

      全展开，在平常练习中可以用，但在项目中要注意（常用的为using namespace std）

      std 是所有C++的命名空间

      using namespace std;
      
      int main() {
      	int x = 1;
      	int b = 6;
      
      	cout << aa :: x << endl;
      	cout << x << endl;
      	cin >> x >> b;
      	cout << x << b << endl;
      
      	return 0;
      }
      

4. std命名空间的使用惯例：std是C++标准库的命名空间，如何展开std使用更合理呢？

   1. 在日常练习中，建议直接using namespace std即可，这样就很方便。
   2. using namespace std展开，标准库就全部暴露出来了，如果我们定义跟库重名的类型/对象/函数，就存在冲突问题。该问题在日常练习中很少出现，但是项目开发中代码较多、规模较大，就很容易出现。所以建议在项目开发中使用，像std::cout这样使用时指定命名空间 + using std::cout展开常用的库对象/类型等方式。

3、C++的输入&输出

1. 输出：对 << 运算符进行了复用

   1. 作用1：二进制位左移（C中的做法）

   2. 与cout在一起使用时，变为流插入

      1. 流插入会自动识别类型（不需要像printf那样自己写类型）
      2. 相配的endl相当于’\n’

      int main() {
      	int x = 1;
      	int b = 6;
      
      	cout << x << endl;
      	cout << x << b << " " << endl;
      
      	return 0;
      }
      

2. 输入：对>>进行了复用

   1. 二进制位有右移

   2. 与cin在一起使用时：流提取

      1. 流提取也会自动识别类型（作用相当于C中的scanf 并且不用写类型）

      int main() {
      	int x ;
      	int b ;
      
      	cin >> x >> b;
      
      	return 0;
      }
      

3. 说明：

   1. 使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时，必须包含< iostream >头文件，以及按命名空间使用方法使用std。
   2. cout和cin是全局的流对象，endl是特殊的C++符号，表示换行输出（与C 中的\n作用类似），他们都包含在头文件
   3. <<是流插入运算符，>>是流提取运算符。
   4. 使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动控制格式。C++的输入输出可以自动识别变量类型。
   5. 实际上cout和cin分别是ostream和istream类型的对象，>>和< 也涉及运算符重载等知识；这些知识我们我们后续才会学习，所以我们这里只是简单学习他们的使用。后面我们还有有一个章节更深入的学习IO流用法及原理
   6. 注意：早期标准库将所有功能在全局域中实现，声明在.h后缀的头文件中，使用时只需包含对应头文件即可，后来将其实现在std命名空间下，为了和C头文件区分，也为了正确使用命名空间， 规定C++头文件不带.h；

   #include <iostream>
   using namespace std;
   int main()
   {
      int a;
      double b;
      char c;
      
      // 可以自动识别变量的类型
      cin>>a;
      cin>>b>>c;
      
      cout<<a<<endl;
      cout<<b<<" "<<c<<endl;
      return 0;
   }
   
   

4、缺省参数（对C语言的改进语法）

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

2. 缺省参数分类

   1. 全缺省参数

      void Fun(int a = 0, int b = 10, int c = 20) {
      
      	cout << "a = " << a << endl;
      	cout << "b = " << b << endl;
      	cout << "c = " << c << endl;
      
      }
      
      int main() {
      	Fun(1, 2, 3);
      	Fun(1, 2);
      	Fun(1);
      	Fun();
      
      	return 0;
      }
      

   2. 半缺省参数

      void Fun1(int a, int b = 10, int c = 20) {
      
      	cout << "a = " << a << endl;
      	cout << "b = " << b << endl;
      	cout << "c = " << c << endl;
      }
      
      int main() {
      	Fun1(1, 2, 3);
      	Fun1(1, 2);
      	Fun1(1);
      
      	return 0;
      }
      

3. 注意：

   1. 半缺省参数必须从右往左依次来给出，不能间隔着给
   2. 缺省参数不能在函数声明和定义中同时出现
   3. 缺省值必须是常量或者全局变量
   4. C语言不支持（编译器不支持）

5、函数重载

1. 声明和定义、

   1. 函数在调用的时候，先调用的声明；所以缺省参数给值是在声明中给

   2. 编译器步骤：预处理、编译、汇编、

      1. 预处理：展开头文件、条件编译、宏替换、去掉注释
      2. 编译的处理：检查语法，在检查了语法之后会生成汇编代码
      3. 汇编：把汇编代码转变为二进制机器码：
      4. 链接：链接就是把定义所处的文件、与实行文件合并到一起
      5. 函数是为了执行一系列命令，所以总体来说，函数被编译了之后，是一堆指令，所以函数的地址是函数中第一段指令的地址
      6. 想要的到函数的地址需要从定义中获取，函数声明只是一个壳子，其中并没有地址；那么为什么声明就能过呢？那么就要考虑到声明的意义，声明的本质是一个承诺，定义式一个兑现，在链接阶段，我们去寻找定义，找到了就正常运行，找不到就报错
      7. 解析：在预处理阶段过后，头文件就会被展开放入测试文件；我们在定义中加入可以实现，是因为我们在编译阶段会检查语法，这时候就会调用函数声明，只要这里正常，就可以进行下一步

2. 函数重载

   1. 引入：

      自然语言中，一个词可以有多重含义，人们可以通过上下文来判断该词真实的含义，即该词被重载了。 比如：以前有一个笑话，国有两个体育项目大家根本不用看，也不用担心。一个是乒乓球，一个 是男足。前者是“谁也赢不了！”，后者是“谁也赢不了！

   2. 概念：

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

   3. 分类

      1. 参数类型不同

         void Fun1(int a = 5, int b = 10, int c = 20) {
         
         	cout << "a = " << a << endl;
         	cout << "b = " << b << endl;
         	cout << "c = " << c << endl;
         }
         void Fun1(int a = 5, double b = 10.0, int c = 20) {
         
         	cout << "a = " << a << endl;
         	cout << "b = " << b << endl;
         	cout << "c = " << c << endl;
         }
         

      2. 参数个数不同

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

      3. 参数顺序不同

         void Fun1(int a = 5, double b = 10.0) {
         
         	cout << "a = " << a << endl;
         	cout << "b = " << b << endl;
         }
         void Fun1(double a = 5.0, int b = 10) {
         
         	cout << "a = " << a << endl;
         	cout << "b = " << b << endl;
         }
         

   4. C语言不支持，CPP为什么能支持呢？

      1. 如果函数定义与调用在一个文件中，直接调用，可以直接取到函数的地址，但是若果其中有声明，需要在链接的时候去寻找；有些地方使用函数名去寻找函数地址，由于名称相同，所以无法确定究竟是哪一个，所以C中无法实现函数重构
      2. CPP中加入了函数名修饰，只要函数中的参数不同，函数名经过修饰后就会不同，这样就可以找到正确的函数（不同的编译器使用的函数修饰不同；linux是更具函数名去寻找，然后对函数名进行修饰）不需要详细研究每个编译器的规则，仅了解有这个事就行

6、引用

1. 概念

   1. 引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空 间，它和它引用的变量共用同一块内存空间。 （比如：李逵，在家称为"铁牛"，江湖上人称"黑旋风）

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

      int main() {
      	int a = 0;
      	int& b = a;
      	cout << a << endl;
      	cout << b << endl;
      
      	return 0;
      }
      

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

2. 引用的性质

   1. 引用必须初始化

   2. 引用定义后，不能改变指向

   3. 一个变量可以有多个引用，多个别名

3. 其他

   ‍

4. 常引用

   void TestConstRef()
   {
       const int a = 10;
       //int& ra = a;   // 该语句编译时会出错，a为常量
       const int& ra = a;
       // int& b = 10; // 该语句编译时会出错，b为常量
       const int& b = 10;
       double d = 12.34;
       //int& rd = d; // 该语句编译时会出错，类型不同
       const int& rd = d;
   }
   

5. 使用场景

   1. 做参数

      在函数调用时直接使用函数的别名进行接收

      void Swap(int* a, int* b) {
      	int tmp = *a;
      	*a = *b;
      	*b = tmp;
      }
      
      void Swap(int& a, int& b) {
      	int tmp = a;
      	a = b;
      	b = tmp;
      }
      
      int main() {
      	int x = 0,y = 1;
      
      	Swap(&x,&y);
      	Swap(x,y);
      
      	return 0;
      }
      

      注意：形参是调用变量的别名，形参的名称可以和变量名称一样（因为形参与原变量不在同一个域中），但是不建议这样用，容易混淆

      优点：对象比较大，减少拷贝，提高效率

   2. 做返回值

      1. 传值返回，返回的是值的拷贝（存放在寄存器中，再从寄存器中提取），传引用返回，返回的是别名（在函数使用了之后，这个函数栈帧会被清除，属于非法访问）

         int& Add(int a, int b)
         {
         	int c = a + b;
         	return c;
         }
         int main()
         {
         	int& ret = Add(1, 2);
         	Add(3, 4);
         	cout << "Add(1, 2) is :" << ret << endl;
         	return 0;
         }
         

         结果：

         ​​

      2. 结论：返回变量出了函数的作用域，生命周期结束，被销毁，就不能对其进行引用

      3. 什么情况下可以使用引用返回：

         1. 返回变量不被销毁：全局变量/静态变量

      4. 引用做返回值的价值

         1. 修改返回对象
         2. 减少拷贝，提高效率

6. 引用和指针的对比

   1. 从语法上看

      1. 引用时别名，不开空间；指针是地址，需要开空间存储地址
      2. 引用必须初始化，而指针不需要初始化
      3. 引用不可以改变指向，而指针可以
      4. 引用相对安全，不容易出现空引用；但是空指针容易出现（没有NULL引用，但是有NULL指针）
      5. sizseof、++、解引用等方面的区别

   2. 从底层角度看

      1. 语法上引用不开空间，但是引用在底层上是要开辟空间的（就是使用指针来实现的），所以引用在语法与底层上不同（就像老婆饼里没有老婆一样）
      2. 在汇编层面上，没有引用，都是指针，引用在编译之后也转换成了指针

   3. 注意：使用引用的这些场景，指针也可以，但是引用更加适合

7. 其他：C++中与C的不同之处

   1. C++的结构体中可以定义变量、函数
   2. 在使用C++的时候可以直接定义与使用数据，不用再像之前一样传输值
   3. 不用再带前缀了，因为现在是写在一个结构体下的（与类相似），不会有同名的烦恼
   4. C++规定，临时变量具有常性；正常返回的值是一个临时变量，但是返回一个别名就不是临时的了，可以进行读、写
   5. 运算符重载：opeartor[]，在使用了之后，妮子啊使用返回值的时候可以像使用数组一样使用（初步了解）

8. 不同处总结

   1. 引用概念上定义一个变量的别名，指针存储一个变量地址。
   2. 引用在定义时必须初始化，指针没有要求
   3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何 一个同类型实体
   4. 没有NULL引用，但有NULL指针
   5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32 位平台下占4个字节)
   6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
   7. 有多级指针，但是没有多级引用
   8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
   9. 引用比指针使用起来相对更安全

7、内联函数

1. 引言

   1. 如果我们频繁调用一个函数（比如调用函数100万次，建立100万的栈帧）

      1. C语言如何解决？使用宏来进行替换

         1. 容易犯错的点

            1. 宏不是函数
            2. 宏没有分号
            3. 括号控制优先级

         2. 核心点：宏是在预处理阶段进行替换

         3. 宏的缺点：

            1. 语法复杂，坑很多，不容易控制
            2. 不能进行调试
            3. 没哟类型安全的检查

         4. 宏的最大优点：不用建立栈帧（对于会被频繁调用的函数尤其适用）

         5. 示例：

            #define Add(a,b) ((a) + (b))
            
            int main() {
            	cout << Add(1, 2) * 3 << endl;
            
            	return 0;
            }
            

      2. C++中我们如何解决：内联函数：inline

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

   inline int Ad(int a, int b) {
   	return a + b;
   }
   
   int main() {
   	cout << Ad(1, 2) * 3 << endl;
   
   	return 0;
   }
   

3. 优缺点：

   1. 缺点：

      1. 大一点的函数不适合使用内联

         1. ​​
         2. 1001w是子啊1w个调用位置都展开，所以公占用空间位1001w
         3. 1w+100：是因为这1W个调用位置，每次调用的时候，开辟一个栈帧，进入函数，子啊调用完之后，栈帧消除，即使是子啊1万个位置调用，也就只是占用1w+100个位置

4. 特性：

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

5. 其他：怎么防止在多个文件中重定义一个函数？

   1. 声明与定义分离：防止链接冲突（可能会出现重定义）
   2. static：会修饰链接属性：只在当前定义可见（底层就是不会进入符号表）
   3. 内联：内联不会讲函数加入符号表（与静态的思路类似）
   4. 总结：大函数就使用：声明与定义分离，static；小函数就使用：内联
   5. 注：#pragma once 是用于解决一个文件中重复定义了两个或以上的头文件，不能解决头文件和.c文件都定义了的情况

6. 宏的优缺点？

   1. 优点：

      1. 增强代码的复用性。
      2. 提高性能。

   2. 缺点：

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

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

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

8、auto关键字

1. 引入：

   类型别名思考 ：

   随着程序越来越复杂，程序中用到的类型也越来越复杂，经常体现在： 1. 类型难于拼写 2. 含义不明确导致容易出错

   示例：

   #include <string>
   #include <map>
   int main()
   {
    std::map<std::string, std::string> m{ { "apple", "苹果" }, { "orange",
   "橙子" },
      {"pear","梨"} };
    std::map<std::string, std::string>::iterator it = m.begin();
    while (it != m.end())
    {
    //....
    }
    return 0;
   }
   
   

   std::map::iterator 是一个类型，但是该类型太长了，特别容易写错。聪明的同学可能已经想到：可以通过typedef给类型取别名，比如：

   #include <string>
   #include <map>
   typedef std::map<std::string, std::string> Map;
   int main()
   {
    Map m{ { "apple", "苹果" },{ "orange", "橙子" }, {"pear","梨"} };
    Map::iterator it = m.begin();
    while (it != m.end())
    {
    //....
    }
    return 0;
   }
   
   

   使用typedef给类型取别名确实可以简化代码，但是typedef有会遇到新的难题：

   typedef char* pstring;
   int main()
   {
    const pstring p1;    // 编译成功还是失败？
    const pstring* p2;   // 编译成功还是失败？
    return 0;
   }
   
   

   在编程时，常常需要把表达式的值赋值给变量，这就要求在声明变量的时候清楚地知道表达式的 类型。然而有时候要做到这点并非那么容易，因此C++11给auto赋予了新的含义

2. auto作用：自动识别类型（根据右边的值自动推到左边的类型）

   int main() {
   	int a = 15;
   	auto b = a;
   
   	return 0;
   }
   

3. auto的使用细则

4. 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;
          *a = 20;
          *b = 30;
           c = 40;
          return 0;
      }
      

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

      当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译 器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。

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

5. 适用场景

   1. 在类型名很长、很复杂的情况下，使用auto来自动识别类型，可以简化代替

6. auto的弊端

   1. auto在一定程度上会影响可读性（在使用的时候要知道自己使用值的类型，不然类型不确定会出问题）

7. auto不适用的场景

   1. auto不能做参数
   2. auto不适用于做返回值（可以做，但是我不建议做）和python一样，你不能直接看到返回值的类型，在后续使用的的时候会有问题（如果一个函数返回类型究极套娃，那么你会烦死）
   3. auto不能用来定义数组（规定）

9、基于范围的for循环(C++11)

1. 范围for的语法

   在C++98中如果要遍历一个数组，可以按照以下方式进行

   void TestFor()
   {
   int array[] = { 1, 2, 3, 4, 5 };
   for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
        array[i] *= 2;
   for (int* p = array; p < array + sizeof(array)/ sizeof(array[0]); ++p)
        cout << *p << endl;
   }
   

   对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因 此C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范 围内用于迭代的变量，第二部分则表示被迭代的范围。

   int main() {
   	int array[] = { 1,2,3,4,5 };
   
   	//打印数值
   	for (auto e : array) {
   		cout << e << " ";
   	}
   	cout << endl;
   
   	//修改数值
   	for (auto& e : array) {
   		e *= 2;
   	}
   
   	return 0;
   }
   

   注意：与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环

2. 范围for的使用条件

   1. for循环迭代的范围必须是确定的

      对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供 begin和end的方法，begin和end就是for循环迭代的范围。

   2. 迭代的对象要实现++和==的操作。(关于迭代器这个问题，以后会讲，现在提一下，没办法 讲清楚，现在大家了解一下就可以了

10、指针空值nullptr

在良好的C/C++编程习惯中，声明一个变量时最好给该变量一个合适的初始值，否则可能会出现不可预料的错误，比如未初始化的指针。如果一个指针没有合法的指向，我们基本都是按照如下 方式对其进行初始化：

int mian() {
	int* a = NULL;
	int* b = 0;

	return 0;
}

NULL实际是一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码：

#ifndef NULL
#ifdef __cplusplus
#define NULL   0
#else
#define NULL   ((void *)0)
#endif
#endif

可以看到，NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量。不论采取何 种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦，比如:

void f(int)
{
 cout<<"f(int)"<<endl;
}
void f(int*)
{
 cout<<"f(int*)"<<endl;
}
int main()
{
 f(0);
 f(NULL);
 f((int*)NULL);
 return 0;
}

程序本意是想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，因此与程序的 初衷相悖。 ​*

在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void)常量，但是编译器 默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转(void *)0。

注意：

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

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

3. 为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。