【C++深入浅出】初识C++上篇（关键字，命名空间，输入输出，缺省参数，函数重载）

旧坑未填新坑又起。今天我们又要开启一个新的系列C++深入浅出。振奋人心的C++学习终于来了在本系列中你能感受到C++相比C语言特有的魅力尽管学习的过程中可能会充满坎坷但风雨之后仰望天空即使没有彩虹也会是睛空。学完C++后你甚至可以在C++中用短短几行代码就搞定C语言几十上百行的代码是不是很神奇这还只是C++其中的一个强大之处哦。所以不要恐惧让我们一起怀着激动的心情打开C++的大门吧

二. 什么是C++

C语言是结构化和模块化的语言适合处理较小规模的程序。对于复杂的问题规模较大的
程序需要高度的抽象和建模时C语言则不合适。为了解决软件危机 20世纪80年代计算机
界提出了OOP(object oriented programming面向对象)思想支持面向对象的程序设计语言
应运而生。
1982年Bjarne Stroustrup博士在C语言的基础上引入并扩充了面向对象的概念发明了一
种新的程序语言。为了表达该语言与C语言的渊源关系命名为C++。因此C++是基于C语言而
产生的它既可以进行C语言的过程化程序设计(C++兼容C语言)又可以进行以抽象数据类型为特点的基于对象的程序设计还可以进行面向对象的程序设计。

三. C++关键字初探

在C语言的学习过程中我们前前后后一共学到了32个关键字。而C++作为C语言的扩展一共多达63个关键字如下表所示

注这里稍微知道一下有这些关键字即可后面学到具体应用时再进行细讲

四. 命名空间

4.1 为什么要引入命名空间

在写C语言代码时你是否写过类似这样的代码

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

int rand = 0;
int main()
{
	printf("%d", rand);
	return 0;
}

当你Ctrl+F5兴冲冲的编译运行时发现不解情的编译器报出了重定义的错误

由于预处理阶段会将头文件进行展开而在我们的stdlib.h头文件中存在着名为rand的随机数函数而C语言是不允许在相同作用域下定义多个同名符号的因此会报出重定义的错误。
#include<stdio.h>
#include<stdlib.h>

int rand = 0; //前面已经将rand全局定义为函数这里又定义为全局变量顾重定义
int main()
{
	int rand = 0; //这里rand是局部变量作用域不同局部优先因此不会报错
	rand(); //由于rand是局部优先这里的rand是个局部变量顾无法作为函数使用报错
	printf("%d", rand);
	return 0;
}
在上面的代码中我们无论将rand定义成全局变量还是局部变量都无法实现我们想要的效果那怎么办呢将rand变量的名字换一个呗得不到就不要强求啦

但是在C++中新增了命名空间来对标识符的名称进行本地化以避免命名冲突或名字污染上面的问题就被很好的解决了。

所以说努力拓展提升自己能力够了自然也就得到了

4.2 命名空间的定义

定义命名空间需要使用到namespace关键字后面跟命名空间的名字然后接一对{}即可。{}中的内容即为命名空间的成员。命名空间内的成员可以是变量也可以是函数、类型甚至可以是另一个命名空间。

namespace Dream //namespace关键字 + 命名空间名称
{
	//命名空间内定义变量
	int a;
	int b = 10;

	//命名空间内定义函数
	int add(int x,int y)
	{
		return x + y;
	}

	//命名空间内定义类型
	struct Stack
	{
		int* a;
		int top;
		int capacity;
	};

	//命名空间嵌套定义
	namespace other
	{
		int a;
		int b = 10;
	}

}

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

此外如果我们在同一工程中定义了两个相同名称的命名空间(无论在哪个文件)编译器最终会合并到同一个命名空间中

//test1.cpp
namespace Dream
{
	int a = 5;
	int b = 10;
}

//test2.cpp
namespace Dream
{
	int Add(int x, int y)
	{
		return x + y;
	}
}

