【C++入门篇】C++入门基础[必备知识点]

wheeldown

于 2024-08-04 23:46:57 发布

阅读量421

点赞数 7

文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/wheeldown/article/details/140912021

版权

一、引用

1.1引用概念和定义

引用不是定义一个新的变量，更不是在内存中开辟一个新的空间。它是为给已定义的变量起用一个别名，这个别名和已定义的变量指向的是同一块空间。

举个例子：在中学时期，我们会给关系好的朋友起一个外号，比如”黑狗“，“阿白”比较有特点的外号以证明关系很铁。那么在日常生活中，我们叫他的真名和他的外号是不是本意都是指向同一个人。对滴！！！这个外号跟别名有着异曲同工之妙！！！

引用的定义：

类型& 引⽤别名 = 引⽤对象;

C++中为了避免引⼊太多的运算符，会复⽤C语⾔的⼀些符号，⽐如前⾯的>，这⾥引⽤也和取地址使⽤了同⼀个符号&，⼤家注意使⽤⽅法⻆度区分就可以。（吐槽⼀下，这个问题其实挺坑的，个⼈觉得⽤更多符号反⽽更好，不容易混淆）

我们举例说明

1.1.1别名的别名

int a = 0;
// 引⽤：b和c是a的别名
int& b = a;
int& c = b;

这里b是a的别名，c是b的别名，所以a，b，c都是指向的同一块空间。

我们用结果看一下:

cout << a << endl;
cout << b << endl;
cout << d << endl;
cout << &a << endl;
cout << &b << endl;
cout << &d << endl;

三者的结果是一样的，对abc分别取地址，发现他们的地址都是相同的。都是00000009805AFC54。

1.1.2别名的赋值和引用的使用

我们都知道空间可以被赋值，那么别名的赋值是怎么样的哪？下列代码中的e的输出结果是什么？

int a = 0;
// 引⽤：b和c是a的别名
int& b = a;
int& c = b;
//
int e=20;
d=e
cout << a << endl;
cout << b << endl;
cout << d << endl;
cout << e << endl;

输出结果显示

对滴！！！别名指向的空间被赋值，空间变成了e的值，有点牵一发而动全身的感觉拉哈！！！

1.2 别名的特性

引⽤在定义时必须初始化
⼀个变量可以有多个引⽤
引⽤⼀旦引⽤⼀个实体，再不能引⽤其他实体

首先时必须进行初始化，不然编译器会对其进行报错。

int a = 10;
// 编译报错：“ra”: 必须初始化引⽤
//int& ra;
int& b = a;
int c = 20；

未初始化编译器提示（vs2022）

讲到这里了都

我们写一个交换函数试试水

void swap(int& rx, int& ry)
{
	int tmp = rx;
	rx = ry;
	ry = tmp;
}
int main()
{
int a=10;
int b=20;
swap(a,b)
}

这里我们详细解释一下，为什么a和b可以直接传实参，按惯性思维来说传的时形参吗？

这是因为a和b作为参数进入函数时，编译器将rx看作变量a的别名，ry看作变量b的别名，所以在函数实现功能时，又因为rx和ty是别名，还是分别指向a和b的空间。所以还是实质还是a和b的交换。

我们接下来用几个例子详细说明一下引用的特性

1.2.1参数引用

typedef int STDataType;

typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;

void STInit(ST& rs, int n = 4)
{
	rs.a = (STDataType*)malloc(n * sizeof(STDataType));
	rs.top = 0;
	rs.capacity = n;
}
int main()
{
ST st1;
STInit(st1);
}

这种跟swap函数的方式是大致一样的，都是相当于传实参。

1.2.2返回值的引用

我们对比下列的两个函数

//1.
int* STTop(ST& rs)
{
	assert(rs.top > 0);

	//return &(rs.a[rs.top - 1]);
	return rs.a + (rs.top - 1);
}
//2.
int &STTop(ST& rs)
{
	assert(rs.top > 0);

	return rs.a[rs.top - 1];
}
(STTop(st1))+= 1;

