C++基础入门(一)

1.1C++关键字

C++总计63个关键字，C语言32个关键字。

2.1命名空间

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

2.1.1命名空间定义

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

#include <iostream>

int a = 99;
namespace N1   //N1——命名空间的名称
{
	int a = 10;
	int Add(int left, int right)
	{
		return left + right;
	}
}

namespace N2
{
	int a;
	int m;
	namespace N3   //命名空间的嵌套
	{
		int Sub(int left, int right)
		{
			return left - right;
		}
	}
}
namespace N1   //同一个工程内可以存在多个相同名称的命名空间，编译器最后会合成一个命名空间
{                   
	int Mul(int left, int right)
	{
		return left * right;
	}
}   //正因为编译器最后会合成一个命名空间，所以名字相同的两个命名空间内不可以定义名字相同的元素

注意：
1、命名空间内可以定义变量，也可以定义函数
2、命名空间可以嵌套定义
3、同一个工程内可以存在多个名字相同的命名空间，编译器最后会合成到一个命名空间中，也正因此，名字相同的命名空间内不可以再定义名字相同的两个元素
4、namespace不能定义在函数或类的内部

2.1.2命名空间的使用

如上面的代码，我们已经定义了三个命名空间，那么这些命名空间我们该怎么使用呢？

int main()
{
    using N::a;
    printf("%d\n",a);
	printf("%d\n", ::a);   //::为作用域限制符,若前面不加限制，默认使用全局作用域中的变量a
	printf("%d\n", N1::a);   //在作用域限制符前面加上命名空间的名称意为使用该命名空间内定义的变量a
	return 0;
}

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

由上述运行结果可知，命名空间的使用有三种方式：
1、加命名空间名称及作用域限定符
2、使用using关键字将命名空间中成员引入
3、使用using namespace命名空间名称引入

3.1C++的输入&输出

在上面的代码中，输出函数一直用的是printf函数，但在C++中，它也有自己的方式。

#include <iostream>
using namespace std;

int main()
{ 
	cout << "Hello World!!!" << endl;
	return 0;
}

注意：
1、使用cout标准输出（控制台）和cin标准输入（键盘）时，必须包含头文件，以及std标准命名空间
2、使用C++输入输出更加方便，不需要增加格式控制，比如整型–%d,字符–%c …

#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.1缺省参数

4.1.1缺省参数概念

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

void TestFunc(int m = 10)
{
	cout << m << endl;
}

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

4.1.2缺省参数分类

1、全缺省参数——所有参数都有默认值
2、半缺省参数——部分参数具有默认值

void TestFunc1(int a = 10,int b = 20,int c = 30)//全缺省参数
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
}
void TestFunc2(int a, int b = 20, int c = 30)//半缺省参数
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
}
int main()
{
	TestFunc1();
	TestFunc2(10);
}

注意：

1、半缺省参数必须从右往左依次来给出，不能间隔着给
2、缺省参数不能在函数声明和定义中出现
3、缺省值必须是常量或者全局变量

5.1函数重载

5.1.1函数重载的概念

函数重载是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数需要满足的条件有：1、必须处于同一作用域 2、函数名字必须相同 3、函数参数必须不同，满足以上条件即可构成函数重载。

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

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

int main()
{
	cout << Add(10, 20) << endl;
	cout << Add(12.34, 12.56) << endl;
	return 0;
}

5.1.2 名字修饰

看了C++的函数重载，我们会有一个疑问，为什么C语言不支持函数重载呢？
首先，我们都知道，在C/C++中，一个函数要运行起来，需要经历：
预处理，编译，汇编，链接。

1、我们的项目通常是由多个源文件和多个头文件组成，在之前我们知道，在编译阶段，当一个a.cpp调用了b.cpp中定义的Add函数时，在编译后链接前这个阶段，a.o目标文件中是没有Add的地址的，Add的地址在b.o中。
2、所以，链接阶段就是专门处理这种问题链接器看到a.o 调用Add，但没有Add的地址，就会到b.o的符号表中找到Add的地址，然后链接到一起。
3、在链接过程中，面对Add函数，连接器是怎么找的呢，这就是我们要说的名字修饰规则，在不同的编译器是有不同的修饰规则。

我们来看一下Windows下vs的修饰规则，首先我们在写代码时生成一个链接错误就可以看到函数在链接时对于名字的修饰。

首先我们了解一个在Windows下vs的修饰规则：
不管__cdecl，__fastcall还是__stdcall调用方式，函数修饰都是以一个“?”开始，后面紧跟函数的名字，再后面是参数表的开始标识和按照参数类型代号拼出的参数表；
参数表的部分拼写代号如下所示：
X | void
D | char
E | unsigned char
F | short
H | int
I | unsigned int
J | long
K | unsigned long
M | float
N | double
_N | bool
U | struct

以问号？开头，紧跟函数名字，以@开始，中间为函数的调用类型、函数的参数类型以及函数的返回值类型。最后以@Z结束。如上图例，可以自己带入分析一下。

通过分析修饰名发现函数的调用方式，返回值类型，参数个数甚至参数类型都被加入了修饰后的名称，这样连接器和编译器就可以区别同名但不同参数类型或名字空间的函数，不会导致链接时函数多重定义。
各位也可以自己去看一下C语言中的函数名称修饰规则是很简单的，所以C语言中是无法实现函数重载的。

5.1.3 extern “C”

在有一些时候，C++工程中可能需要将某些函数按照C的风格来编译，在函数前加extern ''C",就是告诉编译器，将该函数按照C语言规则来编译。
举个例子(这里用的是函数重载后名字修饰来体现是哪个语言)：

6.1 引用

6.1.1 引用概念

引用不是一个新变量，而是给已经存在的变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用一块内存空间。（概念层面）

实现方式：

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

比如：

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

6.1.2引用特性

1、引用在定义时必须初始化
2、一个变量可以有多种引用
3、引用一旦引用一个实体，便不可再引用其他实体

6.1.3 引用的使用场景

1、做参数

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

2、做返回值

int& Add(int a,int b)
{
	int c = a + b;
	return c;
}

int main()
{
	int& ret = Add(10, 20);
	cout << "Add(10,20) is :" << ret << endl;
	return 0;
}

6.1.4 引用和指针的底层实现

首先说明，在语法概念上，引用是变量的一个别名，没有独立空间，和它的引用实体共用一块内存空间，但在底层实现上，他是必定要有空间的，因为我们都可以看出来，这个引用和指针有点像，在底层，引用就是按照指针方式来实现的。
我们举个例子来具体看一下：


在上述两个图中，我们看到，引用和指针在底层实现时是一样的，所以，引用在底层实现时也是需要空间的。

6.1.5 引用和指针的区别

1、引用在定义时必须要初始化，指针没有要求，只是建议没有具体指向时指向空。
2、引用在初始化引用一个实体后，就不可再引用其他实体，但指针在任何时候可以指向任何一个同类型实体
3、没有NULL引用，但有NULL指针
4、引用的sizeof结果为引用类型的大小，但指针始终是对应地址空间所占字节个数（具体要看所处平台，32–4个字节）
5、两者自加后的意义不同
6、没有多级引用，但有多级指针
7、访问实体方式不同，指针需要显式解引用，引用编译器会自己进行处理
8、引用比指针用起来相对安全