//上面两个同名命名空间编译器最终会进行合并结果如下
namespace Dream
{
	int a = 5;
	int b = 10;

	int Add(int x, int y)
	{
		return x + y;
	}
}

4.3 命名空间使用

那么定义了命名空间后我们要如何使用它呢如果我们直接对命名空间的成员进行访问编译器会报错

#include<stdio.h>
namespace Dream
{
	int b = 10;
}
int main()
{
	printf("%d", b); //报错b只在Dream作用域内有效
	return 0;
}

我们一般有一下三种使用方法

1、变量名前加命名空间名称及作用域限定符

namespace Dream
{
	int b = 10;
	namespace other
	{
		int b = 5;
	}
}

int main()
{
	printf("%d", Dream::b); //表示Dream命名空间内的b即输出10
    printf("%d", Dream::other::b); //表示Dream命名空间内的other命名空间内的b即输出5
	return 0;
}

分析两个变量b虽然名称相同但被划分到了两个命名空间中作用域不同因此不会出现重定义的问题。并且通过在前面加上对应的命名空间我们可以实现对这两个变量b的访问。

2、使用using将命名空间中某个成员展开

但是如果命名空间中的某个变量需要在程序中频繁的进行使用每次都要在前面加上命名空间未免显得过于繁琐因此C++还允许我们使用using关键字将命名空间中某个成员展开

namespace Dream
{
	int a = 5;
	int b = 10;
}

using Dream::a;

//int a = 10;  //由于上方将变量a展开a的作用域相当于全局这里如果再定义a会重定义
int main()
{
	a += 10; //引入了a顾不需要再前面加上命名空间
	printf("%d\n", a);
	printf("%d", Dream::b); //而变量b没有展开故需加上命名空间
	return 0;
}

3、使用using naespace 将整个命名空间展开

当然如果你愿意的话你也可以将整个命名空间展开这样整个命名空间的东西都将暴露在全局。具体方式如下

namespace Dream
{
	int a = 5;
	int b = 10;
}

using namespace Dream; //展开后使用命名空间内的变量就无需再加前缀
int main()
{
	a += 10;
	printf("%d\n", a);
	printf("%d", b);
	return 0;
}

下面我们再来看看许多C++程序中经常出现的写法就很清楚了

#include<iostream>
using namespace std;
int main()
{
	return 0;
}

第一条语句的作用是包含输入输出流下面我们会进行说明这里我们可以暂且将理解为C语言的#include<stdio.h>
第二条语句是不是很熟悉啦没错就是用来展开命名空间std的。std的英文全拼是Standard即标准的意思。C++标准程序库中的所有标识符都被定义在这个命名空间中。顾这里将整个命名空间引入是为了后续更方便的使用C++标准程序库的标识符如函数、类型等等。

但是虽然方便但在实际工程中并不建议直接将整个命名空间展开。原因是在大规模工程中定义的变量太多可能会出现定义的变量名与std命名空间的标识符出现重复的情况此时如果将std全部展开就会出现重定义的BUG。

故比起将命名空间全部展开我们更推荐使用第一种或者第二种使用方式。

五. C++的输入输出

在学习C语言时我们写的第一个代码就是hello world那么在我们第一次接触C++时是不是也应该使用C++对美好的世界打个招呼呢我们来试试C++是怎么实现输入输出的吧

#include<iostream>
using namespace std; //展开std命名空间
int main()
{
	cout << "hello world!!!" << endl; //打印输出
	return 0;
}

下面我们来分析分析上面的代码

1、使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时必须包含<iostream>头文件
以及按命名空间使用方法使用std。是的iostream也是一个头文件噢。

2、cout和cin是全局的流对象它们分别是ostream和istream类型的对象。而endl是特殊的C++符号表示换行输出他们都包含在包含在<iostream>头文件中。

