入门C++这一篇就够了

你帅你先说.

已于 2022-12-29 13:44:34 修改

阅读量5.4k

点赞数 56

分类专栏： C++ 文章标签： c++ 开发语言后端

于 2021-12-05 18:17:56 首次发布

本文链接：https://blog.csdn.net/qq_52363432/article/details/121531583

版权

C++ 专栏收录该内容

13 篇文章 9 订阅

订阅专栏

●🧑个人主页:你帅你先说.
●📃欢迎点赞👍关注💡收藏💖
●📖既选择了远方，便只顾风雨兼程。
●🤟欢迎大家有问题随时私信我！
●🧐版权：本文由[你帅你先说.]原创，CSDN首发，侵权必究。

🥳1.C++关键字

相比于32个关键字的C语言，C++提供了63个关键字。

asm	do	if	return	try	continue
auto	double	inline	short	typedef	for
bool	dynamic_cast	int	signed	typeid	public
break	else	long	sizeof	typename	throw
case	enum	mutable	static	union	wchar_t
catch	explicit	namespace	static_cast	unsigned	default
char	export	new	struct	using	friend
class	extern	operator	switch	virtual	register
const	false	private	template	void	true
const_cast	float	protected	this	volatile	while
delete	goto	reinterpret_cast

我们发现，里面的有些关键字在C语言阶段我们已经学过了。

🎤2.命名空间

🎶2.1 命名空间的定义

在C/C++中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。

1.命名空间的使用
举个🌰:

int rand = 0;

这段代码这样写一点问题都没有
但如果我们引入头文件

#include<stdlib.h>

系统就会报出rand重定义的错误。
简单来说就是你命名的变量和函数库的变量重名了，针对于这个问题，C语言没办法很好的解决这个问题。所以C++就有了命名空间来解决这个问题。
刚刚我们讲的关键字里我们注意到有一个叫namespace的关键字，也就是命名空间。
有了命名空间我们对上面的代码进行修改

#include<stdlib.h>
namespace MY
{
	int rand = 0;
}

此时rand和库里的rand形成了一层屏障，相当于是一个域。编译器自己不会去访问这个域，只有我们手动才能访问到域里的内容。

printf("%d",MY::rand);

此时才可以访问到域里的内容。
如果::左边为空,那就默认到全局域里去找。即可通过这种方式访问全局变量。虽然这些变量是在域里，但域里的变量还是属于全局变量，放在静态区。
💡:命名空间只能定义在全局。
2.与函数不同，命名空间是可以嵌套定义的。

namespace m
{
	int rand = 0;
	namespace n
	{
		int random = 0;
	}
}
//此时如果要访问random
printf("%d",m::n::rand);

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

🍽️2.2 命名空间的使用

命名空间的使用有三种方式：
●加命名空间名称及作用域限定符:

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

●使用using将命名空间中成员引入

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

●使用using namespace 命名空间名称引入

using namespce MY;//将命名空间里的内容全部展开
int main()
{
 	printf("%d\n", rand);
 	return 0; 
}

第三种方式将命名空间里的内容全部展开，虽然方便了，但命名空间形成的屏障就消失了。所以在大型项目中，这种方法要慎用。

🎉3. C++输入&输出

C++的第一行代码:

#include<iostream>//C++的库 输入输出流
using namespace std;//C++库的实现定义在一个叫std的命名空间中
int main()
{
	cout<<"hello world"<<endl;
	return 0;
}

输入流

int main()
{
	int a
	cin>>a;//>>流提取
}

相比于scanf，cin可以自动识别类型，不需要%d，%c等来区别变量类型。
输出流

int main()
{
	int a
	cin>>a;
	cout<<a<<endl;//endl等价于"\n"
	//<<流插入
}

与cin类似，相比于printf，cout也可以自动识别类型。
💡:使用cout标准输出(控制台)和cin标准输入(键盘)时，必须包含< iostream >头文件以及std标准命名空间

🥂4.缺省参数

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

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

像这种函数的每个参数都有缺省值的我们叫它全缺省参数

void Fun(int a = 10,int b = 5,int c = 1)
{
	cout<<a<<b<<c<<endl;
}

既然有了全缺省，对应的就会有半缺省，但半缺省不是缺省不是缺省一半，而是部分缺省，且必须从右往左连续缺省。

