【C++】—— 从 C 到 C++ （上）

一、第一个C++程序

  我们来写一下我们的第一个 C++ 程序：

#include<stdio.h>

int main()
{
	printf("hello world\n");
	return 0;
}
1
2
3
4
5
6
7

  大家是不是很奇怪，这 C++ 怎么一股 C 的味道
  其实 C++ 是兼容 C 语言的。C++ 本来就是在 C 的基础上增加许多东西。
  在写 C++ 代码时，要把文件后缀名改为 $.cpp$，这样 VS编译器 就会调用 C++ 的编译器

  那我们想写一段 C++ 自己的代码怎么写呢？我们来看看。

#include<iostream>
using namespace std;

int main()
{
	cout << "hello world" << endl;
	return 0;
}
1
2
3
4
5
6
7
8

  这段代码可能有些小伙伴看不懂，没关系，看完本篇文章就解惑啦。

  

二、命名空间

2.1、命名的烦恼

  在写 C语言 的代码时，如果我们定义了在全局变量定义了一个变量名为：$rand$，一般来讲是可以正常使用的，但当包含了头文件 <$stdio.h$> 时，就会发现报错。

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

int rand = 10;

int main()
{
	
	printf("%d\n", rand);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11

  这是因为在 C语言 中规定在 同一个域中不能定义同名的东西，因为区分不开（C++也是如此）

  上述代码中头文件 <$stdlib.h$> 包含了了库函数 $rand$ ，现在又在全局域中定义了相同名字的变量，就会发生重定义，编译器无法识别你究竟想调用哪个。

  我们写一个东西，本来写的好好的，但包了一个头文件之后突然就不行了，是不是很不爽

  注：如果将 $rand$ 变量定义在 $main$ 函数中（函数局部域）是不会报错的。因为他们不再同一个域中，而且根据就近原则，当全局域和函数局部域中定义了相同名字的变量时，编译器会直接调用 函数局部域 中定义的那个变量。
  
  不仅如此，在工作中，往往是项目组的成员共同协作。小明和小红各自写了一份代码，都没问题，但两人代码一合并，就出现了大量的重命名。怎么办呢？这时小明只能发挥绅士风度，含泪把自己的代码改了。

  通过上述两个例子，不难发现重命名这事还是很烦的，因此 C++ 中引入了命名空间来解决这个问题
  

2.2、命名空间的定义

• 定义命名空间，需要使用到 $namespace$ 关键字，后面跟命名空间的名字，该名字根据程序员自己的实际需求或喜好定，然后加上一对 { } 即可（ { } 后 不需要 加；），{ } 中定义的成员即为命名空间的成员。命名空间中可以定义变量、函数、类型等
• $namespace$ 本质是定义一个域，这个域跟全局域各自独立，不同的域可以定义同名的变量
• C++ 中有函数局部域，全局域，命名空间域，类域；域影响的是编译时语法查找一个变量 / 函数 / 类型的出处（声明或定义）的逻辑，所以有了域的隔离，名字冲突就解决了。局部域和全局域会影响编译查找逻辑，还会影响变量的生命周期，命名空间域和类域不影响变量的生命周期
• $namespace$ 只能定义在全局，当然他也可以嵌套定义
• 项目工程中多个文件定义的同名 $namespace$，会认为是一个 $namespace$，不会发生冲突
• C++ 标准库都放在⼀个叫 $std$($standard$) 的命名空间中。（C++ 官方也怕和别人冲突，嘿嘿）
    

2.2.1、定义命名空间

  那么现在，我们用命名空间解决上述问题吧

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

namespace ganyu
{
	int rand = 10;
}

int main()
{
	printf("%d\n", rand);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

  

  好消息：能打印了；
  坏消息：不知道打印了个啥

  其实，在这里编译器默认打印的是全局域中的 $rand$。我们将自己定义的 $rand$ 变量放入了命名空间，相当于用一堵墙将其隔开，编译器在默认情况下是不会去命名空间中找的，此时区局域中只有库函数的 $rand$，程序自然能跑起来了（程序打印的是函数指针）。

  那如何让编译器去命名空间中找呢？这时我们就需要认识一个新的操作符：: : 类作用域操作符

使用方法如下：命名空间名 :: 变量/函数/类型

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

namespace ganyu
{
	int rand = 10;
}

int main()
{
	//使用::让编译器区命名空间查找
	printf("%d\n", ganyu::rand);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

  

2.2.2、命名空间的嵌套

  在工作中，往往会分为几个部门。每个部门下面又有若干个项目组，每个项目组又有若干个成员，每个项目组会有一个命名空间，该项目组中每个成员也可以在里面嵌套定义自己的命名空间

namespace ganyu
{
	namespace cw
	{
		struct Node
		{
			int val;
			struct Node* next;
		};
	}

	namespace cq
	{
		int Add(int x, int y)
		{
			return x + y;
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

  
  变量的访问方法如下：

int main()
{
	struct ganyu::cw::Node newnode = { 0 };
	ganyu::cq::Add(10, 20);
	
	return 0;
}
1
2
3
4
5
6
7

  可以看到使用了两次:: 操作符来调用
注：上述结构体的命名空间指定是加在 $Node$ 前而不是 $struct$ 前，因为 $struct$ 只是一个关键字

  

2.2.3、命名空间的同名

  在一个工程项目中，同名的 $namespace$ 不会冲突，他们会认为是一个命名空间。
当然，这个合并并不是真正的合并，而是逻辑上的合并

  即使是自己一个人，一个工程也可能有多个文件，如果每个文件都单独要有一个命名空间，到时自己都记不住。有了这个性质，我们就很方便了

$Stack.h$

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
namespace ganyu
{
	typedef int STDataType;
	typedef struct Stack
	{
		STDataType * a;
		int top;
		int capacity;
	}ST;
	void STInit(ST* ps, int n);
	void STDestroy(ST* ps);
	void STPush(ST* ps, STDataType x);
	void STPop(ST* ps);
	STDataType STTop(ST* ps);
	int STSize(ST* ps);
	bool STEmpty(ST* ps);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

$test.cpp$

#include"Stack.h"
// 全局定义了⼀份单独的Stack
typedef struct Stack
{
	int a[10];
	int top;
}ST;
void STInit(ST* ps) {}
void STPush(ST* ps, int x) {}
int main()
{
	// 调⽤全局的
	ST st1;
	STInit(&st1);
	STPush(&st1, 1);
	STPush(&st1, 2);
	printf("%d\n", sizeof(st1));
	// 调⽤ganyu namespace的
	ganyu::ST st2;
	printf("%d\n", sizeof(st2));
	ganyu::STInit(&st2);
	ganyu::STPush(&st2, 1);
	ganyu::STPush(&st2, 2);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

  

2.3、命名空间的使用

2.3.1、指定命名空间的访问

  在前面的代码中，我们访问命名空间中的成员就是用的指定命名空间的访问。通过命名空间加 ::，我们可以让编译器去指定的命名空间访问我们想要访问的成员。这里就不再举例介绍了。
  

2.3.2、展开命名空间

  通过制定命名空间来访问，好是好，但可能有些小伙伴觉得每次都要使用 :: 操作符，太过繁琐，有没有简便的方法呢？有的，那就是展开命名名间。

  如果说命名空间是建立了一堵墙，保护里面的成员不被默认访问到，那么展开命名空间就是将这堵墙拆掉

命名空间的展开方式如下：$using$ $namespace$ 空间名；

注：虽然定义命名空间后面不用加；，但是展开是要加；

#include<stdio.h>

namespace ganyu
{
	int a = 0;
	int b = 1;
}

// 展开命名空间中全部成员
using namespace ganyu;
int main()
{
	printf("%d\n", a);
	printf("%d\n", b);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

  可见，展开命名空间后就不用再使用::操作符啦

注：这里的展开命名空间和预处理中的展开头文件并不是一个意思

• 展开命名空间可是将命名空间这个域给拆开，可以理解成把这堵墙给推倒
• 展开头文件是指头文件的内容拷贝过来

   但是，凡事有利有弊。既然你把墙给推倒了，那么他就不能起保护作用了，这样又有了变量名相同的风险

  

2.3.3、展开某个成员

  鲁迅先生说过：“中国人向来是喜欢折中的”
  既然全展开和不展开都不行，那好，我们折中一下：展开部分成员

  展开部分成员的方式如下：$using$ 空间名 : : 成员；

#include<stdio.h>
namespace ganyu
{
	int a = 0;
	int b = 1;
}

using ganyu::b;
int main()
{
	printf("%d\n", ganyu::a);
	printf("%d\n", b);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

  

2.2.4、总结

命名空间的三种使用方式：

• 指定命名空间访问：项目中推荐这样方式。（虽然麻烦事麻烦了点，但是基本不会出岔子）
• $using$ 将命名空间中的某个成员展开：项目中经常访问的不存在命名冲突的成员推荐这种方式
• 展开命名空间中的全部成员：项目中不推荐，冲突风险很大，日常小练习为了方便推荐使用

 
注：展开命名空间后再指定其成员时没问题的，当很少这样

 

三、C++的输入&输出

3.1、输入输出的基本概念

  开头我们写了第一个 C++ 程序，不知大家还记不记得

#include<iostream>
using namespace std;

int main()
{
	cout << "hello world" << endl;
	return 0;
}
1
2
3
4
5
6
7
8

  可能有许多第一次接触 C++ 的小伙伴看不懂，没关系，现在我们一起来了解

• 头文件 <$iostream$>：<$iostream$> 是 $Input$ $Output$ $Stream$ 的缩写，即标准输入输出流库，定义了标准输入输出对象。可以把他的功能类比成 C 语言中的 <$stdio.h$>

• $std$::$cout$ 是 ostream 类的对象，它主要面向窄字符（$narrow$ $characters$（$of$ $type$ $char$)）的标准输出流，

  • 类这个概念当前可先理解成结构体，之后的文章我们会进一步讨论
  • $cout$ 中的 $‘c‘$ 其实是 $characters$，表示窄字符的输出；还有一个 $wout$ 表示宽字符的输出

• $std$::$in$ 是 $istream$ 类的对象，它主要面向窄字符的标准输入流

  • 为什么都是字符呢？其实像整型、浮点型等类型只有内存中才有，这是为了内存方便运算；到了文件、网络上就只剩下字符了
  • 其实无论我们用 $printf$ 还是 $cout$，整型其实都是转换成字符再输出的。输出到哪呢？输出到控制台（$console$）、$Linux$ 中叫终端。如果需要输出到其他地方（如文件）则需要其他方式

• << 是流插入运算符，>> 是流提取运算符（当然他们还做位左移/右移）

• $std$::$endl$ 是一个函数（很复杂），流插入输出时，相当于插入一个换行字符加插入缓冲区

  • 注：$cout$、$cin$、$endl$ 都是非常复杂的，它涉及类和对象，运算重载、继承等很多面向对象的知识，我们这里只是极其简单地讲一讲，往后的学习会更加深入了解他

• C++ 的输入输出比 C语言 的更加方便，它不需要像 C语言 那样需要手动指定格式，C++ 的输入输出可以自动识别变量类型（本质是通过函数重载实现的），其实最重要的是 C++ 的流能更好的支持自定义类型对象的输入输出

3.2、C++ 的输出

我们直接上代码来感受一下C++ 的输出

#include<iostream>

int main()
{
	int a = 10;
	float b = 2.5f;
	char c = 't';
	
	std::cout << a << " " << b << " " << c << std::endl;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11

运行结果：

而如果是 C语言 则要手动输入类型：

int main()
{
	int a = 10;
	float b = 2.5f;
	char c = 't';

	//cout << a << " " << b << " " << c << endl;
	printf("%d %f %c\n", a, b, c);
	return 0;
}
1
2
3
4
5
6
7
8
9
10

  在最后流插入时，换行用的是 $endl$ 那能不能像 C语言 一样用 ‘\n’ ,或 “\n” 呢？其实都是可以的，别忘了 C++ 是兼容 C 的
 
注：下列写法是不允许的：

std::cout << a" "  <<  std::endl;
1

  因为流插入操作符是个双目操作符，它只能有两个操作数，上述有三个操作数自然是不行的
  
  可能有小伙伴会问：C++ 能不能在打印浮点数时控制打印精度，控制打印小数点后面多少位呢？

#include<iostream>
int main()
{
	double a = 2.22222222;
	printf("%.2lf\n", a);
	return 0;
}
1
2
3
4
5
6
7

  C++ 的默认识别类型默认是保留小数点后 5 位，要想实现控制精度 C++ 也能做到，但比较麻烦，要单独调用一个函数，这里更推荐大家直接用 C语言 的方法，毕竟 C++ 是兼容 C语言 的。
  
  但凡事有利就有弊，既然 C++ 兼容了 C，那么也要付出一定的代价
  简单提一下：由于兼容了 C，C 和 C++ 有各自的缓冲区，编译器两个都要关注，假如 $printf$ 在 $cout$ 前面，那么就要先刷新 C 的缓冲区才能打印 $cout$ 的内容
  在一些高 IO 需求的地方，如部分大量输入的竞赛题中，可加上一下 3 行代码，可以提高 C++ 的 IO 效率

ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
1
2
3

  

3.3、C++ 的输入

下面我们来试试 C++ 的输入：

#include<iostream>
using namespace std;

int main()
{
	int a = 0;
	float b = 0.0f;
	char c = 0;
	cin >> a >> b >> c;
	cout << a << "\n" << b << '\n' << c << endl;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

• $cout$ / $cin$ / $endl$ 等都属于 <$iostream$>，<$iostream$> 是 C++ 的一个标准库，C++ 的标准库都放在一个叫 $std$（$standard$）的命名空间中，所以要通过命名空间的使用方式去使用他们
• 在日常练习中我们可以$using$ $namespace$ $std$；，实际项目开发中不建议
• 上述列举 C语言 代码时，我们没有包含 <$stdio.h$>，也可以使用 $printf$ 和 $scanf$，这时因为在包含 <$iostream$> 时，间接包含了 <$stdio.h$>。VS 系列编译器是这样的，但其他编译器可能会报错。建议是先不额外包含 <$stdio.h$>，程序报错再包含

  

四、缺省参数

4.1、缺省参数的定义

  缺省参数是函数在声明或定义时为函数参数指定一个缺省值。在调用该函数时，如果该参数没有指定实参则用该形参的缺省值，反之使用指定的实参，缺省参数分为全缺省和半缺省（有些地方吧缺省参数也叫做默认参数）
  

4.2、缺省参数的使用

#include <iostream>
using namespace std;

void Func(int a = 0)
{
	cout << a << endl;
}
1
2
3
4
5
6
7

  缺省参数很简单，只需在定义形参时给形参赋值（缺省值）即可
  

int main()
{
	Func(); // 没有传参时，使⽤参数的默认值
	Func(10); // 传参时，使⽤指定的实参
	return 0;
}
1
2
3
4
5
6

  
运行结果：

 

4.3、全缺省与半缺省

  缺省参数分为全缺省和半缺省：

• 全缺省：全部形参给缺省值
• 半缺省：部分形参给缺省值

4.3.1、全缺省

例子如下：

void Func1(int a = 10, int b = 20, int c = 30)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
}
1
2
3
4
5
6

• C++ 中规定，带缺省参数的函数调用必须从左到右依次给实参，不能跳跃给实参

因此函数调用可以如下：

Func1();
Func1(1);
Func1(1,2);
Func1(1,2,3);
1
2
3
4

但是下面这样是不可以的

Func1(1, ,3);
Func1( ,2,3);
1
2

 

4.3.2、半缺省

• C++ 中规定，半缺省中，必须从右往左依次缺省，不能跳跃给缺省值

如：

void Func2(int a, int b = 10, int c = 20)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl << endl;
}
1
2
3
4
5
6

  上述就是正确的缺省参数的定义方法
  
  下面从左往右和中间跳跃都是错误的

void Func2(int a = 0, int b = 10, int c)；

void Func2(int a, int b = 10, int c)；

void Func2(int a = 0, int b, int c = 20)；
1
2
3
4
5

  同样，半缺省的函数调用必须从左到右依次给实参，不能跳跃给实参

Func2(100);
Func2(100, 200);
Func2(100, 200, 300);
1
2
3

  

4.4、注意事项

  当行数的定义和声明分开时，缺省参数不能在声明和定义中同时出现，规定必须在 函数声明 给缺省值
  
举个栗子：
$Stack.h$ 文件

#include <iostream>
#include <assert.h>
using namespace std;
typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;
void STInit(ST* ps, int n = 4);
1
2
3
4
5
6
7
8
9
10
11

$Stack.cpp$ 文件

#include"Stack.h"
// 缺省参数不能声明和定义同时给
void STInit(ST* ps, int n)
{
	assert(ps && n > 0);
	ps->a = (STDataType*)malloc(n * sizeof(STDataType));
	ps->top = 0;
	ps->capacity = n;
}
1
2
3
4
5
6
7
8
9

  

4.5、缺省参数的应用

  下面我们通过栈来简单了解一下缺省参数的应用：

  在我们初始化一个栈时，一般都是不开空间，或者开少量空间（比如现在开 4 个）。
  现在我们明确知道到要开 1000 个空间。
  想一想，如果没有缺省参数，是不是要不断扩容，差不多要扩容 10 次。要知道每次扩容都是有额外消耗的。
  如果我们使用缺省参数，直接传实参 1000，是不是就是省去这部分消耗。

  当然，这里只是简单举个例子，缺省参数在后面类和对象时会很好用，这点后面再介绍。
  

小甘雨说：做人不要做缺省参数，要做就做显示实参

  

五、函数重载

  在写 C语言 中，大家是否遇到这样的情况：要对整型和浮点型进行加法运算，这时我们就要分别写一个整型的加法函数和浮点型的加法函数。加法函数的函数名我们一般是 $Add$，但是因为 C语言 是不支持函数的重名的，这时我们便只能取两个函数名，比如 $Add$$i$ / $Add$$f$

  在 C++ 中，引入了函数重载，即允许函数名相同。当然，也是有条件的
   C++ 允许统一作用域中出现同名的函数，但是要求这些同名的函数形参不同。
形参的不同可以是形参类型不同，数量不同，顺序不同
  这样 C++ 的调用就表现出了多态行为，使用更加灵活
  

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;
}
1
2
3
4
5
6
7
8
9
10
11

2. 参数个数不同

void f()
{
	cout << "f()" << endl;
} 
void f(int a)
{
	cout << "f(int a)" << endl;
}
1
2
3
4
5
6
7
8

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;
}
1
2
3
4
5
6
7
8

  
注：返回类型不同不符合函数重载，因为在调用时无法将他们区分

//不构成函数重载
void fxx()
{
	;
}

int fxx()
{
 	return 0;
}
1
2
3
4
5
6
7
8
9
10

  

思考：下面两个函数构成重载函数吗？

void f1()
{
	cout << "f()" << endl;
} 
void f1(int a = 10)
{
	cout << "f(int a)" << endl;
}
1
2
3
4
5
6
7
8

  他们是函数重载，满足形参数量不同

  但是，调用他们会存在歧义，编译器会报错，因为当不传递参数时，编译器不知道要调用哪个
  当然，如果给了参数那就没问题，这样就明确调用第二个函数

  同时， 是没有办法区分他们的，除非使用命名空间。但是函数重载的定义是在同一域中，使用了命名空间他们就不是函数重载的概念了。我们只要不要这样写就好了。