第一个函数是返回的是指针类型，返回的是一个地址。但是在C++中return返回的并不是顺序中相关参数的地址，而是C++会创建一个常性临时创建对象，我们叫做临时对象，返回的是临时对象的空间。所以并不会返回顺序表中相关参数的地址。

第二个函数我们仔细观察会发现STTop前面有一个&的运算符，这样我们返回的就是顺序表中的参数别名，可以直接用参数进行运算。

所以结论很明显：第一个函数是不会进行运算的，第二个可以进行运算。

1.2.3小心野引用！

对的，学到这里你可能会发现，引用和指针有点像呀！！！但打一个预防针，他俩虽然本质差不多，底层都是用指针实现，但是表层的用法是不一样的哦。所以既然差不多，所以小心野引用

举个例子

int &func()
{
	int ret = 10;
	ret++;
	//...

	return ret;
}

这就是野引用，ret在函数内被定义，但是ret在出函数的时候就被销毁了。所以返回的并不是ret。

穿插知识：越界是不一定报错的！！！！！

越界读不报错

越界写不一定报错

报错机制是抽查：

1.3引用的使用

引⽤在实践中主要是于引⽤传参和引⽤做返回值中减少拷⻉提⾼效率和改变引⽤对象时同时改变被引⽤对象。
引⽤传参跟指针传参功能是类似的，引⽤传参相对更⽅便⼀些。
引⽤返回值的场景相对⽐较复杂，我们在这⾥简单讲了⼀下场景，还有⼀些内容后续类和对象章节中会继续深⼊讲解。
引⽤和指针在实践中相辅相成，功能有重叠性，但是各有特点，互相不可替代。C++的引⽤跟其他语⾔的引⽤(如Java)是有很⼤的区别的，除了⽤法，最⼤的点
C++引⽤定义后不能改变指向， Java的引⽤可以改变指向。
⼀些主要⽤C代码实现版本数据结构教材中，使⽤C++引⽤替代指针传参，⽬的是简化程序，避开复杂的指针，但是很多同学没学过引⽤，导致⼀头雾⽔。

来来来，让我们剖析一下先数据结构教材中让人迷惑的点！！！

这里实际是对STL起了个别名，让下面的函数内书写比较方便，并不是取地址

二、const引用

• 可以引⽤⼀个const对象，但是必须⽤const引⽤。const引⽤也可以引⽤普通对象，因为对象的访问权限在引⽤过程中可以缩⼩，但是不能放⼤。

需要注意的是类似 int& rb = a*3; double d = 12.34; int& rd = d; 这样⼀些场景下a*3的和结果保存在⼀个临时对象中， int& rd = d 也是类似，在类型转换中会产⽣临时对象存储中间值，也就是时，rb和rd引⽤的都是临时对象，⽽C++规定临时对象具有常性，所以这⾥就触发了权限放⼤，必须要⽤常引⽤才可以。

所谓临时对象就是编译器需要⼀个空间暂存表达式的求值结果时临时创建的⼀个未命名的对象， C++中把这个未命名对象叫做临时对象。

int main()
{
//权限不能放大

	const int a = 10;
	const int* p1 = &a;
	int* p2 = p1;

	//权限可以缩小
	int b = 20;
	int* p3 = &b;
	const int* p4 = p3;

	

	int* const p5 = &b;
	int* p6 = p5;
	//不存在权限放大，因为const修饰的是p5本身不是指向的内特容

	
}

这里需要注意得是

类似 int& rb = a*3; double d = 12.34; int& rd = d; 这样⼀些场景下a*3的和结果保存在⼀个临时对象中

int main()
{
int a = 10;
const int& ra = 30;
// 编译报错: “初始化”: ⽆法从“int”转换为“int &”
// int& rb = a * 3;
const int& rb = a*3;
double d = 12.34;
// 编译报错：“初始化”: ⽆法从“double”转换为“int &”
// int& rd = d;
const int& rd = d;
return 0;
}

三、指针和引用的关系

