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

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

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

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

int rand = 10; //error：“rand”: 重定义；以前的定义是“函数”	
int main()
{
	printf("%d\n", rand);
	return 0;
}

 上述报错的原因，是因为在stdlib.h库里面中已经有rand定义了

要解决该问题，C++祖师爷定出来一个命名空间，是一个域

 2.1 命名空间定义

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

1. 命名空间的普通定义 

namespace GalaxyPokemon //GalaxyPokemon是命名空间的名称
{
    // 命名空间中可以定义变量/函数/类型
    
    //定义变量
    int rand = 2024;    

    //定义函数
    int Add(int left,int right)
    {
        return left + right;
    }

    //定义类型
    struct Pokemon
    {
        struct Pokemon* pikaqiu;
        int val;
    };

}

 2. 命名空间的嵌套定义

namespace GalaxyPokemon1 //定义一个名叫GalaxyPokemon1的命名空间
{
    int a;
    int b;
    int Add(int left,int right)
    {
        return left + right;
    }

 namespace GalaxyPokemon2//嵌套一个名叫GalaxyPokemon2的命名空间
 {
     int c;
     int d;
     int Sub(int left, int right)
     {
         return left - right;
     }
 }

}

3.  同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。但是不允许同一个命名空间有相同名称的命名变量

 ps：一个工程中的test.h和上面test.cpp中两个N1会被合并成一个

// test.cpp
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;
     }
 }
}
//3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。
// ps：一个工程中的test.h和上面test.cpp中两个N1会被合并成一个
// test.h
namespace N1
{
 int Mul(int left, int right)
 {
     return left * right;
 }
}

int main()
{
    printf("%d\n",N1::Add(1,2)); //打印结果：3
    printf("%d\n",N1::N2::Sub(1,2)); //打印结果：-1
    printf("%d\n",N1::Mul(1,2)); //打印结果：2
}

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

 2.2 命名空间的使用

1. 域作用限定符

命名空间名称::命名空间成员

域作用限定符为两个冒号：：其作用是：通知编译器应从作用域限定符左侧的名字所示的作用域中寻找右侧那个名字，即指定访问哪个名字空间的哪个成员。

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

int a = 0; //全局域 

namespace GalaxyPokemon
{
    int a = 1; //命名空间域
}

using namespace GalaxyPokemon; //展开了命名空间

int main()
{
    int a = 2; //局部域

    //默认局部搜索 -> 全局域 -> 展开了命名空间域(暴露到全局) or 指定访问命名空间域
    printf("%d\n", a);//打印结果: 2

    //指定访问命名空间域
    printf("%d\n", GalaxyPokemon::a);//打印结果: 1

    //加了::表示去左边的域里面搜索，::的左边是空白，空白就代表全局域
    printf("%d\n", ::a); //打印结果: 0

    return 0;
}

注意：展开命名空间，就等于暴露到全局，如果此时全局中有与命名空间相同的定义，那么就会报错 

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

int a = 0; //全局域 

namespace GalaxyPokemon
{
    int a = 1; //命名空间域
}

using namespace GalaxyPokemon; //展开了命名空间 = 暴露到全局

int main()
{
    printf("%d\n", a);//打印错误: a不明确

    return 0;
}

 2.加命名空间名称及作用域限定符

符号“::”在C++中叫做作用域限定符，我们通过“命名空间名称::命名空间成员”便可以访问到命名空间中相应的成员。

#include <stdio.h>
namespace GalaxyPokemon
{
    int a;
    double b;
}

int main()
{
    GalaxyPokemon::a = 10;//将命名空间中的成员a赋值为10

    //打印命名空间中的成员a
    printf("%d\n", GalaxyPokemon::a);//打印结果: 10
    return 0;
}

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

 我们还可以通过“using 命名空间名称::命名空间成员”的方式将命名空间中指定的成员引入。这样一来，在该语句之后的代码中就可以直接使用引入的成员变量了。

#include <stdio.h>
namespace GalaxyPokemon
{
	int a;
}

using GalaxyPokemon::a; //将命名空间中的成员a引入

int main()
{
    int a = 10; //将命名空间中的成员a赋值为10
    printf("%d\n", a); //打印命名空间中的成员a

    return 0;    
}

4. 使用using namespace 命名空间名称引入

通过”using namespace 命名空间名称“将命名空间中的全部成员引入。这样一来，在该语句之后的代码中就可以直接使用该命名空间内的全部成员了。

