【C++】C++入门

小羊oi！

已于 2023-09-09 19:58:06 修改

阅读量2.6k

点赞数 16

分类专栏：小阳c++专栏文章标签： c++

于 2023-09-06 21:30:17 首次发布

本文链接：https://blog.csdn.net/weixin_62985813/article/details/132699633

版权

小阳c++专栏专栏收录该内容

18 篇文章 4 订阅

订阅专栏

2.4而且c++允许定义存在多个名字相同的命名空间，编译器会合并在同一个命名空间当中

3、命名空间的使用

3.1命名空间名称加作用域限定符：

3.2使用 using 将命名空间中某个成员引入：（部分展开，展开常用的，保密性强）

3.3使用 using namespace 将命名空间名称引入：（全部展开，有风险）

2.3面试题目：为什么返回值不同不能进行重载？？

一、第一个C++程序

#include <iostream>

using namespace std;

int main()
{
	cout << "hello world" << endl;
	return 0;
}

我们知道，C++是对C语言的完善以及再发展，所以C++中的很多东西是与C语言十分修饰的，并且C++也是兼容C的，也就是说，我们在 .cpp 文件中编写、运行 .c 程序，编译器也不会报错；那么类比过来，我们也就不难猜到，上述程序中的 iostream 是头文件，cout 是输出函数，对我们来说，唯一感到不解和陌生就只有 using namespace std; 这条语句，要理解这条语句，我们需要学习C++的命名空间相关知识。

二、命名空间

1、什么是命名空间

在C语言中，如果我们的程序中包含某一头文件，那么我们就不能定义与其同名的全局变量，否则编译器就会报错

但是C语言头文件中的库函数是非常多的，我们在编写大型项目的时候就难免可能会定义与库函数同名的变量，从而造成命名冲突；为了解决这个问题，C++引入了命名空间的概念。

在命名空间中创建的变量，是全局变量，存放在静态区

编译器查找变量的规则是：默认现在局部域中查找，如果找不到，再到全局域中去找，如果在全局域中也没找到该变量，就报错；而命名空间的作用是改变编译器查找变量的规则，让编译器先到局部域中查找，如果找不到，就直接到命名空间中去找，再找不到就报错

2、命名空间的定义

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

2.1命名空间的特点：

命名空间的名称是随意取的；
命名空间中可以定义函数/变量/类型；
命名空间可以嵌套；
同一个工程中允许存在多个相同名称的命名空间，编译器最后会将其合成到同一个命名空间中；

2.2命名空间定义函数/变量/类型：

2.3命名空间嵌套定义：

2.4而且c++允许定义存在多个名字相同的命名空间，编译器会合并在同一个命名空间当中

那么同一个文件的命名空间会不会被合并？？会合并可以理解成：多次定义同名域，但是被控制的范围都是一样的

3、命名空间的使用

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

命名空间名称加作用域限定符、
使用 using 将命名空间中某个成员引入、
使用 using namespace 将命名空间名称引入，其中的作用域限定符为：“::”

按照下面的命名空间举例子：

3.1命名空间名称加作用域限定符：


	cout << N::a << endl;
	cout << N::Add(2, 3) << endl;

3.2使用 using 将命名空间中某个成员引入：（部分展开，展开常用的，保密性强）

#include <iostream>
using N::a;
using N::Add;
int main()
{
	return 0;
}

3.3使用 using namespace 将命名空间名称引入：（全部展开，有风险）

using的意义：将命名空间的内容展开，相当于把命名空间的隔离墙给拆开了，这也带来了问题，所以就出现了部分展开

#include <iostream>
using namespace std;
using namespace N;
int main()
{
	cout << a << endl;
	cout << Add(2, 3) << endl;
	return 0;
}

有太多的书，直接iostream下面就是接着using namespace std; 这样在平时玩的时候是安全的，以后写项目的时候，全部展开是感情大忌

总的来说，我们想要使用命名空间中的变量，一共有两种方法：

