【C++从0到1】第一篇：C++入门（上）

---

---

一、 C++关键字

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

二、命名空间

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

#include<stdio.h>

int rand = 0;
int main()
{
	printf("%d\n", rand);
	return 0;
}

这个代码会输出rand的值吗？

我们再包含一个头文件：

#include<stdio.h>
#include<stdlib.h>

int rand = 0;

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

此时我们编译发现就会出错：

这是因为<stdlib.h>里面定义了rand这个函数，我们再定会rand这个名字就会报错。

2.1 命名空间定义

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

#include<stdio.h>
#include<stdlib.h>

namespace ts
{
	int rand = 0;
}


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

此时我们打印rand就不会报错。因为rand是个函数，所以用函数名打印就是这个函数的地址。

那么我们想用我们定义的rand该怎么使用呢？

此时我们这样使用就可以完美避开名字冲突的问题了。
看下面代码：

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

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

int main()
{

	printf("%d\n", ts1::Add(1, 2));
	printf("%d\n", ts2::Add(10, 20));
	return 0;
}

看输出结果：

2. 命名空间可以嵌套
看下面的代码：

namespace N2
{
	int a = 1;
	int b = 2;
	int Add(int left, int right)
	{
		return left + right;
	}

	namespace N3
	{
		int c = 3;
		int d = 4;
		int Sub(int left, int right)
		{
			return left - right;
		}
	}
}

int main()
{
	printf("%d\n", N2::a);
	printf("%d\n", N2::b);
	printf("%d\n", N2::N3::c);
	printf("%d\n", N2::N3::d);
	return 0;
}

也会输出结果：

3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。
这是什么意思呢？

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

2.1 命名空间的使用

命名空间的使用有三种方式：
1.加命名空间名称及作用域限定符::

2.使用using namespace 命名空间名称引入
我们使用ts作为前缀有点麻烦，可不可以不要ts呢？

此时ts里面的定义的所有变量就暴露出来了，就可能会与其他名字发生冲突

namespace ts
{
	int a = 1;
	int b = 2;
	int Add(int left, int right)
	{
		return left + right;
	}
	
}

using namespace ts;

int a = 10;

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

编译就会出错：

3.使用using将命名空间中成员引入

而没有引入的其他成员就不能使用

而在这三种方法里面我们推荐使用的是第一种和第三种方法。因为第二种使用起来虽然很方便，但是极不安全。

三、C++输入&输出

新生婴儿会以自己独特的方式向这个崭新的世界打招呼，C++刚出来后，也算是一个新事物，

那C++是否也应该向这个美好的世界来声问候呢？我们来看下C++是如何来实现问候的。

很多人在学C++的时候就直接写using namespace std; 好像就是必须要这么写，但是不知道为什么要这么写，相信大家看完上面就知道了吧！但是不推荐这么写，平时我们练习的时候可以这样写，方便些，但是在做项目的时候就不能这么写了。
说明：

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

2. 使用C++输入输出更方便，不需增加数据格式控制，比如：整形–%d，字符–%c
   比如：
   
   输入用cin
   
   是不是我们使用起来就更方便了呢？但是我们是不是就不用C语言的输入输出呢？也不是，怎么用方便怎么用比如现在有一个结构体：
   
   我们用C++的输出就很麻烦，我们用C语言的输出看一下：
   
   此时我们发现用C语言反而更方便，所以我们要辩证看待。

四、缺省参数

大家知道什么是备胎吗？

C++中函数的参数也可以配备胎。

4.1 缺省参数概念

缺省参数是声明或定义函数时为函数的参数指定一个默认值。在调用该函数时，如果没有指定实参则采用该默认值，否则使用指定的实参.。
我们在C语言的传参的时候是是不是下面这样呢？

#include<iostream>
using namespace std;

void TestFunc(int a)
{
	cout << a << endl;
}

int main()
{
	TestFunc(1);
	return 0;
}

此时会输出1

