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

六‍第一章初识C++六‍

文章目录

六‍第一章初识C++六‍
前言
一、C++简介
- 1. 什么是C++？
- 2. C++有多重要呢？
二、关键字
三、命名空间
- 1. 命名空间定义
- 2. 命名空间使用
四、输入和输出
五、缺省参数
六、函数重载
- 1. 概念
- 2. 为什么C++支持函数重载？
七、引用
- 1. 引用概念
- 2. 引用特点
- 3. 使用场景
- 3. 引用和指针的区别
八、内联函数
九、auto关键字(C++11)
十、基于范围的for循环(C++11)
十一、指针空值nullptr(C++11)
总结

前言

从本章开始，博主将持续更新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个关键字

对于这里，不详细讲述，后面用到会解释。

三、命名空间

在我们写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("%pn", rand);			//rand默认是去全局去找，找到是函数指针。
	printf("%dn", Jared::rand);	//指定去Jared域去找，找到是变量rand
	cout << Jared::Add(1, 2) << endl;//调用Jared域中的Add函数，打印3
	return 0;
}

（2）命名空间可以嵌套

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

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

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

2. 命名空间使用

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

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

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

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

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

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

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

四、输入和输出

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

#include
// std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中
using namespace std;
int main()
{
	cout<<"Hello world!!!"< 
 
 
 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< 
五、缺省参数 
缺省参数是声明或定义函数时，为函数的参数指定一个缺省值。可以认为缺省参数本质上就是一个备胎。 
void Func(int a = 10)
{
	cout << a << endl;
}
int main()
{
	Func(); // 没有传参时，使用参数的默认值，输出10
	Func(5); // 传参时，使用指定的实参，输出5
	return 0;
}
 
分类：
 （1）全缺省参数 
void Func(int a = 1, int b = 2, int c = 3)
{
///
}
 
传参只能从左向右开始，Func(10，20）只能是传给a和b。
 错误示范：Func（，1，）这个在语法上是不被允许的。
 （2）半缺省参数 
void Func(int a, int b = 10, int c = 20)
{
///
}
 
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;
}
 
当我们用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;
}
 

 以上这些函数两两一组构成函数重载，分别对应参数类型不同、参数个数不同、参数类型顺序不同的情况。我们在使用重载的函数时候，也要根据形参的区别输入对应的实参。 
int main()
{	
	Add(10, 20);   
	Add(10.1, 20.2);
	A();
	A(10);
	f(10, 'a');
	f('a', 10);
	return 0;
}
 

 下面这种情况时不构成函数重载的，返回值不同的时候编译器无法区分到底调用哪个函数 
short Add(int left, int right)
{
	return left + right;
}

int Add(int left, int  right)
{
	return left + right;
}
 
这种情况也不构成重载，虽然两个函数的参数是缺省值和非缺省值，但是依旧不影响修饰出来的函数名，所以不能构成函数重载。 
void Func(int a = 10)
{//}
void Func(int a)
{//}
 
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. 引用特点 
引用在定义时必须初始化
一个变量可以有多个引用
引用一旦引用一个实体，在不能引用其他实体
 
 
 在引用常量的时候，经常会出一些问题 
	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;	//正确，改为可读不可写
 
3. 使用场景 
做参数——输出型参数、大对象传参提高效率 
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;
}
 
做返回值——输出型返回对象(调用者可以修改返回对象)、减少拷贝，提高效率 
int& f()
{
	static int n = 0;
	n++;
	// ...
	return n;
}
 
切记不要出现类似的情况，下面这种情况，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 < 
结论： 出了函数作用域，返回对象就销毁了，那么一定不能用引用返回，一定要用传值返回。传值返回会调用拷贝构造生成临时对象，这个临时对象保存在寄存器中用于返回，c再被析构。 
传值、传引用效率比较：
 以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。 
3. 引用和指针的区别 
 
 在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。
 在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。从汇编实现的角度，引用底层跟指针的汇编代码是一样的。
 其实引用只是对指针进行了简单的封装，它的底层依然是通过指针实现的，引用占用的内存和指针占用的内存长度一样，在 32 位环境下是 4 个字节，在 64 位环境下是 8 个字节，之所以不能获取引用的地址，是因为编译器进行了内部转换。 
 
不同点：
  
引用概念上定义一个变量的别名，指针存储一个变量地址。
引用在定义时必须初始化，指针没有要求。
引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体。
没有NULL引用，但有NULL指针。
在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)
引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
有多级指针，但是没有多级引用。
访问实体方式不同，指针需要显式解引用，引用编译器自己处理。
引用比指针使用起来相对更安全，指针更强大，更危险，更复杂。 
八、内联函数 
 
 以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。本质上是对宏函数的优化。C++中基本上不再使用宏，尽量使用const、enum、inline去替代宏。 
 
宏的优点：1、复用性变强 2、宏函数提高代码效率，减少栈帧建立
 宏的缺点：1、复杂，可读性差 2、传参没有类型安全检查 3、不方便调试 
宏函数: 
#define ADD(a,b) ((a)+(b))
 
普通函数：
 
 内敛函数：
 
 可以看出，内敛函数没有call Add函数 
特点： 
inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运行效率。
inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。
inline 不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。 
九、auto关键字(C++11) 
auto会自动推导类型 
	int a=10;
	auto b=a;
 
使用auto定义变量时必须对其进行初始化
当在同一行声明多个变量时，这些变量必须是相同的类型。 auto a = 1, b = 2;
auto不能推导的场景： 
auto不能作为函数的参数 void TestAuto(auto a)//错误
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 << " "
 
与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环。
 for循环迭代的范围必须是确定的，对于数组而言，就是数组中第一个元素和最后一个元素的范围。
 错误示范： 
void TestFor(int array[])
{
	for(auto& e : array)//错误
	cout<< e < 
十一、 指针空值nullptr(C++11) 
NULL实际是一个宏 #define NULL 0
 NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量，使用空值的指针时，会遇到一些麻烦。所以C++11使用nullptr关键字代替NULL 
 
在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。
在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。
为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。 
总结 
以上就是C++第一章的内容，主要是对C语言设计不足做的一些优化，为后面的学习打好基础，感谢收看！六‍

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

C/C++/C#相关栏目本月热门文章