• 《深入浅出C++》——初识C++

    🧑‍💻第一章 初识C++🧑‍💻

    文章目录

    前言

    从本章开始，博主将持续更新C++学习经验分享，希望对看到这篇文章的你有所帮助。

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

    本章节主要目标：补充C语言语法的不足，以及C++是如何对C语言设计不合理的地方进行优化的

    一、C++简介

    1. 什么是C++？

    👇
    1979年，贝尔实验室的本贾尼等人试图分析unix内核的时候，试图将内核模块化，于是在C语言的基础上进行扩展，增加了类的机制，完成了一个可以运行的预处理程序，称之为C with classes。

    1982年，Bjarne Stroustrup 博士在C语言的基础上引入并扩充了面向对象的概念，发明了一种新的程序语言。为了表达该语言与C语言的渊源关系，命名为C++。因此：C++是基于C语言而产生的，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。

    语言的发展就像是练功打怪升级一样，也是逐步递进，由浅入深的过程。C++还在不断的向后发展。但是：现在公司主流使用还是C++98和C++11，所有大家不用追求最新，重点将C++98和C++11掌握好

    2. C++有多重要呢？

    1、语言的使用广泛度：


    👆
    TIOBE - 2022年7月编程语言流行趋势排行榜 TOP榜单，从中可以看出，C/C++几乎一致稳居前5，不仅这个月如此，这三十年一直都在前五名之列。

    2、在工作领域

    • 操作系统以及大型系统软件开发
    • 服务器端开发
    • 游戏开发
    • 嵌入式和物联网领域
    • 数字图像处理
    • 人工智能
    • 分布式应用

    除了上述领域外，在：科学计算、浏览器、流媒体开发、网络软件等都是C++比较适合的场景，作为一名老牌语言的常青树，C++都存在很大的价值。

    二、关键字

    C语言32个关键字，C++(98)总计63个关键字，C++(11)总计73个关键字

    • 1

    在这里插入图片描述
    对于这里，不详细讲述，后面用到会解释。

    三、命名空间

    👇在我们写C语言程序的时候，有时候会碰到这样的情况。

    发生这种情况的原因是rand即是函数，又是变量名，C语言没办法解决类似这样的命名冲突问题，所以C++提出了namespace来解决。所以说，使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突。

    1. 命名空间定义

    定义命名空间，需要使用到 namespace 关键字，后面跟命名空间的名字，然后接一对 { }即可，{ }中即为命名空间的成员。一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中。

    （1）命名空间中可以定义变量/函数/类型

    namespace Jared
{
	int rand = 0; 					//命名空间中可以定义变量
	int Add(int left, int right)	//命名空间中可以定义函数		
	{
		return left + right;
	}
	struct Node						//命名空间中可以定义类型/结构体
	{
		struct Node* next;
		int val;
	};
}
int main()
{
	printf("%p\n", rand);			//rand默认是去全局去找，找到是函数指针。
	printf("%d\n", Jared::rand);	//指定去Jared域去找，找到是变量rand
	cout << Jared::Add(1, 2) << endl;//调用Jared域中的Add函数，打印3
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    （2）命名空间可以嵌套

    namespace A
{
	int a=0;
	namespace B
	{
		int c=1;
	}
}
int main()
{
	cout << A::B::c << endl; //打印1
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    （3）同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。

    🚨一个工程中的Test.h和Test.cpp和main.cpp中三个A命名空间会被合并成一个命名空间，这样会方便团队协作。

    2. 命名空间使用

    （1）加命名空间名称及作用域限定符

    int main()
{
	printf("%d\n", Jared::rand);
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5

    （2）使用using将命名空间中某个成员引入

    using Jared::rand;
int main()
{
	printf("%d\n", rand);
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    （3）使用using namespace 命名空间名称 引入

    using namespce Jared;
int main()
{
	printf("%d\n", rand);//先去全局域去找，如果没有找到就去展开的Jared域去找
	Add(10, 20);
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    🚨看起来虽然方便了，using namespace std展开，标准库就全部暴露出来了，如果我们定义跟库重名的类型/对象/函数，就存在冲突问题。所以规范的工程项目中是不推荐这种方式的，日常练习可以使用。建议在项目开发中使用，像std::cout这样使用时指定命名空间 + using std::cout展开常用的库对象/类型等方式。

    四、输入和输出

    🎈使用C++问候世界，打印Hello world

    #include
// std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中
using namespace std;
int main()
{
	cout<<"Hello world!!!"<<endl;
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    🚨

    cout是ostream类型的全局对象， cin是istream类型的全局变量(这里再类和对象会详细说明)。使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时，必须包含< iostream >头文件。endl是特殊的C++符号，表示换行输出,相当于"\n" 也包含在包含< iostream >头文件中。

    std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中。 <<是流插入运算符，>>是流提取运算符。涉及运算符重载等知识(后面也会细说）。

    使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动控制格式。C++的输入输出可以自动识别变量类型。旧编译器(vc 6.0)中还支持格式，后续编译器已不支持，因此推荐使用+std的方式

    int i=11; double d=11.11;
cout<<i<<d<<endl; //自动识别类型（原理：函数重占+运算符重载）

    • 1
    • 2

    五、缺省参数

    缺省参数是声明或定义函数时，为函数的参数指定一个缺省值。可以认为缺省参数本质上就是一个备胎。

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    👀分类：
    （1）全缺省参数

    void Func(int a = 1, int b = 2, int c = 3)
{
///
}

    • 1
    • 2
    • 3
    • 4

    传参只能从左向右开始，Func(10，20）只能是传给a和b。
    错误示范：Func（，1，）这个在语法上是不被允许的。
    （2）半缺省参数

    void Func(int a, int b = 10, int c = 20)
{
///
}

    • 1
    • 2
    • 3
    • 4

    1.必须从右往左连续缺省，不能间隔 错误示范： Func(int a=10, int b = , int c = 20)
    2.调用的时候，因为没有全缺省所以不能传空参数，Func( )，全缺省则可以。

    🚨

    • 缺省参数不能再函数声明和定义中同时出现，一般在函数声明的时候给缺省参数。
    • 缺省值必须是常量或者全局变量

    看到这里你可能会问缺省参数有什么用❓
    举个列子：

    struct Stack
{
	int* a;
	int size;
	int capacity;
};
void StackInit(struct Stack* ps, int InitCapacity = 4)
{
	ps->a = (int*)malloc(sizeof(int) * InitCapacity);
	ps->size = 0;
	ps->capacity = 0;
}
int main()
{
	Stack st1;
	StackInit(&st1, 100);
	Stack st2;
	StackInit(&st2);
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    当我们用C语言写栈这个数据结构的时候，在初始化栈函数时给初始化容量一个缺省值4。在st1中，假设我知道栈里至少要存100个数据,我们直接传100即可。但时像st2这种情况，我们不知道栈里可以存多少个数据，我们不传，默认会开辟4个整数大小的空间，其他人使用的时候也会更加方便。
    所以：缺省参数的作用就是使我们函数调用的更加灵活。

    六、函数重载

    1. 概念

    在汉语中经常会出现一词多义的现象，比如包袱：可以指用布包起来的包。如，“把你的包袱拿好。”/也可以指某种负担。如。“你不要有思想包袱。”，人们可以通过上下文来判断该词的意思。在C++中也有类似的用法，就是函数重载。

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

    例如：

    // 1、参数类型不同
int Add(int left, int right)
{	
	return left + right;
}
double Add(double left, double right)
{
	return left + right;
}

// 2、参数个数不同
void A()
{
	cout << "A()" << endl;
}
void A(int a)
{
	cout << "A(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;
}

    • 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
    • 26
    • 27
    • 28
    • 29

    👆
    以上这些函数两两一组构成函数重载，分别对应参数类型不同、参数个数不同、参数类型顺序不同的情况。我们在使用重载的函数时候，也要根据形参的区别输入对应的实参。

    int main()
{	
	Add(10, 20);   
	Add(10.1, 20.2);
	A();
	A(10);
	f(10, 'a');
	f('a', 10);
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    🚨
    下面这种情况时不构成函数重载的，返回值不同的时候编译器无法区分到底调用哪个函数

    short Add(int left, int right)
{
	return left + right;
}

int Add(int left, int  right)
{
	return left + right;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    这种情况也不构成重载，虽然两个函数的参数是缺省值和非缺省值，但是依旧不影响修饰出来的函数名，所以不能构成函数重载。

    void Func(int a = 10)
{//}
void Func(int a)
{//}

    • 1
    • 2
    • 3
    • 4

    2. 为什么C++支持函数重载？

    为什么C++支持函数重载，而C语言不支持函数重载呢？
    首先来回顾一下C/C++程序运行起来要经历的几个阶段：
    我们新建一个工程，里面包含 fun.h fun.c main.c 三个文件
    预处理：头文件展开、宏替换、条件编译、去掉注释 。在上述工作完成后生成fun.i 和main.i文件（fun.h文件在另外两个文件里面被展开）
    编译： 语法检查（语法分析、语义分析、词法分析）、符号汇总、生成汇编代码。在上述工作完成后生成fun.s 和main.s文件。
    汇编： 把汇编代码转换为二进制机器码，形成符号表。在上述工作完成后生成fun.o 和main.o文件。符号表里存放定义函数的地址信息
    链接： 合并目标文件、段表，符号表的合并和符号表的重定位。在上述工作完成后生成在a.out 或者a.exe文件。

    在链接阶段，.o格式的目标文件合并到一起，生成a.out文件，链接器看到a.o调用Add函数的，但是没有Add函数的地址，就会到fun.o的符号表中找A函数的地址，然后链接到一起。每个编译器都有自己的函数名修饰规则，当Add函数是我们写的重载函时候，gcc的函数修饰后名字不变，而g++的函数修饰后变成_Z+函数长度+函数名+类型首字母。也正是g++函数名修饰规则的特点，即使函数名相同，只要参数不同，在g++中还是可以区分同名函数的重载的。C语言没办法支持重载，因为同名函数没办法区分。

    也正是因为C和C++编译器对函数名字修饰规则的不同，C++中调用C语言实现的静态库或者动态库就会出现问题，导致链接失败，在符合表中找不到对应函数的名字，这种场景下就要使用extern “C”。在函数前加extern “C”，意思是告诉编译器，将该函数按照C语言规则来编译。

    七、引用

    1. 引用概念

    引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。
    用法：类型& 引用变量名(对象名) = 引用实体；

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    👆从上图中，我们可以清晰的看出，a和b共用一块内存空间，同时a的改变会影响b，b的改变也会影响a，可以说a和b是完全相同的。

    2. 引用特点

    1. 引用在定义时必须初始化
    2. 一个变量可以有多个引用
    3. 引用一旦引用一个实体，在不能引用其他实体
      在这里插入图片描述
      🚨
      在引用常量的时候，经常会出一些问题
    	const int a = 10;
	//int& ra = a;		// 错，a为常量，常量只能可读，引用后就变成了可读可写。ra引用a属于权限放大，所以不行，权限不能放大，但是可以缩小
	const int& ra = a;	//正确，改为可读不可写
	// int& b = 10;		// 该语句编译时会出错，10为常量
	const int& b = 10;	//正确，改为可读不可写
	double d = 12.34;
	//int& rd = d;		// 错误，d时double类型，转换为int类型会发生隐式转换，不会改变b而会生成临时变量，临时变量具有常性
	const int& rd = d;	//正确，改为可读不可写

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    3. 使用场景

    1. 做参数——输出型参数、大对象传参提高效率
    void Swap(int& x, int& y)
{
	int tmp = x;
	x = y;
	y = tmp;
}
int main()
{
	int a = 0, b = 2;
	Swap(a, b);
	cout << a << b << endl; //2 0
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    1. 做返回值——输出型返回对象(调用者可以修改返回对象)、减少拷贝，提高效率
    int& f()
{
	static int n = 0;
	n++;
	// ...
	return n;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    🚨切记不要出现类似的情况，下面这种情况，main开辟栈帧调用Add函数，Add函数开辟新的栈帧,出了Add函数，系统会清理栈帧将c置成随机值，所以这种程序使用引用返回本质上是不对的（虽然编译器不一定能检查出来），结果没有保障的。

    int& Add(int a, int b)
{
	int c = a + b;
	return c;
}
int main()
{
	int& ret = Add(1, 2);
	Add(3, 4);
	cout << ret <<endl;
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    结论： 出了函数作用域，返回对象就销毁了，那么一定不能用引用返回，一定要用传值返回。传值返回会调用拷贝构造生成临时对象，这个临时对象保存在寄存器中用于返回，c再被析构。

    传值、传引用效率比较：
    以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。

    3. 引用和指针的区别

    在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。
    在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。从汇编实现的角度，引用底层跟指针的汇编代码是一样的。
    其实引用只是对指针进行了简单的封装，它的底层依然是通过指针实现的，引用占用的内存和指针占用的内存长度一样，在 32 位环境下是 4 个字节，在 64 位环境下是 8 个字节，之所以不能获取引用的地址，是因为编译器进行了内部转换。

    不同点：
    👇

    1. 引用概念上定义一个变量的别名，指针存储一个变量地址。
    2. 引用在定义时必须初始化，指针没有要求。
    3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体。
    4. 没有NULL引用，但有NULL指针。
    5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)
    6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
    7. 有多级指针，但是没有多级引用。
    8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理。
    9. 引用比指针使用起来相对更安全，指针更强大，更危险，更复杂。

    八、内联函数

    以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。本质上是对宏函数的优化。C++中基本上不再使用宏，尽量使用const、enum、inline去替代宏。

    宏的优点：1、复用性变强 2、宏函数提高代码效率，减少栈帧建立
    宏的缺点：1、复杂，可读性差 2、传参没有类型安全检查 3、不方便调试

    宏函数:

    #define ADD(a,b) ((a)+(b))

    • 1

    普通函数：
    在这里插入图片描述
    内敛函数：
    在这里插入图片描述
    可以看出，内敛函数没有call Add函数

    特点：

    • inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运行效率。
    • inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。
    • inline 不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。

    九、auto关键字(C++11)

    auto会自动推导类型

    	int a=10;
	auto b=a;

    • 1
    • 2
    • 使用auto定义变量时必须对其进行初始化
    • 当在同一行声明多个变量时，这些变量必须是相同的类型。 auto a = 1, b = 2;
    • auto不能推导的场景：
    1. auto不能作为函数的参数 void TestAuto(auto a)//错误
    2. auto不能直接用来声明数组 auto b[] = {4，5，6};//错误``

    十、基于范围的for循环(C++11)

    因此C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。

    范围for，自动依次取array的数据，赋值给e ，自动迭代，自动判断结束

    int array[] = { 1, 2, 3, 4, 5 };
for(auto& e : array)
	e *= 2;
for(auto e : array)
	cout << e << " "

    • 1
    • 2
    • 3
    • 4
    • 5

    🎈与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环。
    for循环迭代的范围必须是确定的，对于数组而言，就是数组中第一个元素和最后一个元素的范围。
    错误示范：

    void TestFor(int array[])
{
	for(auto& e : array)//错误
	cout<< e <<endl;
}

    • 1
    • 2
    • 3
    • 4
    • 5

    十一、 指针空值nullptr(C++11)

    NULL实际是一个宏 #define NULL 0
    NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量，使用空值的指针时，会遇到一些麻烦。所以C++11使用nullptr关键字代替NULL

    🎈

    1. 在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。
    2. 在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。
    3. 为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。

    总结

    以上就是C++第一章的内容，主要是对C语言设计不足做的一些优化，为后面的学习打好基础，感谢收看！🧑‍💻

  • 相关阅读:
    建模助手：Revit中捕捉点设置问题和楼层排序设置
    二十一、动态内存管理
    Docker下部署安装Mysql
    地理空间数据共享资源大汇总
    求解汉诺塔问题【修改版】
    Spring Cloud实战案例 │ Apollo和Zuul的整合开发
    2024免费的苹果电脑杀毒软件cleanmymac X
    ASEMI整流桥GBJ3510参数，GBJ3510特征，GBJ3510大小
    最长有效括号【python版】
    SpringBoot-Profile功能与外部化配置
  • 原文地址：https://blog.csdn.net/weixin_55051736/article/details/126217855