本章我需要注意的点

1. namespace仅仅是对全局变量做一层“ 隔离 ”，它仍然是全局变量，放在静态区的！！
2. cout的输出结果是，遵循原始赋值。不会保留几位小数（对比double的%lf）
3. 半缺省是函数参数中缺省部分参数，而且缺省规则是必须【从右往左】缺省，且必须连续缺省。
4. 缺省参数不能在函数声明和函数定义中同时出现
5. 推荐在函数声明中出现缺省参数，这样当我们看到函数声明时就知道这个函数是缺省函数了！
6. 函数重载的概念~
7. 返回值不同，不能构成重载！（因为调用的时候，不能区分~）
8. 
   

本节目标

1. C++关键字
2. namespace解决命名冲突问题  --  命名空间
3. C++输入、输出
4. 缺省参数
5. 函数重载
6. 引用
7. 内联函数
8. auto关键字（C++11）
9. 基于范围的for循环（C++11）
10. 指针空值 -- nullptr（C++11）

1. C++关键字(C++98)

C++总计63个关键字，C语言32个关键字
pS:下面我们只是看一下C++有多少关键字， 不对关键字进行具体的讲解。后面学到以后再细讲。

2. namespace解决命名冲突问题（命名空间）

(1)命名空间

在全局作用域中（变量、函数、类），我们可能会面临命名冲突。

使用命名空间的目的是对标识符本地化，以避免命名冲突或名字污染。

namespace关键字就是解决此类问题的！

(2)命名空间的定义

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

域 - 隔离了rand，保护了变量，防止命名污染

 (3)访问命名空间 - （域） 中的变量

域作用限定符 : :

域作用限定符其实在C语言中就有讲到，比如下面的例子。

我们知道变量会优先访问局部变量，再去访问全局变量 。那么如何去直接访问到全局的变量a呢？

—————域作用限定符 : :

注意：: :之前是有一个空格的，表示访问的全局的变量a      : :a    其实不加空格也能访问，还是养成习惯吧(￣▽￣)

 命名空间中，变量/函数/类型等自己想定义的各种全局的内容都可以放，只不过是namespace进行了一层” 隔离 “罢了！

          注意：结构体的域作用限定符放在struct的后面

注意：

namespace仅仅是对全局变量做一层“ 隔离 ”，来防止命名冲突问题。它仍然是全局变量，放在静态区的！！

命名空间可以，允许嵌套定义

相同名称的命名空间 编译器 识别后会 合并 在一起

(4)命名空间的使用

命名空间的使用又三种方式：

(1)每次用到命名空间内的内容时，为其加命名空间名称及作用域限定符

//使用命名空间
//方式1：加命名空间名称及作用域限定符
//缺点：麻烦，每次用到都要重复加     命名空间名称::
namespace qbj
{int rand = 10;int Add(int left, int right){return left + right;}struct Node{struct Node* next;int val;};
}int main()
{printf("%d", qbj::rand);qbj::Add(2, 3);struct qbj::Node next;return 0;
}

 (2)使用using namespace将指定名称的命名空间全部展开(不推荐！因为这样  隔离就失效了！)

(3)使用using 将指定命名空间某个成员展开（✨强推！！）

//使用命名空间
//方式3：使用using 将指定命名空间某个成员展开namespace qbj
{int rand = 10;int Add(int left, int right){return left + right;}struct Node{struct Node* next;int val;};
}using qbj::Node;
int main()
{qbj::rand = 2;qbj::Add(2, 3);struct Node head;return 0;
}

3. C++输入、输出

//输入输出的正常写法（头文件、using namespace std、cout、cin）
#include<iostream>
using namespace std;
int main()
{cout<<"Hello world!!!"<<endl;return 0; 
}//解释：
#include<iostream>//输入输出流
using namespace std;//C++库的实现在一个叫std的命名空间中,将std命名空间全部展开
int main()
{cout<<"Hello world!!!"<<endl;//输出Hello world到控制台，并换行return 0; 
}

说明：

1. 使用cout标准输出(控制台)【流插入】和cin标准输入(键盘)【流提取】时，必须包含< iostream >头文件以及std标准命名空间。

注意：

早期标准库将所有功能在全局域中实现，声明在.h后缀的头文件中，使用时只需包含对应头文件 即可，后来将其实现在std命名空间下，为了和C头文件区分，也为了正确使用命名空间，规定C++头文件不带.h；旧编译器(vc 6.0)中还支持<iostream.h>格式，后续编译器已不支持，因此推荐使用 <iostream>  +  std的方式。

你觉得展开名字为std的命名空间的全部不好？  那么也可以这样：（展开常用的！项目中可能会用到。）

【一般在做oj题不会这样用，即：第一种     using namespace std；  即可】

C++标准库中的大部分东西，都在std这个命名空间里面，所以需要展开

详细说明：

 

cout和printf输出形式区别：

1、cout<<输出的格式不需要指定出变量的数据类型 

2、输出的结果，遵循原始赋值。不会保留几位小数（对比double的%lf）

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>using namespace std;int main()
{// << 流插入cout << "hello world" << endl;//hello worldconst char* str = "hello world";cout << str << endl;//hello worldint i = 1;double d = 1.11;cout << i << d << endl;// 11.11printf("%d%lf", i, d);//11.110000return 0;
}

注意：

什么时候用cout ?   什么时候用printf ？

——————谁方便用谁！  例如：想要指定输出的格式保留小数等...用printf

4. 缺省参数（默认值）

4.1 缺省参数的概念

       缺省参数是声明或定义函数时 ，为函数的参数【指定一个默认值】。在调用该函数时，如果没有指定实参则采用该默认值，否则使用指定的实参。（cpp支持！c没有这个语法）

