C++入门（1）

一、C++简介

C++ 是一种静态类型的、编译式的、通用的、大小写敏感的、不规则的编程语言，支持过程化编程、面向对象编程和泛型编程。

C++ 是由 Bjarne Stroustrup （本贾尼）于 1979 年在新泽西州美利山贝尔实验室开始设计开发的。C++ 进一步扩充和完善了 C 语言，最初命名为带类的C，后来在 1983 年更名为 C++。

C++ 是 C 的一个超集，事实上，任何合法的 C 程序都是合法的 C++ 程序。

注意：使用静态类型的编程语言是在编译时执行类型检查，而不是在运行时执行类型检查。

C++是在C语言的基础之上，容纳进去了面向对象的编程思想，并增加了许多有用的库，以及编程范式等，熟悉C语言对C++的学习是有帮助的。

1.C++补充了C语言语法的不足，而且C++对C语言设计不合理的地方进行了优化，比如：作用域方面、io方面、函数方面、指针和宏方面。

二、C++的关键字

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

下图就是C++的关键字表：

 至于这些关键字的作用这里不做具体的介绍，后续遇见会进行介绍。

这些保留字不能作为常量名、变量名或其他标识符名称。

三、命名空间

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

下面我们来写一个C语言程序进行验证一下C语言中的名字冲突。

#include<stdio.h>
#include<stdlib.h>
int rand = 10;

//C语言无法解决这种命名冲突的问题，因此C++提出了namespace来解决这类问题。
int main()
{
	printf("%d\n", rand);
	return 0;
}

下面就是这段代码的执行结果，可以看出C语言对命名冲突这个问题是无法解决的。

上面代码中定义的rand整形变量与stdlib.h文件中的rand产生了冲突导致编译器不知道以哪一个为准。但是在C++中就采用命名空间来解决了这个问题。

3.1命名空间的定义

定义命名空间时，需要用到namespace关键字，后面跟上命名空间的名字（自己取），然后接一对{}就行了，{}内就是命名空间的成员。

下面我们来写个代码演示一下：

namespace name
{
	//命名空间中可以定义变量、函数、类型
	int rand = 10;

	int add(int left, int right)
	{
		return left + right;
	}
	
	struct Node
	{
		struct Node* next;
		int val;
	};
}

这就是命名空间的定义方法，在定义时不仅仅可以定义变量而且可以定义函数和类型。

命名空间是可以嵌套的，下面我来演示一下嵌套的命名空间是如何定义的：

//命名空间的嵌套
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;
		}
	}
}

命名空间的嵌套很简单就是直接在第一个命名空间内在定义一个命名空间。

在同一个工程中可以允许存在多个相同名称的命名空间，编译器最后会合成同一个命名空间中。

一个工程中的相同名称的命名空间会被合并成一个。

下面我给出一个实例代码：

//test.h
namespace N1
{
	int mul(int left, int right)
	{
		return left * right;
	}
}

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

上面的两段代码是在同一个工程中的，但是它们一个在test.h文件中，一个在test.cpp文件中，虽然它们不在同一个文件中但是它们是同名的编译器在最后会把它们给合并成一个命名空间。

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

3.2命名空间的使用

现在我们已经知道了命名空间是怎么定义的了，那么我们就要学习命名空间是如何使用的。

我们先来看这段程序：

#include<iostream>
namespace N1
{
	int a = 0;
	int b = 1;
	int add(int left, int right)
	{
		return left + right;
	}
}

int main()
{
	printf("%d", a);

	return 0;
}

我们看到这里我们已经定义了一个命名空间，但是并没有对a进行特殊的处理，因此这个程序就会报错，我们来看一下这个程序的执行结果：

 可以看到编译器说a是未声明的标识符。这就说明编译器是没有找到a这个变量的，那么这是为什么呢，是因为命名空间中的变量是封装起来的，上边我们说到了命名空间中的所有内容都是局限于这个命名空间内的。因此编译器在进行查找时是不会去命名空间中查找的，编译器的查找顺序就是下面这样：

默认查找顺序：

1. 当前局部域

2. 全局域

注意：默认情况下，不会到命名空间中去找

 命名空间的本质是定义一个域，命名空间域，在命名空间中的变量依旧是全局变量，只是被封存在命名空间，同一个作用域只能定义一个名字的变量，同域内不能同名，不同域可以定义同名的变量、函数或者类型。

局部域和全局域会影响生命周期，命名空间域不会影响生命周期。

命名空间中的变量名若是冲突了，还可以进行嵌套来避免冲突。

了解了上面那些知识后下面我们再来进行介绍命名空间的使用方式，命名空间的使用一共有三种方式：

方法一：加命名空间名称以及作用域限定符

如下所示：

命名空间名称 ：：变量名

 代码实例：

#include<iostream>
namespace N1
{
	int a = 0;
	int b = 1;
	int add(int left, int right)
	{
		return left + right;
	}
}

int main()
{
	printf("%d", N1::a);

	return 0;
}

这样的话就能使用这个变量了，若有嵌套则使用两个或者多个作用域限定符。

如下代码所示：

#include<iostream>
namespace N1
{
	int a = 0;
	int b = 0;
	int add(int left, int right)
	{
		return left + right;
	}

	namespace N2
	{
		int c = 1;
		int d = 2;
		int sub(int left, int right)
		{
			return left - right;
		}
	}
}
int main()
{
	printf("%d", N1::N2::c);

	return 0;
}

上面的代码就是当想要使用命名空间中嵌套的命名空间中的变量时的方法。

方法二：使用using将命名空间中的某个成员引入

如下所示：