3、<<是流插入运算符>>是流提取运算符。它们是不是和我们C语言学到的左移和右移一模一样是的这实际上是一种运算符重载我们后续会提到。

4、使用C++输入输出更方便不需要像printf/scanf输入输出时那样需要手动控制格式即%d、%f等等。C++的输入输出可以自动识别变量类型。

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

六. 缺省参数

6.1 缺省参数的概念

缺省参数是声明或定义函数时为函数的参数指定一个缺省值(默认值)。在调用该函数时如果没有指定实参则采用该形参的缺省值否则使用指定的实参。具体形式如下

#include<iostream>
using namespace std;

void Func(int a = 0) //给定缺省值0
{
	cout << a << endl;
}

int main()
{
	Func(); // 没有传参时使用参数的默认值
	Func(10); // 传参时使用指定的实参
	return 0;
}

6.2 缺省参数的分类

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

全缺省参数

即所以参数都带有缺省值

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); 
    Func(20,30,40); 
	return 0;
}

半缺省参数

即部分参数都带有缺省值

void Func(int a, int b = 10, int c = 20) //除了a其余参数都有缺省值
{
    cout<<"a = "<<a<<endl;
    cout<<"b = "<<b<<endl;
    cout<<"c = "<<c<<endl;
}

int main()
{
	Func();  //错误调用第一个参数没有缺省值需要传参
	Func(10); //第一个参数传入10其余参数用缺省值
    Func(20,30,40); //全部用指定的实参
	return 0;
}

注意事项

规定半缺省参数必须从右往左依次给出不能间隔着给。示例如下

//错误写法必须从右往左不间断
void Func(int a = 10, int b, int c) {};
void Func(int a = 10, int b = 20, int c) {};
void Func(int a = 10, int b, int c = 30) {};

//正确写法
void Func(int a, int b, int c = 30) {};
void Func(int a, int b = 20, int c = 30) {};

缺省参数不能在函数声明和定义中同时出现。其目的是为了防止我们在声明和定义中给出了不同的缺省值从而导致歧义。
```
//错误的写法
//test.h
void Func(int a = 10);
// a
test.cpp
void Func(int a = 20)
{}
```
缺省值必须是常量或者全局变量
C语言不支持带缺省参数的函数编译器不支持

七. 函数重载

7.1 函数重载的概念

函数重载它是一种函数的特殊情况。C++允许在同一作用域中声明几个功能类似的同名函数这
些同名函数的形参列表(参数个数或类型或类型顺序)不同常用来处理实现功能类似、数据类型不同的问题。

假设我们要写一个Add函数实现两个整型以及两个浮点型的相加在C语言中我们应该这么写

//C语言写法
int iAdd(int x, int y)
{
	return x + y;
}
double dAdd(double x, double y)
{
	return x + y;
}
int main()
{
	iAdd(1, 2);
	dAdd(1.0, 2.0);
	return 0;
}

由于实参的类型不同我们需要写两个Add函数分别实现整形和浮点型的相加并且为了避免重定义两个函数名必须不同难道这不觉得很别扭吗

而C++引入了函数重载我们就能很舒服的使用相同名称来定义这两个参数不同的函数

//C++写法两个Add函数构成函数重载
int Add(int x, int y)
{
	return x + y;
}

double Add(double x, double y)
{
	return x + y;
}

int main()
{
	Add(1, 2);
	Add(1.0, 2.0);
	return 0;
}

7.2 函数重载的条件

C++构成函数重载的条件是形参列表必须不同。形参列表不同分为以下三种

1、参数个数不同

#include<iostream>
using namespace std;
//2、参数个数不同
void Fun(int x)
{
	cout << "void Fun(int x)" << endl;
}
void Fun()
{
	cout << "void Fun()" << endl;
}

int main()
{
	Fun(1); //调用第一个
	Fun(); //调用第二个
}

2、参数类型不同

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