但是如果我们可不可以不传参呢？C++是可以的。

4.2 缺省参数分类

全缺省参数
所有参数都给缺省值

半缺省参数
一部分参数给缺省值

注意：

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

比如说我们现在间着给

编译就会出错，所以我们在使用的时候要按照定义来给参数。
定义和声明不能同时出现是什么意思呢？
这是Add函数声明：

这是Add函数定义：

我们此时再调用它，那么会用那个缺省值呢？

编译就会报错！！

五、 函数重载

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

5.1 函数重载概念

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

参数顺序不同：

3.参数顺序不同：

那么大家看一下下面这个代码能编译成功吗？

#include<iostream>
using namespace std;

void f(int a)
{

}

void f(int a = 1)
{

}

int main()
{

	return 0;
}

编译直接就报错了。那么接下来这个代码呢？

#include<iostream>
using namespace std;

void f()
{

}

void f(int a = 1)
{

}

int main()
{

	return 0;
}

编译就不会报错。
下面两个函数属于函数重载吗？

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

通过概念判断很快就能判断出这个不是函数重载，因为函数重载必须是参数顺序、类型或者个数任意一个不同就满足，而不能通过返回值来判断。我们编译也可以验证：

5.2 名字修饰(name Mangling)

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

1. 实际我们的项目通常是由多个头文件和多个源文件构成，而通过我们C语言阶段学习的编译链接，我们可以知道，【当前a.cpp中调用了b.cpp中定义的Add函数时】，编译后链接前，a.o的目标文件中没有Add的函数地址，因为Add是在b.cpp中定义的，所以Add的地址在b.o中。那么怎么办呢？
2. 所以链接阶段就是专门处理这种问题，链接器看到a.o调用Add，但是没有Add的地址，就会到b.o的符号表中找Add的地址，然后链接到一起。
3. 那么链接时，面对Add函数，连接器会使用哪个名字去找呢？这里每个编译器都有自己的函数名修饰规则。
4. 由于Windows下vs的修饰规则过于复杂，而Linux下gcc的修饰规则简单易懂，下面我们使用了gcc演示了这个修饰后的名字。
5. 通过下面我们可以看出gcc的函数修饰后名字不变。而g++的函数修饰后变成【_Z+函数长度+函数名+类型首字母】。

采用C语言编译器编译后结果

结论：在linux下，采用gcc编译完成后，函数名字的修饰没有发生改变
采用C++编译器编译后结果

结论：在linux下，采用g++编译完成后，函数名字的修饰发生改变，编译器将函数参数类型信息添加到修改后的名字中
Windows下名字修饰规则
我们先看一下在Windows下链接不上会怎么报错：

这个链接报错是不是很复杂呢？

对比Linux会发现，windows下C++编译器对函数名字修饰非常诡异，但道理都是一样的。
6. 通过这里就理解了C语言没办法支持重载，因为同名函数没办法区分。而C++是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持了重载
7. 另外我们也理解了，为什么函数重载要求参数不同！而跟返回值没关系。

六、引用

6.1 引用概念

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

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

我们将地址打印出来看一下：

地址是完全一样的，所以此时相当于b是a的别名，它们所代表的同一块空间：

通过上面打印的地址我们也已经知道它们的地址都是一样的。那我们改变值是不是也会发生改变呢？

打印的值都是20。
注意：引用类型必须和引用实体是同种类型的

6.2 引用特性

1. 引用在定义时必须初始化
   
2. 一个变量可以有多个引用
   
   相当于一个人有多个外号，取多个别名是不会影响的。
3. 引用一旦引用一个实体，再不能引用其他实体
   
   我们画图理解：
   

6.3 常引用

这是什么意思呢？

a被const修饰，所以不可以直接被修改，而b作为a的别名，把a的权限扩大了，所以就会报错。我们怎么修改呢？

此时b的权限就和a的权限一样了。那么权限可以缩小吗？

我们再来看一个例子：