一种是使用作用域限定符 ::
另一种是引入命名空间，而引入命名空间又分为部分引入和全部引入

三、C++的输入输出

#include<iostream>
// std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中
using namespace std; //全部展开
int main()
{
	int a = 0;
	cin >> a;  
	cout << a << endl; 
	return 0;
}

说明：

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

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

3、<<是流插入，>>是流提取

4、使用C++输入输出更方便，C++的输入输出可以自动识别变量类型

5、cout 和 cin 分别是 ostream 和 istream 类型的对象，>>和<<也涉及运算符重载等知识

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

这个问题请看上方命名空间的使用中有所提及！！

四、缺省参数

1、缺省参数的概念

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

c语言不支持，只有c++支持

2、缺省参数的分类

缺省参数一共分为两类：全缺省参数和半缺省参数；

2.1全缺省参数：

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

2.2半缺省参数：（有规则）

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

注意事项

半缺省参数必须从右往左依次来给出，不能间隔着给；
缺省参数不能在函数声明和定义中同时出现，如果既存在函数声明，又存在函数定义，那么缺省参数只能在函数声明处给定；（这种情况指的是俩个文件也就是说.h中写出缺省参数，.c文件中不可以写参数了）
缺省值必须是常量或者全局变量

五、函数重载

1、函数重载的概念

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

1.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参数个数不同构成函数重载：

//参数个数不同构成函数重载
void f()
{
	cout << "f()" << endl;
}
void f(int a)

{
	cout << "f(int a)" << endl;
}

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

cout cin能够自动识别类型，就是因为函数重载

2、函数重载的原理（重要）

在C语言中，一个程序需要经历预处理、编译、汇编、链接四个阶段；

其中编译阶段会进行符号汇总，

汇编阶段会生成符号表，

而链接阶段则会对符号表进行合并与重定位，其中符号表会将每一个变量都关联上一个地址，但这个地址是否有效需要在链接阶段进行符号表的合并与重定位是时才能检查出来

解决问题：为什么c语言中不存在函数重载，在c++中反而存在呢？？

根据图示对于上述过程中生成符号表这一阶段，C编译器与C++编译器所进行的操作是不同的：C语言编译器会直接用变函数名作为符号表中的符号，而不会对函数名进行修饰；而C++编译器则是会对函数名进行修饰，用修饰后的名称来构成符号表

关于修饰是什么意思：还记得我们重载的条件是什么吗，没错正是关于参数的，修饰的时候就是利用参数来进行不同的区分（这里用Linux下g++的修饰规则来观察更好理解，Windows编译器下有大量的@晦涩难懂）

2.1C语言编译器下的函数修饰：

Add变成了<Add>还是没有改变

2.2C++编译器编译器下的函数修饰：

那个ii 就是int的意思说明根据参数的不同进行了不同的函数修饰

结论：

在linux下，采用gcc (C语言编译器) 编译完成后，函数名字的修饰没有发生改变；而采用g++ (C++编译器) 编译完成后，函数名字的修饰发生改变，函数名由前缀_Z+函数长度 +函数名+类型首字母组成，即编译器将函数参数类型信息添加到了修改后的名字中

C语言没办法支持重载是因为同名函数没办法区分；

而C++是通过函数修饰规则来区分，只要参数类型不同，修饰出来的名字就不同，所以就支持重载

2.3面试题目：为什么返回值不同不能进行重载？？

从语法层的角度，是因为在修饰规则中没有带上返回值这个因素吗？那我带上不就好了吗？

解决：函数调用时并不会传递函数的返回值类型，那么对于返回值不同，其他各方面都相同的函数而言，操作系统就不知道应该将参数传递给哪个函数，即在传递参数时出现了二义性，这时候编译也是会报错的

六、内联函数（诞生意义：优化宏）

1、内联函数的概念

一个函数在开始调用时会建立函数栈帧，结束调用时会销毁函数栈帧，而函数栈帧的建立与销毁是有空间和时间上的开销的；那么，对于功能简单、调用次数非常多的小函数来说，每次调用都重新开辟栈帧势必就会造成效率的降低

