C++入门

C++关键字

C++总共有63个关键字，c语言有32个关键字
ps：这里只是简单的对比一下c++的关键字和C语言的关键字，不进行过多的讲解。
C++关键字：

asm	do	if	return	try	continue
auto	double	inline	short	typedef	for
bool	dynamic_cast	int	signed	typeid	public
break	else	long	sizeof	typename	throw
case	enum	mutable	static	union	wchar_t
catch	explicit	namespace	static_cast	unsigned	default
char	export	new	struct	using	friend
class	extern	operator	switch	virtual	register
const	false	private	template	void	true
const_cast	float	protected	this	volatile	while
delete	goto	reinterpret_cast

C语言关键字:

auto	short	int	long	float	double
char	struct	union	enum	typedef	const
unsigned	signed	extern	register	static	volatile
void	if	else	switch	case	default
for	do	while	continue	break	goto
sizeof	return

命名空间

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

#include<stdio.h>
#include<stdlib.h>
int rand = 0;
int main()
{
	printf("%d", rand);
	return 0;
}

这里报错的原因是：rand在库函数(stdlib.h)文件中是一个函数，引用该头文件后在全局中定义rand会导致命名冲突。所以这时候我们用关键字namespace来解决该问题。
namespace叫做命名空间，其实也就是相当于一个局部域，因为引用库函数后，就相当于在全局域中存在一个rand函数，所以我们不可以在全局域中定义rand变量，但是我们可以在main()函数这个局部域中定义rand，也可以用namespace创建一个命名空间，然后在该命名空间中定义rand。
例如：

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

int a = 10;
namespace lzy//创建了一个命名空间lzy ，也就是这个局部域的名字为lzy
{
	int a = 0;
	int rand = 5;
}
int main()
{
	printf("%d\n", lzy::rand);
	printf("%d\n", a);
	printf("%d\n", lzy::a);
	printf("%d\n", ::a);

	return 0;
}

命名空间的定义

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

namespace lzy
{
	// 命名空间中可以定义变量/函数/类型
	int a = 0;
	int rand = 5;
	int Add(int left, int right)//函数
    {
        return left + right;
    }
	struct Node//结构体
	{
		struct Node* next;
	 	int val;
	};
}

命名空间也可以嵌套

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

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;
		}
	}
}
namespace N1
{
	int Mul(int left, int right)
	{
		return left * right;
	}
}
int main()
{
	printf("%d\n",N1::Mul(5, 6));
	printf("%d\n", N1::Add(5, 6));
	printf("%d\n", N1::N2::Sub(5, 6));
	return 0;
}

同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。如上面的Mul和Add函数，最后都合成到N1这一个命名空间中。
// ps：一个工程中的test.h和test.cpp中两个N1也会被合并成在一个命名空间中。

命名空间的使用

命名空间的使用有三种方法，前面或多或少提到了一些
1.加命名空间名称及作用域限定符

namespace N
{
	int a=10;
	int b=15;
}
int main()
 {
	 printf("%d\n", N::a);
	 return 0;    
}

2.使用using将命名空间中某个成员引入

namespace N
{
	int a=10;
	int b=15;
}
using N::b;
 int main()
 {
 printf("%d\n", N::a);
 printf("%d\n", b);
 return 0;    
}

这里的using N::b就相当于将命名空间N中的b展开到全局变量中
3.使用using namespace 命名空间名称引入

namespace N
{
	int a=10;
	int b=15;
}
using namespce N;
 int main()
 {
 printf("%d\n", N::a);
 printf("%d\n", b);
 Add(10, 20);
 return 0;    
}

这里using namespace N相当于将命名空间N里面的所有成员展开到全局变量中

C++输入输出

#include<iostream>
 // std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中
using namespace std;//将std中所有的成员展开到全局变量中
 int main()
 {
	 cout<<"Hello world!!!"<<endl;
	 return 0;
}

说明：

