C++基础入门——上

C++（c plus plus）是一种计算机高级程序设计语言，由C语言扩展升级而产生。本篇适合对C语言有一定基础的人学习。
C++ 98、C++ 11表示版本，依年份而定。

一、关键字（C++ 98）

C++总计63个关键字，C语言32个关键字(加粗的)

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

二、命名空间

在C/C++中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。

例如：

#include <stdio.h>
#include <stdlib.h>
int main()
{
printf("%d\n", rand);
return 0;
}
int rand = 10;
// 编译后后报错：error C2365: “rand”: 重定义；以前的定义是“函数”

C语言没办法解决类似这样的命名冲突问题，所以C++提出了namespace来解决。

使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题。

2.1 命名空间的定义

namespace 名字
{
// 命名空间中可以定义变量/函数/类型
...
}

namespace关键字，跟命名空间的名字，然后接一对{}即可，{ }中即为命名空间的成员。
例如：

namespace test
{
	int rand = 10;
	int Add(int left, int right)
	{
	return left + right;
	}
	struct Node
	{
		struct Node* next;
		int val;
	};
}

注意事项：

1. 命名空间可以嵌套；
2. 同一个工程中允许存在多个相同名称的命名空间，编译器最后会合成同一个命名空间中；
3. 一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中。
4. 命名空间不可以定义在函数、结构体和类中。

事项1. 例如：在Test1.cpp中定义一个包含N2的名为N1的命名空间

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

命名空间N1中嵌套了命名空间N2。

事项2.
假如在Test2.h中定义了名为N1的命名空间，Test1.cpp中包含了Test2.h，命名空间N1就会合并。

注意：合并后算同一个命名空间，此时如果在Test1.cpp和Test2.h中定义了一个同名的变量，也会报错。

命名空间一般定义在头文件中，也可以将其定义在源文件中，在头文件里声明，以便于在其他文件使用。
在头文件中声明命名空间与在源文件中定义命名空间略有不同。在头文件中，只需使用namespace关键字声明命名空间与其中的具体内容，例如变量、函数、类等，而不需要提供具体的实现代码。

例如：

// 头文件（.h）
namespace MyNamespace {
    int myFunction(); // 函数声明
    extern int myVariable; // 变量声明
    class MyClass; // 类声明

2.2 命名空间使用

命名空间的使用有三种方式:

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

命名空间名称::变量名/函数名等

::是运算符中等级最高的，它分为三种：全局作用域符，类作用域符，命名空间作用域符。作用是为了更明确的调用自己的对象或者函数。

全局作用域其命名空间为空，有时为了区分全局变量与局部变量会用到::。
例如：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

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

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

using 命名空间名称::变量名/函数名等

可以放在命名空间以下的任何地方，相较于上一种方法较为方便。
例如：

#include <stdio.h>
namespace N
{
	int a = 1;
	int b;
}
using N::a;
int main()
{
	//using N::a;
	printf("%d\n", a);
	return 0;
}

• 使用using namespace 命名空间名称 引入

using namespace 命名空间名称

这种方法引入的是命名空间，会将命名空间中的所有标识符引入当前作用域，便捷的同时也带来一些弊端，容易命名冲突，也会把不需要的标识符引入，可读性和可维护性下降。

例如：

#include <stdio.h>
namespace N
{
	int a = 1;
	int Add(int x, int y)
	{
		return x + y;
	}
}
using namespace N;
int main()
{
	printf("%d\n", a);
	printf("%d\n", Add(1, 2));
	return 0;
}

2.3 命名空间std

std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中
在C++中，std命名空间包含了许多常用的函数和类，例如输入输出（iostream）、字符串处理（string）、容器（vector、list、map等）、算法（sort、find等）等等。

对于C++标准库里的内容，除了要包含头文件，还要引入命名空间std才能使用。
例如：

#include <iosteam>
using namespace std;
cout << 1 <<endl;

C++标准库为了与C语言的标准库保持兼容，将C语言的头文件名加上了"c"前缀，使用时不用加上std。
例如，#include <stdio.h> 可以写成 #include <cstdio>，其他与C语言并无不同。

#include <cstdio>
int main()
{
	int a = 1;
	printf("%d",a);
	return 0;
}

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

三、C++输入&输出

cout:标准输出对象(控制台)
cin:标准输入对象(键盘)
endl:表示换行输出

使用它们必须包含< iostream >头文件以及按命名空间使用方法使用std。

<<和>>是输入输出流操作符，也称为流插入运算符和流提取运算符。

下面是一些常见的C++输入输出示例：

#include <iostream>

int main() {
    int num;
    std::cout << "请输入一个整数：";
    std::cin >> num;
    std::cout << "您输入的整数是：" << num << std::endl;
    return 0;
}

特点：
使用C++输入输出更方便，不需要像printf/scanf输入输出时那样手动控制格式。C++的输入输出可以自动识别变量类型。

关于cout、cin、>>和<<目前只要会用就可以了，这里只作简单了解。

四、缺省参数

4.1 概念

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

例如：

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

注意：

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

4.2 缺省参数分类

• 全缺省参数
  顾名思义，参数部分全部是缺省参数。

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

• 半缺省参数
  需要注意的是，半缺省必须是后半(右半)缺省，从后往前不能间隔着缺省。

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

**如果存在函数的声明，声明中给缺省参数，定义中不给。**不能出现同时给的情况。

//a.h
void print(int a,int b = 1,int c = 2);
//a.cpp
void print(int a,int b,int c)
{
	std::cout << a << endl;
	std::cout << b << endl;
	std::cout << c << endl;
}

五、函数重载

5.1 函数重载概念

函数重载：是函数的一种特殊情况，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;
}

如果单单是返回值类型不同，而参数列表相同，并不能构成重载，这会导致编译错误。

5.2 C++支持函数重载的原理——名字修饰（name Mangling）

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

在C/C++中，一个程序要运行起来，需要经历以下几个阶段：预处理、编译、汇编、链接。
采用C语言编译后，将函数名前加上_，例如Add(int a,int b)修饰为_Add，或者函数名不变。

采用C++编译后，以g++为例，g++的函数修饰后变成【_Z+函数长度+函数名+类型首字母】（Add(int a,int b)变为_Z3Addii）

在C++中，函数名字的修饰发生改变，编译器会将函数参
数类型信息添加到修改后的名字中。

这也就是C++能够函数重载的原因。