//缺省参数
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>using namespace std;void Func(int a = 0)
{cout << a << endl;
}int main()
{Func(1);//传，则使用指定参数Func();//不传，则按默认参数return 0;
}

4.2 全缺省 -（所有参数都给了缺省值）

注意：传递的参数如果和函数的参数不一样多，那么传递过去的是从左往右依次给的，不给的则是函数默认值。

所以，你能只传b，或者只传b，c?    不能！！  这是规定死的！！    只能从左往右依次传！    不传的是缺省的，默认值是函数参数。

//缺省参数
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>using namespace std;//全缺省，即：所有参数都给了缺省值
void TestFunc(int a = 10, int b = 20, int c = 30)
{cout << "a = " << a << endl;cout << "b = " << b << endl;cout << "c = " << c << endl << endl;
}//参数传递的顺序，是从左往右传
int main()
{TestFunc();//没有参数传递，所以a,b,c都是默认值10，20，30TestFunc(1);//将1传递给a，b、c是默认值20、30TestFunc(1, 2);//将1传给a，2传给b，c是默认值TestFunc(1, 2, 3);//将1传给a，2传给b，3传给creturn 0;
}

4.3 半缺省 - （缺省部分参数）

半缺省是函数参数中缺省部分参数，而且缺省规则是必须【从右往左】缺省，且必须连续缺省。

//缺省两个参数   【b和c】
void TestFunc(int a , int b = 20, int c = 30)//缺省一个参数  c
void TestFunc(int a , int b , int c = 30 )

注意：半缺省中，缺省参数必须是从右往左缺省，且【必须是连续缺省】！

那么对于缺省一个参数、缺省两个参数，他们对于调用的函数时允许传递的参数有何不同呢？

#include<iostream>using namespace std;//缺省一个参数  c
void TestFunc(int a , int b , int c = 30 )
{cout << "a = " << a << endl;cout << "b = " << b << endl;cout << "c = " << c << endl << endl;
}//缺省一个参数，那么a,b参数是必须给的，缺省参数c可以给也可以不给
int main()
{TestFunc(1, 2);TestFunc(1, 2, 3);return 0;
}

#include<iostream>using namespace std;//缺省两个参数 b c
void TestFunc(int a , int b = 20, int c = 30 )
{cout << "a = " << a << endl;cout << "b = " << b << endl;cout << "c = " << c << endl << endl;
}//缺省两个参数，那么a参数是必须给的，缺省参数b,c可以给也可以不给
int main()
{//TestFunc();//不行！  参数a是必须给的！  因为a不是缺省参数！！TestFunc(1);TestFunc(1, 2);TestFunc(1, 2, 3);return 0;
}

对于缺省参数和半缺省参数，除此之外，还有一点需要注意：

**缺省参数不能在函数声明和函数定义中同时出现

例如：

//a.h
void TestFunc(int a = 10);//a.cpp
void TestFunc(int a = 10)
{}//编译运行后，会报错！

所以，缺省参数要么在函数声明中出现，要么在函数定义中出现，不能同时出现！这是死的规定！  要记住。

推荐在函数声明中出现缺省参数，这样当我们看到函数声明时就知道这个函数是缺省函数了！

例如，推荐如下写法：

推荐！
//a.h
void TestFunc(int a = 10);//a.cpp
void TestFunc(int a)
{}

更不用说，声明和定义中缺省参数不一样的情况了，这样更编译不过去！

//a.h
void TestFunc(int a = 10);//a.cpp
void TestFunc(int a = 20)
{}

因为，如果声明和定义位置同时出现，恰巧两个位置提供的值不同，那么编译器就无法确定到底该用哪一个缺省值。

4.4 总结

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

5. 函数重载（一个“ 词 ”有多重含义）

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

5.1 函数重载的概念

函数重载：

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

           (   注意：C语言不支持同名函数    )

即：同名函数的情况下构成重载的3种情况

1. 参数类型不同
2. 参数个数不同
3. 参数顺序不同

在调用同名的函数时，他们会根据自己的参数类型去选择符合的重载函数，例如：

        1. 参数类型不同

//函数重载 - 1.参数类型不同
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>using namespace std;int Add(int left, int right)
{return left + right;
}double Add(double left, double right)
{return left + right;
}long Add(long left, long right)
{return left + right;
}int main()
{Add(10, 20);Add(10.0, 20.0);Add(10L, 20L);return 0;
}

        2. 参数个数不同

//函数重载 - 1.参数个数不同
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>using namespace std;void f(int a)
{cout << "一个参数" << endl;
}void f()
{cout << "没有参数" << endl;
}int main()
{f();f(1);return 0;
}

         3. 参数顺序不同

//函数重载 - 1.参数顺序不同
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>using namespace std;void f(int a, char b)
{cout << "int类型   char类型" << endl;
}void f(char b,int a)
{cout << "char类型  int类型" << endl;
}int main()
{f('A', 1);f(1, 'A');return 0;
}

注意，上面的三种情况，也可以交叉都涉及。例如，既参数个数不同，也参数类型不同。

思考？       返回值不同能否构成重载？

int Add(int left, int right)
{return left + right;
}double Add(int left, int right)
{return left + right;
}

返回值不同，不能构成重载！

因为你看调用时，参数都符合函数参数，仅仅是函数的返回值不同，那么我去调用哪个函数？？    即：调用的时候不能区分。

要特别注意这个例子：

        1. 缺省值不同，不能构成重载

         2. 构成重载，但是使用时会有问题

5.2 重载的原理（名字修饰）

为什么C++支持函数重载，而C语言不支持函数重载呢？
在C/C++中，一个程序要运行起来，需要经历以下几个阶段：预处理、编译、汇编、链接

---