#include <stdio.h>
namespace GalaxyPokemon
{
	int a;
}
using namespace GalaxyPokemon;//将命名空间GalaxyPokemon的所有成员引入
int main()
{
	a = 10;//将命名空间中的成员a赋值为10
	printf("%d\n", a);//打印命名空间中的成员a
	return 0;
}

5. 命名空间嵌套中的访问

有时候我们也需要进行嵌套定义多个相同的变量，可以使用“using 命名空间名称1::命名空间名称2::命名空间成员”进行访问

#include <stdio.h>
namespace GalaxyPokemon1 //定义一个名叫GalaxyPokemon1的命名空间
{
    int a = 0;
    int b;
    int Add(int left,int right)
    {
        return left + right;
    }

 namespace GalaxyPokemon2//嵌套一个名叫GalaxyPokemon2的命名空间
 {
     int a = 1;
     int c;
     int d;
     int Sub(int left, int right)
     {
         return left - right;
     }
 }

}

int main()
{
    printf("%d\n", GalaxyPokemon1::a); //打印结果：0
    printf("%d\n", GalaxyPokemon1::GalaxyPokemon2::a);  //打印结果：1
    printf("%d\n", GalaxyPokemon1::GalaxyPokemon2::Sub(5,3));//打印结果：2
    return 0;    
}

三. C++中的输入输出 

我们在C语言中经常使用到输入和输出，但是在C++中的输入和输出跟C语言的不太一样

C++的输入输出不需要增加数据格式控制，它能自动识别类型

3.1 输出

#include <iostream>

int main()
{
    // std是C++标准库的命名空间名，c++将标准库的定义实现都放到这个命名空间中
    using namespace std;
    //using std cout;//或者也可以这样
    int x = 10;
    double y = 11.1;
    // <<流插入运算符
    cout << "hello world!";//代表“hello world!”流向cout,cont可以理解成控制台
	cout << "hello world!" << endl;//end1代表换行的意思 
    cout << "hello world!" << x << '\n' << endl; //代表“hello world!” x \n都流向控制台
    cout << x << y << endl;//自动识别类型 打印结果 10 11.1
}

3.2 输入 

#include <iostream>

int main()
{
    // std是C++标准库的命名空间名，c++将标准库的定义实现都放到这个命名空间中
    using namespace std;
    //using std cin;
    int x = 10;
    double d = 11.11;

    // >>流提取运算符
    cin >> x >> d;//打印整型x 浮点数d
	return 0;
}

在C语言中有标准输入输出函数scanf和printf，而在C++中有cin标准输入和cout标准输出。在C语言中使用scanf和printf函数，需要包含头文件stdio.h。在C++中使用cin和cout，需要包含头文件iostream以及std标准命名空间。 

四. 缺省参数 

缺省参数 概念

 在声明或定义函数时，为函数的参数指定一个默认值。在调用该函数时，如果没有传参则采用该默认值，传参就使用指定的实参。

#include <iostream>
using namespace std;
void Print(int a = 0)
{
	cout << a << endl;
}
int main()
{
	Print();//没有指定实参，使用参数的默认值（打印0）
	Print(10);//指定了实参，使用指定的实参（打印10）
	return 0;
}

缺省参数 分类

全缺省参数 - 即函数的全部形参都设置为缺省参数

void Print(int a = 10, int b = 20, int c = 30)
{
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
}

int main()
{
    Print();
    Print(1);
    //Print(1,,3);这种方法是错误的。必须从左往右依次给出，不能间隔着给。
    Print(1,2);
    Print(1,2,3);
}

半缺省参数 - 即函数的参数不全为缺省参数

void Print(int a, int b, int c = 30)
{
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
}

int main()
{
    Print();
    Print(1);
    //Print(1,,3);这种方法是错误的。必须从左往右依次给出，不能间隔着给。
    Print(1,2);
    Print(1,2,3);
}

缺省参数 注意事项

1.半缺省参数必须从右往左依次给出，不能间隔着给。 

//错误示例
void Print(int a, int b = 20, int c)
{
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
}

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

//错误示例
//test.h
void Print(int a, int b, int c = 30);
//test.c
void Print(int a, int b, int c = 30)
{
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
}

一般都是声明给，定义不给

3.缺省值必须是常量或者全局变量

//正确示例
int x = 30;//全局变量
void Print(int a, int b = 20, int c = x)
{
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
}