这个容易理解：会发生隐式类型转化，d会被截断。所以输出的是1

此时为什么会报错呢？

那么我们怎么更改呢？

加上const修饰就可以了。此时我们就会发现const在任何情况下都可以使用。
建议：使用引用传参，如果函数中不改变参数的值，我们就使用const&,举个例子：

6.4 使用场景

1. 做参数
   我们现在要交换两个数：
   
   而就必须要传地址了：
   
   我们使用引用也可以：
   
   看下面代码：

#include<iostream>
using namespace std;


void Swap(int x, int y)
{
	int tmp = x;
	x = y;
	y = tmp;
}

void Swap(int* x, int* y)
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}

//1. 做参数
void Swap(int& x, int& y)
{
	int tmp = x;
	x = y;
	y = tmp;
}

int main()
{
	int a = 10;
	int b = 20;
	//传值：
	Swap(a, b);
	cout << a << endl;
	cout << b << endl << endl;

	//传址
	Swap(&a, &b);
	cout << a << endl;
	cout << b << endl << endl;

	
}

这三个swap构成函数重载，因为它们类型不一样，但是调用会出错，因为调用不明确，如果是传地址的话，就不会报错，因为接受参数类型是int*；但是如果是传值的话就不知道是调用哪个Swap函数，就会报错。

2. 做返回值
   大家看代码：

#include<iostream>
using namespace std;

//做返回值
int Add(int x, int y)
{
	return x + y;
}

int main()
{
	int a = 10;
	int b = 20;
	int ret = Add(a, b);
	cout << ret << endl;
	return 0;
}

这个输出结果相信大家都能看懂。但是我们从函数栈帧的过程去分析它：

我们发现这个返回的过程就是形成了值拷贝，我们能不能不形成值拷贝呢？

int& Add(int x, int y)
{
	int c = x + y;
	return c;
}

int main()
{
	int a = 10;
	int b = 20;
	int& ret = Add(a, b);
	cout << ret << endl;
	return 0;
}

同样也可以输出。

但是这里有一个问题就是此时Add函数栈帧已经销毁了，已经还给操作系统了，但是还会去访问c，所以就会非法访问内存，所以这个用法是错误的。
举个例子：

此时ret的值就会被改变。我们也画图来分析：

所以ret的值会被改变。再看一个例子：

前面两个我们都能看懂，第三个为什么是这样呢？

这是我的理解！！那么有没有正确的使用方式呢？

这里就是正确的使用方式。
注意：如果函数返回时，出了函数作用域，如果返回对象还未还给系统，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。

6.5 传值、传引用效率比较

以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。
例如：

#include <iostream>
#include <time.h>
using namespace std;

struct A
{
	int a[10000];
};

void TestFunc1(A a)
{
	
}

void TestFunc2(A& a)
{

}

void TestRefAndValue()
{
	A a;
	size_t begin1 = clock();
	for (int i = 0; i < 100000; i++)
	{
		TestFunc1(a);//将a整个结构体传过去，会形成值拷贝
	}
	size_t end1 = clock();

	size_t begin2 = clock();
	for (int i = 0; i < 100000; i++)
	{
		TestFunc2(a);//引用结构体传参，不会形成值拷贝
	}
	size_t end2 = clock();

	cout << "TestFunc1 time:" <<  end1 - begin1 << endl;
	cout << "TestFunc1 time:" << end2 - begin2 << endl;
}

int main()
{
	TestRefAndValue();
	return 0;
}

跑出来的时间就不一样的。传的结构体越大，值拷贝就越大，消耗的时间也越多。
总结：引用的作用主要体现在传参和传返回值
1.引用传参和传返回值，有些场景下面可以提高性能。（大对象+深浅拷贝）
2.引用传参和传返回值，输出型参数和输出型参数返回值。通俗的说，有些场景下面，形参的改变可以改变实参，有些场景下，引用返回，可以改变返回对象。

6.6 引用和指针的区别

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

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

引用和指针的不同点:

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