using N::b

 这种方法是指定展开命名空间中的某一个。

代码实例：

#include<iostream>
namespace N1
{
	int a = 0;
	int b = 0;
	int add(int left, int right)
	{
		return left + right;
	}

	namespace N2
	{
		int c = 1;
		int d = 2;
		int sub(int left, int right)
		{
			return left - right;
		}
	}
}
using N1::a;
int main()
{
	printf("%d", a);

	return 0;
}

将命名空间中的某个成员引入后，我们就能直接使用这个成员了。

方法三：使用using namespace 命名空间名称 引入

如下所示：

using namespace N;

代码实例：

#include<iostream>
namespace N1
{
	int a = 0;
	int b = 0;
	int add(int left, int right)
	{
		return left + right;
	}

	namespace N2
	{
		int c = 1;
		int d = 2;
		int sub(int left, int right)
		{
			return left - right;
		}
	}
}
using namespace N1;
int main()
{
	printf("%d", a);

	return 0;
}

这种方法是进行展开命名空间，让编译器的默认查找会去展开的命名空间中查找，与包含头文件中的拷贝展开是不同的。

展开命名空间后的编译默认查找如下：

1.当前局部域

2.全局域

3.到展开的命名空间中查找

 不展开的话不会去命名空间中找，展开命名空间后若未指定，则先去全局找，若同时展开两个命名空间，并且这两个命名空间中有同名的就会冲突。因此命名空间不能够随意展开。

三、C++的输入和输出

下面我先写出我们的第一个C++代码，然后再去介绍代码中的输入输出语句：

#include<iostream>
using namespace std;
int main()
{
	cout << "hello world!" << endl;
	return 0;
}

1.这里的using namespace std;是用来展开C++标准库的命名空间，std是C++标准库的命名空间名，C++将标准库的定义实现都放到了这个命名空间中。

2.使用cout标准输出对象（控制台）和 cin标准输入对象（键盘）时，必须包含<iostream>头文件，以及按照命名空间的方法使用std。

3.cout和cin是全局的流对象，endl是特殊的C++符号，表示换行输出，它们都包含在<iostream>头文件中。

4.<<是流插入运算符，>>是流提取运算符。

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

6.实际上cout和cin分别是ostream 和 istream 类型的对象，>> 和 << 也涉及运算符重载等知识，这些等到以后再介绍。

注：早期标准库的全部内容是在全局域中实现的，声明在.h的头文件中，使用时只需要包含对应的头文件即可，后来将其实现在std的命名空间中，为了和C语言的头文件进行区分，也为了正确使用命名空间，于是规定C++的头文件不带.h；旧编译器（vc6.0）中还支持<iostream.h>的格式，后续的编译器都已经不支持了，因此更加推荐使用<iostream> + std 的方式。

下面我们来写一个C++语言的代码实例：

#include<iostream>
using namespace std;
int main()
{
	int a; 
	double b;
	char c;
	//可以自动识别变量类型
	cin >> a;
	cin >> b >> c;
	cout << a << " " << b << " " << c << endl;

	return 0;
}

std命名空间的使用惯例：

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

1.在日常练习中，建议直接using namespace std; 即可，这样比较方便。

2. using namespace std; 展开，标准库就全部暴露出来了，如果我们定义与库重名的类型/对象/函数，就会出现冲突问题，这种问题在日常练习中很少出现，但是在做大型项目中，项目开发的代码较多、规模较大，就很容易出现冲突的问题，所以建议在项目开发中使用 std::cout这种指定命名空间或者使用 using std::cout 这种展开命名空间中的某个类型/对象的方式。

四、缺省参数

4.1缺省参数概念

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

也就是说如果不传入实参，就用缺省值进行初始化形参，缺省参数可以有多个，而且传参的时候，要按照顺序传，不能够跳跃传，也不能够中间空一个然后再传。

缺省参数最好在声明时给。

下面我们来写一个带有缺省参数的代码实例：

#include<iostream>
using namespace std;
void func(int a = 0)
{
	cout << a << endl;
}
int main()
{
	//不传实参
	func();
	//传递实参
	func(10);

	return 0;
}

下图是这段代码的运行截图：

 从上图可以看出，没有传递实参的a的值是用的缺省值，而传递了实参的a的值是实参的值。

4.2缺省参数的分类

全缺省参数：

全缺省参数就是函数的每一个形参都被赋予了缺省值。

下面是一个代码实例：

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

半缺省参数：

半缺省参数就是函数的形参中并不是全部的形参都被赋予了缺省值，而是一部分被赋予了缺省值，并且只能从右往左缺省

下面是代码实例：

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

这种写法就是正确的，从右向左缺省，下面我来演示一个错误的实例，大家看看就行，不要把错误的写法给记住了。

错误实例：

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

这种写法就是错误的，因为这种写法容易造成歧义，当我们传参时，我们前边已经说了，只能顺序传不能跳跃传，因此我们传出的第一个实参会把a给占掉，而c则不会接收到参数。因此，大家要切记不能使用这种缺省方法。

下面我们总结一下需要注意的点：

1. 半缺省参数只能从右往左一次给出，不能间隔着给，也不能从左往右给。

2. 缺省参数不能在函数声明和定义中同时出现，因此一般是在声明中给缺省值。至于原因是因为

如果在声明和定义中同时出现，恰巧两个位置提供的值不同，那么编译器就无法确定到底该用哪一个缺省值。

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

4. C语言不支持缺省参数。

结语：

这篇博客暂时就先写到这里，希望大家能从中学习到一些C++的入门知识或者小细节。到下篇会再接着介绍关于C++入门篇的知识。