void Fun(int a,int b,int c = 1)
{
	cout<<a<<b<<c<<endl;
}

💡:
1.缺省参数不能在函数声明和定义中同时出现
2.缺省参数必须是常量或者全局变量
3.C语言不支持缺省参数

🍺5.函数重载

🎆5.1函数重载概念

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

//1.参数类型不同
int Add(int left, int right) 
{
	return left+right; 
}
double Add(double left, double right) 
{
 	return left+right; 
}
//2.参数个数不同
void f()
{
	cout << "f()" << endl;
}

void f(int a)
{
	cout << "f(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;
}

💡:不能通过返回值的不同来构成重载
举个🌰:

void fun(int a)
{
	cout<<a<<endl;
}
int fun(int a)
{
	return a;
}

此时如果你调用fun(1)，系统无法区分你要调用的是哪个。
只有满足以上三个条件中的任何一个才能构成重载，其余情况均不构成重载。
那么C语言支持函数重载吗?
答案是不支持。
为什么呢？
这一块要涉及到的知识比较复杂，在这边先简单的讲一下。
C语言区分函数只是简单的从函数名来区分，而C++则是通过函数名长度、函数名、函数参数来区分函数的，比如f()函数，(linux环境)系统中是这样来标识的 _Z1fv 1是函数名长度，f是函数名，v是函数参数首字母，v就是void，再举个例子，func(int i,double x)，系统中就是 _Z4funcid这样来标识。
讲完了知识点我们来道题巩固一下
在这里插入图片描述
这道题很明显是选B，刚刚讲过参数个数不同可以构成重载。但这题我想说的远不止这些，这题我要是在主函数中f(10)调用函数可以吗？可能很多人会想传了一个参数那调用的就是void f(int)这个声明对应的函数，但你没有注意到第一个函数的第二个参数是缺省参数，当你f(10)调用函数时编译器他不知道该调用哪个函数,因为你有缺省参数，传一个值也是可以的。所以这道题虽然定义正确，函数也可以重载，但却会造成二义性，这也提醒我们，不是函数能重载就没问题了，还得看可不可以正常调用。

💐5.2extern C

有时候在C++工程中可能需要将某些函数按照C的风格来编译，在函数前加extern “C”，意思是告诉编译器，将该函数按照C语言规则来编译。比如：tcmalloc是google用C++实现的一个项目，他提供tcmallc()和tcfree两个接口来使用，但如果是C项目就没办法使用，那么他就使用extern “C”来解决。

🍲6.引用

🍗6.1 引用概念

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。

🌰:

void TestRef()
{
 int a = 10;
 int& aa = a;//<====定义引用类型
 
 printf("%p\n", &a);
 printf("%p\n", &aa);
}

💡:引用类型必须和引用实体是同种类型的。

🍰6.2 引用特性

1. 引用在定义时必须初始化

int a = 10;
int& b;//error
int& b = a;//正确用法

2. 一个变量可以有多个引用

int a = 10;
int& b = a;
int& c = a;
int& d = b;//这样也可以

3. 引用一旦引用一个实体，再不能引用其他实体

int a = 10;
int& b = a;
int c = 20;
b = c;//这段代码的含义是将c的值赋给b，不是把b变成c的别名

到目前为止，swap函数我们已经学了三种方法

void swap(int* p1, int* p2) // 传地址
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
void swap(int& r1, int& r2) // 传引用
{
	int tmp = r1;
	r1 = r2;
	r2 = tmp;
}
void swap(int r1, int r2)   // 传值
{
	int tmp = r1;
	r1 = r2;
	r2 = tmp;
}
// 它们三个构成函数重载
// 但是swap(x, y)调用时存在歧义，他不知道调用传值还是传引用

🎈6.3使用场景

1. 做参数

void Swap(int& left, int& right) 
{
 	int temp = left;
 	left = right;
 	right = temp; 
}

2. 做返回值

我们先来回顾一下函数传值返回的过程

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