在C语言中，我们使用宏函数来解决这个问题：例如我们写一个宏函数Add，这样使得程序在预处理阶段直接将 Add 函数替换成相应的代码，从而不再建立函数栈帧。

小羊提醒：写宏函数时有以下注意点

参数的类型不写
return不写
该加上的括号必须加上（一会举例子解释）

#define Add(x,y) ((x)+(y))

为什么要加括号？

外层括号比如：Add（2，3）*5 不加的话就会出错
内层括号比如：Add（a|b，a&b）当x和y是表达式的时候，运算符优先级比+高，就会出问题

宏的缺点：

宏不能调试；
宏没有类型安全检查；
宏非常容易写错；

聊了这么多宏的故事，天空一身巨响，内联函数闪亮登场！！

基于C语言宏函数的这些缺陷，C++设计了内联函数：

以 inline 关键字修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开 (用函数体替换函数的调用)，没有函数调用建立栈帧的开销，内联函数可以提升程序运行的效率；

内联函数的编写和正常函数一样，仅仅是在函数的返回值类型前添加一个 inline 关键字 (这样就解决了C语言宏函数容易写错以及没有类型安全检查的缺陷)；

同时，在 debug 模式下，内联函数不会自动展开，需要我们对编译器进行相关设置；在 release 模式下，内联函数会自动展开 (这样解决了C语言宏函数无法调试的缺陷)；

总结：内联函数在继承了C语言宏函数优点的同时几乎避免了其所有的缺陷

2、内联函数定义及查看

2.1内联函数的定义

//普通函数
int Add(int x, int y)
{
	return x + y;
}

//内联函数--添加inline关键字
inline int Add(int x, int y)
{
	return x + y;
}

2.2内联函数的查看

1、在 release 模式下，编译器会自动将内联函数展开，但由于 release 模式无法调试，所以我们这里无法观察；

2、在 debug 模式下，需要在项目->属性中对编译器进行如下设置，否则不会展开

我们现在进入调试查看内容

2.2.1普通函数的汇编代码

2.2.2内联函数的汇编代码

3、内联函数的特点

3.1特点一

inline 对于编译器而言只是一个建议 (类似于C语言的 register 关键字)，不同编译器关于 inline 的实现机制可能不同，一般建议将具有如下特点的函数采用 inline 修饰

函数规模较小 (即函数不是很长，具体没有准确的说法，取决于编译器内部实现)；
不是递归；
频繁调用；

下图为《C++prime》第五版对于 inline 的建议：

当我们将 Add 函数的内部逻辑复杂化之后，尽管我们使用了 inline 关键字修饰 Add 函数，但是 Add 函数并没有被展开，而是和正常函数一样调用、建立栈帧

3.2特点二

inline 是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段会用函数体替换函数调用；这样做的优势是减少了栈帧建立的开销，提高了程序运行效率；缺陷是可能会使可执行程序所占用的空间变大

需要注意的是，这里的空间指并不是指程序运行时占用的内存空间，而是指经过编译链接后得到的可执行程序 (.exe/.o文件) 所占用的空间；对于可执行程序变大的原因，我们以下面这个例子为例（解释为什么inline过长不展开）：

假设一个Func函数的汇编指令有50条，且这个函数要被重复调用1W次；

那么对于普通Func函数来说：我们每次调用Func都要转换出一条 call 汇编代码，调用1W次就有1W条汇编指令；但是Func函数本身只会在函数定义处被转换为汇编代码；所以普通Func函数经过编译之后的汇编指令一共有 1W+50 条；

而对于 inline 函数来说，由于 inline 函数会在所有调用的地方展开，也就是说，每调用一次Func函数，就会转换成50条对应的汇编代码；所以 inline Func函数经过编译之后的汇编指令一共有 50W 条；

而汇编指令的增多可能会导致我们编写的静态库/动态库增大，也有可能导致编写的 .exe 增大；这其实就是所谓的 “代码膨胀”，这也在一定程度上解释了为什么当内联函数过长时编译器不进行展开。