1. 使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时，必须包含< iostream >头文件，以及按命名空间使用方法使用std。
2. cout和cin是全局的流对象，endl是特殊的C++符号，表示换行输出，他们都包含在包含< iostream >头文件中。
3. <<是流插入运算符，>>是流提取运算符。
4. 使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动控制格式。C++的输入输出可以自动识别变量类型。
5. 实际上cout和cin分别是ostream和istream类型的对象，>>和<<也涉及运算符重载等知识，这些知识暂时不清楚，所以我们这里只是简单学习他们的使用。后面会学习IO流用法及原理。

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

#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;
 }

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

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

缺省参数

缺省参数概念

缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参。
那么缺省是什么意思呢？下面是知乎大佬的回答，仅参考。
缺省，即系统默认状态，意思与“默认”相同。缺省是一种计算机术语，指在无决策者干预情况下，对于决策或应用软件、计算机程序的系统参数的自动选择。默认选项的设计可以在用户不须决策的状况下就可以基础地使用上述的软件与程序。“缺省”最初来源于计算机英文文档中的单词"default"，"default”有很多意思：违约、缺省、拖欠、默认，由于当时计算机方面的翻译水平不高，于是就把这个词直译成了“缺省”，其实应该取它的引申意思“默认”。
意思是可以理解为默认，那么这里也好理解了，缺省参数也就是默认参数了。

void Func(int a = 0)
 {
	 cout<<a<<endl;
}
int main()
{
	Func(); //没有传参是使用的是函数的默认值    
	Func(10);//传参时，使用指定的参数
	return 0;
 }

缺省参数的分类

全缺省参数

#include<iostream>
using namespace std;
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(10);   // 传参时，使用指定的实参
	return 0;
}

半缺省参数

#include<iostream>
using namespace std;
 //半缺省 -- 从右往左缺省(即给默认参数从右向左赋值)
void Func(int a, int b = 20, int c = 30)
{
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    cout << "c = " << c << endl << endl;
}

int main()
{
    //Func();
    Func(1);
    Func(1,2);
    Func(1,2,3);

    return 0;
}

注意：

1.半缺省参数必须从右往左依次来给出，不能间隔着给
2.缺省参数不能在函数声明和定义中同时出现。这里一般都是只在声明中给出缺省值。

原因：
看下面的代码，这里test.cpp文件中是包含了a.h文件的，在预处理阶段时候会把头文件展开，假如在声明中没有给出缺省值，也就是以下代码：

 //a.h
  void Func(int a, int b);//声明中不给缺省
 
  // a.cpp
  void Func(int a ,int b = 20);//定义中给缺省值
  {}
  
  //test.cpp
  #include<a.h>
  int main()
  {
	Func(1);
	Func(1,2);	
  }

那么在预处理阶段，我们把a.h展开后，告诉编译器我们有这么一个函数，void Func(int a, int b); 这时候编译器会把Func看成全缺省函数，在编译阶段检查语法的时候，Fun(1);这里只传一个变量，这一行代码就会编译不过去。

反而如果在声明中给出缺省值，在定义中不给缺省值的话，如下：

 //a.h
  void Func(int a, int b = 10);//声明给缺省值
  
  // a.cpp
  void Func(int a ,int);//定义不给缺省值
  {}
  
  //test.cpp
  #include<a.h>
  int main()
  {
	Func(1);
	Func(1,2);	
  }

在预处理阶头文件展开后，void Func(int a, int b = 10);会告诉编译器这是一个半缺省函数，在编译过程的时候语法也不会有问题。
如果在声明和定义中都给出缺省值的话，如下：

 //a.h
  void Func(int a = 10);//声明给缺省值
  
  // a.cpp
  void Func(int a = 20)//定义给缺省值
  {}
  
  //test.cpp
  #include<a.h>
  int main()
  {
	Func();
	Func(1);	
  }
  // 注意：如果声明与定义位置同时出现，恰巧两个位置提供的值不同，那编译器就无法确定到底该用那个缺省值。