当函数返回值的时候，不是把c的值赋给ret，换句话说不是把c给返回，而是把c的拷贝给返回。什么意思呢？当函数返回值时，会把c的值放在一个临时变量中，再通过这个临时变量把值赋给ret。这个时候你是否有疑惑这个临时变量是什么？实际上，这个临时变量在c比较小时一般是寄存器充当，如果c较大，临时变量放在调用Add函数的栈帧中。
那么如果引用做返回值，这段程序会发生什么？

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

在这里引用返回的意思就是不会生成c的拷贝返回，直接返回c的引用。
这样就会导致一下两个问题:
1.存在非法访问，因为add(1,3)的返回值是c的引用，所以add栈帧销毁了以后，会去访问c位置空间。
2.如果add函数栈帧销毁，清理空间，那么取c值的时候就是取到随机值，给ret就是随机值。

说了这么多，无非就是想告诉你引用返回适用于出了函数作用域，返回对象还没被销毁的情况。
🌰:

int& Count()
{
 	static int n = 0；
 	n++;
 	return n; 
}

n是个静态变量，放在静态区，出了函数作用域不会被销毁，此时就可以用引用返回。
我们再来看一个引用的应用

const int N = 10;
int& At(int i)
{
	static int a[N];
	return a[i];
}
int main()
{
	for(int i = 0;i<N;i++)
	{
		At(i) = 10+i;//写入
	}
	for(int i = 0;i<N;i++)
	{
		cout<<At(i)<<" ";//读出
	}
	cout<<endl;
}

这样写相当于给函数写入值。但如果把At函数里的&去掉就会出错，因为去掉后At(i)的值就是个临时变量，临时变量具有常属性，是右值。

🍋6.4传值、传引用效率比较

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

所以当要处理的数据很多的情况下，用引用传参和传返回值的效率更高。

🍾6.5常引用

//权限放大
const int a = 10;
int& b = a;

这段代码有没有问题？
答案是有。
a已经被赋予了常属性，再让b变成a的引用，只要类型前面没有const就是默认可以修改的，所以要在int前再加一个const。

//权限不变
const int a = 10;
const int& b = a;

这段代码的意思是a、b的值都是10且b是a的常引用，且都不可更改。
这种情况也是支持的

//权限缩小
int c = 10;
const int& d = c;

常属性这还有一块需要注意的

//1.
double d = 11.98;
int i = d;
//2.
double d = 11.98;
int& i = d;
//3.
double d = 11.98;
const int& i = d;

这三种写法有什么区别呢?
首先我们先看第一种，将double类型的d赋值给int类型的d，我们C语言学过，这是允许的，只是d会发生截断，那这个截断过程是什么样的呢?实际上是会把d的截断部分先存在一个临时变量里再赋值给i。这样你就会发现第二种写法是有问题的，为什么呢？同样是把截断部分存在临时变量里让i作为临时变量的引用，但临时变量具有常属性，是不能被修改的，所以第三种写法才是正确的。(临时变量不是局部变量，这是两个完全不同的概念)

学到这我们发现const Type& 是通吃所有类型的，可以接收任何类型的变量。
所以我们建议如果函数函数中不改变参数的值，建议使用const&。
学到这，可能有人会有疑惑

int a = 10;
int& b = a;

b存在哪呢？
我们知道临时变量是存在栈区的。有的人就会以为存在栈里是这样的
在这里插入图片描述
这样想就错了。
不管是a还是b它都不会存在栈区，栈区存的是值，而a和b是属于符号，是存在符号表里的，通过符号表里的地址标识去访问栈区。

🎊6.6指针和引用的区别

引用在定义时必须初始化，指针没有要求
引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
没有NULL引用，但有NULL指针
在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占
4个字节)
引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
有多级指针，但是没有多级引用
访问实体方式不同，指针需要显式解引用，引用编译器自己处理
引用比指针使用起来相对更安全
从底层来看，我们来讨论一下它们的区别。

你会发现，指针和引用是两个完全不同的概念，指针是开辟空间，存储变量地址，而引用不开辟空间，仅仅是对变量取别名，但它们的底层实现是完全一样的。底层这一块大家只需了解一下就行，平时在用的时候不要去想底层。

🍷7.内联函数

🕺7.1内联函数概念

以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数压栈的开销，内联函数提升程序运行的效率。

举个🌰:

inline int Add(int x,int y)
{
	ret = x+y;
	return ret;
}
int main()
{
	int ret = Add(1,2);
	cout<<ret<<endl;
}