int main()
{
	Add(1, 2); //调用第一个
	Add(1.0, 2.0); //调用第二个
}

3、参数顺序不同

#include<iostream>
using namespace std;
//3、参数顺序不同
void Fun(int x , double y)
{
	cout << "void Fun(int x , double y)" << endl;
}
void Fun(double x, int y)
{
	cout << "void Fun(double x, int y)" << endl;
}

int main()
{
	Fun(1,2.0); //调用第一个
	Fun(2.0,1); //调用第二个
}

注意是参数类型的顺序不同而不是变量名顺序不同即以下写法不构成函数重载
//变量名顺序不同不构成函数重载形参的名称只是标识本质上还是同一个函数
void Fun(int x , double y){};
void Fun(int y , double x){};

4、缺省函数的重载

此外带缺省参数的函数也可以构成函数重载编译并不会报错但使用上可能会出现一些很尴尬的问题举例如下

#include<iostream>
using namespace std;
//4、缺省函数的重载
void Fun(int x, double y = 1.0)
{
	cout << "void Fun(int x , double y = 1.0 )" << endl;
}
void Fun(int x)
{
	cout << "void Fun(int x)" << endl;
}
int main()
{
	Fun(1, 2.0); //这里会调用第一个函数没问题
	Fun(1); //此时既可以调用第一个函数也可以调用第二个函数存在歧义会报错
}

由于缺省函数的重载很容易引发歧义顾我们一般不也会这么写

7.3 C++支持函数重载的原因

可能会有很多小伙伴会疑惑为什么C++支持函数重载而C语言不支持函数重载呢、

在C/C++中一个程序要运行起来需要经历以下几个阶段预处理、编译、汇编、链接

我们发现每个.c文件都会生成属于自己的符号表。main.c文件中sum函数只是声明故在符号表中并没有sum函数的地址。而sum.c文件中的sum函数是定义故在符号表中存在着sum函数的地址。当链接器进行链接时就会将两张符号表进行合并此时符号表中既有main函数的地址也有sum函数的地址程序便可以正常运行。

但是如果两个文件中的sum函数都是定义呢如下

由于两个符号表中的sum函数都是有效地址进行符号表合并后符号表就会出现上面的相同符号不同地址的情况会引发符号表的歧义此时我们就不知道该去哪个地方找sum函数了会报重定义的错误。

这就是为什么C语言不能定义同名函数的原因重定义会引发符号表的歧义。

那就有人会想C语言不行那凭什么放到C++就可以呢搞特殊

首先要说明的是上面的两个Add函数放到C++依然不构成函数重载因为它们的类型相同。那C++为什么类型不同就允许同名函数的存在呢这是因为C++引入了函数名修饰规则函数在符号表中除了名称还一并将参数类型代入修饰。

不同的编译器下的函数名修饰规则可能有所不同由于VS的函数名修饰规则过于复杂下面我们采用Linux下的g++来进行演示

源代码清单

int Add(int x,int y)
{
    return x + y;
}

double Add(double x,double y)
{
    return x + y;
}

int main()
{
    return 0;
}

采用gcc编译(C语言)

为了正确进行编译将第一个Add函数改为Add1第二个改为Add2。编译后查看汇编代码如下

采用g++编译(C++)

Linux系统下的g++编译器将函数修饰后变成【_Z+函数长度+函数名+类型首字母】的形式形参的个数、顺序以及类型不同都会使得修饰后的函数名不同

总结提炼

在linux下采用gcc编译完成后函数名字没有发生改变。
在linux下采用g++编译完成后函数名字的修饰发生改变编译器将函数参数类型信息添加到修改后的名字中。
C语言没办法支持重载是因为同名函数没办法区分。而C++是通过函数修饰规则来区分只要参数不同修饰出来的名字就不一样顾支持重载。
如果两个函数仅仅是返回值不同是不构成重载的因为调用时编译器没办法区分。