此时在预处理阶段中，void Func(int a = 10);会告诉编译器Func函数是一个全缺省参数，缺省值为10，编译过程中语法不会有什么问题，因为test.cpp和a.h文件中没有函数Func的定义，在汇编结束后生成的test.o和a.o(a.cpp汇编结束后生成的文件)会发生链接，在链接的时候，编译器识别到Func函数的缺省值有两个不同的值，这时候编译器无法确定用哪个值。

总结：缺省参数不能在函数声明和定义中同时出现。这里只在声明中给出缺省值。

3. 缺省值必须是常量或者全局变量
4. C语言不支持（编译器不支持）

函数重载

重载可以理解为一词多义。

函数重载定义

函数重载：是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这
些同名函数的形参列表(参数个数 或 类型 或 类型顺序)不同，常用来处理实现功能类似数据类型不同的问题。与返回值没有关系。
大致分为以下三种情况:

#include<iostream>
using namespace std;
// 1、参数类型不同
int Add(int left, int right)
{
    cout << "int Add(int left, int right)" << endl;
    return left + right;
}

double Add(double left, double right)
{
    cout << "double Add(double left, double right)" << endl;
    return left + right;
}

// 2、参数个数不同
void f()
{
    cout << "f()" << endl;
}
void f(int a)
{
    cout << "f(int a)" << endl;
}

// 3、参数类型顺序不同
void f(int a, char b)
{
    cout << "f(int a,char b)" << endl;
}

void f(char b, int a)
{
    cout << "f(char b, int a)" << endl;
}

int main()
{
    Add(10, 20);
    Add(10.1, 20.2);
    
    f();
    f(10);
    
    f(10, 'a');
    f('a', 10);
    return 0;
}

为什么C++支持函数重载，而C语言不支持函数重载呢？

在C/C++中，一个程序要运行起来，需要经历以下几个阶段：源码.c->(预处理)->预处理过的.i源文件->(编译)->汇编文件.s->(汇编)->目标文件.o->(链接)->.exe或者a.out可执行程序

1. 实际项目通常是由多个头文件和多个源文件构成，而通过C语言阶段学习的编译链接，我们可以知道，【当Test.cpp中调用了a.cpp中定义的Add函数时】，编译后链接前，Test.o的目标文件中没有Add的函数地址，因为Add是在a.cpp中定义的，所以Add的地址在a.o中。那么怎么办呢？
2. 所以链接阶段就是专门处理这种问题，链接器看到Test.o调用Add，但是没有Add的地址，就会到a.o的符号表中找Add的地址，然后链接到一起。我们看以下代码：

//add.h
#include<iostream>
int Add(int a, int b);

//a.cpp
int Add(int a, int b)
{
	return a + b;
}

//Test.cpp
#include"add.h"
using namespace std;

int main()
{
	int sum = Add(3, 2);
	cout << sum << endl;
	return 0;
}

以上只是一些反汇编代码，汇编代码都是一些二进制的机器码我们看不懂的。

3. 那么链接时，面对Add函数，链接接器会使用哪个名字去找呢？这里每个编译器都有自己的函数名修饰规则。
4. 由于Windows下vs的修饰规则过于复杂，而Linux下g++的修饰规则简单易懂，下面我们使用了g++演示了这个修饰后的名字。
5. 通过下面我们可以看出gcc的函数修饰后名字不变。而g++的函数修饰后变成【_Z+函数长度+函数名+类型首字母】。

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

• 采用C++编译器编译后结果
  
  结论：：在linux下，采用g++编译完成后，函数名字的修饰发生改变，编译器将函数参数类型信息添加到修改后的名字中。

6. 通过这里就理解了C语言没办法支持重载，因为同名函数没办法区分。而C++是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持了重载。
7. 如果两个函数函数名和参数是一样的，返回值不同是不构成重载的，因为调用时编译器没办法区分。
   尽管你给返回值一个命名规则也无法区分，因为在编译阶段编译器就分不出来了，到不了链接的时候，根据地址去找函数定义。例如：

#include<iostream>
using namespace std
int Func();
double Func();
int main()
{
	Func();
	Func();
}