此时编译器不会调用函数，也就是不会创建栈帧，而是把函数里的内容进行展开，这有点类似于宏的替换。
有了inline函数，我们就不需要用C的宏，因为宏很复杂，很容易出错。

💃7.2内联函数特性

inline是一种以空间换时间的做法，省去调用函数额开销。 所以代码很长或者有循环/递归的函数不适宜使用作为内联函数。
inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等，编译器优化时会忽略掉内联。
inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。

🧇8.auto关键字(C++11)

🍲8.1auto简介

在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，但后来我们发现我们正常定义变量，它也是具有自动存储器的局部变量，所以就没有人用它。
C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。

什么意思呢？

int a = 0;
char b = 'b';
double c = 3.14;
//自动推导类型
auto d = a;//推导出类型为int
auto e = b;//推导出类型为char
auto f = c;//推导出类型为double

我们用程序去验证
在这里插入图片描述

🥗8.2auto使用细则

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

int main()
{
 	int x = 10;
 	auto a = &x;
 	auto* b = &x;
	auto& c = x;
 	cout << typeid(a).name() << endl;
 	cout << typeid(b).name() << endl;
 	cout << typeid(c).name() << endl;
  	*a = 20;
 	*b = 30;
 	 c = 40;
 	return 0; 
}

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

void TestAuto()
{
 auto a = 1, b = 2; 
 auto c = 3, d = 4.0; // 该行代码会编译失败，因为c和d的初始化表达式类型不同
}

🍨8.3 auto不能推导的场景

1.auto不能作为函数的参数

// 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
void TestAuto(auto a)
{}

2.auto不能直接用来声明数组

void TestAuto()
{
 int a[] = {1,2,3};
 auto b[] = {4，5，6};
}

🍭9.基于范围的for循环(C++11)

在C++98中如果要遍历一个数组，可以按照以下方式进行：

int main()
{
	int array[] = { 1, 2, 3, 4, 5 };
	//C/C++ 遍历数组
	for (int i = 0; i < sizeof(array) / sizeof(int); ++i)
	{
		cout << array[i] << endl;
	}
}

对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。（这个我们也俗称语法糖）

int main()
{
	int array[] = { 1, 2, 3, 4, 5 };
	for (auto e : array)//auto也可以换成其它类型，但一般用auto
	{
		cout << e << endl;
	}
}

还可以用范围for给数组每个元素+1

int main()
{
	int array[] = { 1, 2, 3, 4, 5 };
	for (auto& e : array)//auto也可以换成其它类型，但一般用auto
	{
		e++;
	}
	//array必须是数组名，不能是一个指针
}

🍮10.指针空值nullptr(C++11)

在良好的C/C++编程习惯中，声明一个变量时最好给该变量一个合适的初始值，否则可能会出现不可预料的错误，比如未初始化的指针。如果一个指针没有合法的指向，我们基本都是按照如下方式对其进行初始化：

int main()
{
 	int* p1 = NULL;
 	int* p2 = 0;
 	return 0;
}

NULL实际是一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码：

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

可以看到，NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量。不论采取何种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦，比如

void f(int) 
{
 	cout<<"f(int)"<<endl; 
}
void f(int*) 
{
 	cout<<"f(int*)"<<endl; 
}
int main()
{
 	f(0);
 	f(NULL);
 	f((int*)NULL);
 	return 0; 
}

程序本意是想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，因此与程序的初衷相悖。在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void*)常量，但是编译器默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强制类型转换(void*)0。
💡:
1.在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。
2.在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。
3.为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。
看到这，恭喜你，你已经成功入门了。
🍺🍺🍺🍺🍺🍺🍺🍺🍺🍺🍺🍺🍺🍺🍺🍺🍺
这样的文章你还不快点赞👍关注💡收藏⭐
🍷🍷🍷🍷🍷🍷🍷🍷🍷🍷🍷🍷🍷🍷🍷🍷🍷

📢:悄悄告诉你长按⭐️可一键三连！

你帅你先说.

关注

56
点赞
踩
165

收藏

觉得还不错? 一键收藏
打赏
22
评论
入门C++这一篇就够了

在C/C++中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。
复制链接

扫一扫