C++中指针和引⽤就像两个性格迥异的亲兄弟，指针是哥哥，引⽤是弟弟，在实践中他们相辅相成，功能有重叠性，但是各有⾃⼰的特点，互相不可替代。
语法概念上引⽤是⼀个变量的取别名不开空间，指针是存储⼀个变量地址，要开空间。 • 引⽤在定义时必须初始化，指针建议初始化，但是语法上不是必须的。
引⽤在初始化时引⽤⼀个对象后，就不能再引⽤其他对象；⽽指针可以在不断地改变指向对象。
•引⽤可以直接访问指向对象，指针需要解引⽤才是访问指向对象。
sizeof中含义不同，引⽤结果为引⽤类型的⼤⼩，但指针始终是地址空间所占字节个数(32位平台下占4个字节，64位下是8byte)
指针很容易出现空指针和野指针的问题，引⽤很少出现，引⽤使⽤起来相对更安全⼀些。

四、inline内联函数

⽤inline修饰的函数叫做内联函数，编译时C++编译器会在调⽤的地⽅展开内联函数，这样调⽤内联函数就需要建⽴栈帧了，就可以提⾼效率。
inline对于编译器⽽⾔只是⼀个建议，也就是说，你加了inline编译器也可以选择在调⽤的地⽅不展开，不同编译器关于inline什么情况展开各不相同，因为C++标准没有规定这个。inline适⽤于频繁调⽤的短⼩函数，对于递归函数，代码相对多⼀些的函数，加上inline也会被编译器忽略。比特就业课
C语⾔实现宏函数也会在预处理时替换展开，但是宏函数实现很复杂很容易出错的，且不⽅便调试，C++设计了inline⽬的就是替代C的宏函数。
vs编译器 debug版本下⾯默认是不展开inline的，这样⽅便调试，debug版本想展开需要设置⼀下以下两个地⽅。
inline不建议声明和定义分离到两个⽂件，分离会导致链接错误。因为inline被展开，就没有函数地址，链接时会出现报错。

调试情况下解决默认inline不展开的方法：

还有一个问题

// 实现⼀个ADD宏函数的常⻅问题

//#define ADD(int a, int b) return a + b;

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

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

// 正确的宏实现 #define ADD(a, b) ((a) + (b)

) // 为什么不能加分号?

// 为什么要加外⾯的括号?

// 为什么要加⾥⾯的括号?

五 nutller

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

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

• C++中NULL可能被定义为字⾯常量0，或者C中被定义为⽆类型指针(void*)的常量。不论采取何种定义，在使⽤空值的指针时，都不可避免的会遇到⼀些⿇烦，本想通过f(NULL)调⽤指针版本的 f(int*)函数，但是由于NULL被定义成0，调⽤了f(int x)，因此与程序的初衷相悖。f((void*)NULL); 调⽤会报错。

• C++11中引⼊nullptr，nullptr是⼀个特殊的关键字，nullptr是⼀种特殊类型的字⾯量，它可以转换成任意其他类型的指针类型。使⽤nullptr定义空指针可以避免类型转换的问题，因为nullptr只能被隐式地转换为指针类型，⽽不能被转换为整数类型。

#include<iostream>
using namespace std;
void f(int x)
{
cout << "f(int x)" << endl;
}
void f(int* ptr)
{
cout << "f(int* ptr)" << endl;
}
int main()
{
f(0);

// 本想通过f(NULL)调⽤指针版本的f(int*)函数，但是由于NULL被定义成0，调⽤了f(int
x)，因此与程序的初衷相悖。
f(NULL);
f((int*)NULL);
// 编译报错：error C2665: “f”: 2 个重载中没有⼀个可以转换所有参数类型
// f((void*)NULL);
f(nullptr);
return 0;
}

wheeldown

关注

7
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
【C++入门篇】C++入门基础[必备知识点]

引用不是定义一个新的变量，更不是在内存中开辟一个新的空间。它是为给已定义的变量起用一个别名，这个别名和已定义的变量指向的是同一块空间。举个例子：在中学时期，我们会给关系好的朋友起一个外号，比如”黑狗“，“阿白”比较有特点的外号以证明关系很铁。那么在日常生活中，我们叫他的真名和他的外号是不是本意都是指向同一个人。对滴！！！这个外号跟别名有着异曲同工之妙！！！引用的定义：类型& 引⽤别名 = 引⽤对象;
复制链接

扫一扫