3.3特点三

inline 不建议声明和定义分离，分离会导致链接错误

对于 inline 函数来说，如果我们将函数的定义和声明分离，那么函数的声明在汇编阶段会生成一个符号表，里面关联的是一个无效的地址；但是由于 inline 函数是直接展开的，所以函数定义部分在汇编阶段并不会生成符号表；这时候就出现了上面的问题，程序经过符号表的合并之后 inline 函数仍然关联一个无效地址，会在重定位的时候发生链接性错误

七、auto关键字（C++11语法糖）

1、类型名思考

在代码编写过程中，随着程序越来越复杂，程序中用到的类型也越来越复杂，经常体现在：

类型难于拼写；
含义不明确导致容易出错；

#include <string>
#include <map>
int main()
{
	std::map<std::string, std::string> m{ { "apple", "苹果" }, { "orange","橙子" },{"pear","梨"} };
	std::map<std::string, std::string>::iterator it = m.begin();
	while (it != m.end())
	{
		//....
	}
	return 0;
}

对于std标准库中map的迭代器，他也是一个类型，但是名字真的是太长了，特别容易写错，当然typedef可以解决，但是他不可以自动识别，这个时候auto的优势就展现出来了

2、auto的概念

一个新的类型指示符（不能将auto理解成是一种类型，是类型占位符）来指示编译器，auto声明的变量必须由编译器在编译时期推导而得

int TestAuto()
{
	return 10;
}

int main()
{
	int a = 10;
	auto b = a;
	auto c = 'a';
	auto d = TestAuto();
	//auto e;  //无法通过编译，使用auto定义变量时必须对其进行初始化
	cout << typeid(b).name() << endl;
	cout << typeid(c).name() << endl;
	cout << typeid(d).name() << endl;
	return 0;
}

注意：使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto 的实际类型;因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型

3、auto的使用细则

用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&

在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量

4、auto虽然强大，但也有坎过不去

auto不能作为函数的参数，因为不是所有的参数都有初始化表达式，因此编译器可能无法推导出a的实际类型，所以直接规定auto不能作为函数形参
auto不能直接用来声明数组：数组需要根据元素类型及个数来开辟空间，而数组名代表指针，因此 auto 无法推导

八、范围for（重要）

1、范围 for 的用法

它可以自动判断结束，自动迭代

for循环后的括号被冒号分为两部分：

第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围

void TestFor()
{
	int array[] = { 1,2,3,4,5 };

	//使用引用进行迭代--可以修改原数组
	for (auto& e : array)
		e *= 2;

	//使用局部变量进行迭代--不能修改原数组
	for (auto e : array)
		cout << e << " ";

	cout << endl;  
}

2、范围for的使用条件

for循环迭代的范围必须是确定的：对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供 begin 和 end 的方法，begin 和 end 就是 for 循环迭代的范围

迭代的对象要实现++和==的操作；(关于迭代器我们以后会学习，现在大家了解一下就可以了)

九、指针空值nullptr（C++11）

在C语言中，通常我们在定义一个指针变量的时候会将其初始化为 NULL，避免后面对其错误使用造成野指针越界访问问题；其实这里的 NULL 是C语言中定义的一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码：

#ifndef NULL
#ifdef __cplusplus
#define NULL   0
#else
#define NULL   ((void *)0)
#endif
#endif

我们可以看到，对于C语言来说，NULL 其实是数字0被强转为指针类型，相当于0处的地址；而对于C++来说，NULL 则被直接解释为数字0；虽然 0 和 (void*)0 二者在数值上相同，但是他们的类型是不相同的，一个是整形，另一个是指针；这就导致使用时会出现一些问题，比如下面这个例子：

void f(int)
{
	cout << "f(int)" << endl;
}

void f(int*)
{
	cout << "f(int*)" << endl;
}

int main()
{
	f(0);
	f(NULL);
	f(nullptr);
	f((int*)NULL);
	return 0;
}