大家好,我是牛牛。
今天给分享一下C++中引用的使用以及注意事项,主要包含以下几部分内容:
-
引用简介
-
引用的语法格式
-
引用规则
-
引用的应用
-
引用的本质
-
引用与指针的区别
一、引用简介
参数的传递本质上是一次赋值的过程 ,对于像 char、bool、int、float 等基本类型的数据,它们占用的内存往往只有几个字节,对它们进行内存拷贝非常快速。
而数组、结构体、对象是一系列数据的集合,数据的数量没有限制,可能很少,也可能成千上万,对它们进行频繁的内存拷贝可能会消耗很多时间,拖慢程序的执行效率。
C语言中在传递这种聚合类型数据时,建议传递指针。但是指针使用起来比较麻烦而且可读性差。
因此C++增加了一种比指针更加便捷的传递聚合类型数据的方式-引用。
引用同指针一样,能够减少数据的拷贝,提高数据的传递效率,而且比指针更加方便和易用。
二、引用的语法格式
type &name = data;
例如:
int a = 10;
int &p = a;
引用可以看做是数据的一个别名,通过这个别名和原来的名字都能够找到这份数据,对引用的操作就相当于对数据的操作。
#include<iostream>
using namespace std;
int main()
{
? ? int a = 10;
? ? int &p = a;
? ? cout << p << " " << a << endl;
? ? cout << &p << " " << &a << endl;?
? ? p = 20;
? ? cout << p << " " << a << endl;
? ? return 0;
}
三、引用规则
1、引用只是别名,不占内存;和它引用的变量共用同一块内存空间;
2、引用仅在定义时带&,使用时普通变量一样使用,不含&;
3、引用必须在创建的时候初始化,一旦引用初始化后,就不能改变引用所指向的变量,类似于指针常量。
4、引用必须与一个确定的合法内存单元相关联,不存在NULL引用且不可以使用;
四、引用的应用
4.1 常引用
不能通过别名修改引用空间的数据,修饰形参可以防止在函数中对引用空间进行误操作;
格式:
const 数据类型 &别名 = 数据空间名;
const 数据类型 &别名
例如:
const int &n = 10;
4.2 引用作用与数组
①数组元素的类型 (&别名)[元素的个数] = 数组名;
int arr[3] = {20,100,45};
? int (&my_arr)[3] = arr;
? int i;
? for(i=0;i<3;i++)
? {
? ? cout << my_arr[i] << " ";
? }
? cout << endl;
②使用typedef 给数组元素的类型 [元素的个数]取别名,然后使用新类型名进行引用的定义
int arr[3] = {20,100,45}; ?
? typedef int TYPE_ARR[3]; // TYPE_ARR就是 int [3]类型的别名;
? TYPE_ARR &my_arr = arr;?
? int i;
? for(i=0;i<3;i++)
? {
? ? cout << my_arr[i] << " ";
? }
? cout << endl;
4.3 *引用作用于指针
给指针变量起别名,C语言使用二级指针指向一个指针,然后对指针空间进行操作,C++可以给指针起个别名进行指针空间的操作。
例如:将一个指针传递到函数中,在函数中申请一块空间,并赋值为“hello world”
①、使用二级指针:
#include<iostream>
#include<stdlib.h>
#include<string.h>
using namespace std;
void mallocFunc(char **p)
{
? *p = (char *)calloc(1,20);
? strcpy(*p,"hello world");
}
int main()
{
? char *str = NULL;
? // 在mallocFunc函数中为str申请一块空间,并赋值为"hello world"?
? mallocFunc(&str);
? cout << str << endl;
? return 0;
}
②、使用指针的引用:
#include<iostream>
#include<stdlib.h>
#include<string.h>
using namespace std;
void mallocFunc(char* &my_str)
{
? my_str = (char *)calloc(1,20);
? strcpy(my_str,"hello world"); ?
}
int main()?
{
? char *str = NULL;
? mallocFunc(str);
? cout << str << endl;
? return 0;
}
4.4、引用作为函数形参
#include <iostream>
using namespace std;
// ?定义一个函数交换两个变量的值
// 值传递
void swap1(int a,int b)
{
? ? int temp = a;
? ? a = b;
? ? b = temp;
}
// 地址传递 - 在函数的内部修改函数外部空间里面的数据
// 产生副本
void swap2(int *p,int *p1)
{
? ? int temp = *p;
? ? *p = *p1;
? ? *p1 = temp;
}
//引用
// 在函数内部修改函数外部空间的数据
// 不产生参数副本
// 使用起来比指针要简单
void swap3(int &t,int &t1)
{
? ? int temp = t;
? ? t = t1;
? ? t1 = temp;
}
int main()
{
? ? int a = 20,b = 30;
? ? swap1(a,b);
? ? cout << "val :a:" << a << ",b:" << b << endl;
? ? int m = 40,n = 50;
? ? swap2(&m,&n);
? ? cout << "val :m:" << m << ",n:" << n << endl;
? ? int k = 3, j = 40;
? ? swap3(k,j);
? ? cout << "val :k:" << k << ",j:" << j << endl;
? ? return 0;
}
注意:如果使用引用作为参数不希望在函数内部改变引用空间的内容,可以在引用的前面加const修饰。
void swap3(const int &t,const int &t1)
{
? ? // .......
}
4.5、引用作为函数返回值-一般用于做迭代
#include<iostream>
using namespace std;
int &test()
{
? static int num = 1;
? return num;
}
int main()
{
? int &ret = test();
? cout << ret << endl;
? return 0;
}
注意:不要返回局部变量的引用,原因是局部变量会在函数返回后被销毁,因此被返回的引用就成为”无所指”的引用,程序进入未知状态。
引用作为函数返回值的迭代应用:
#include <iostream>
using namespace std;
// 类 - 面向对象 ?属性和行为 -- 访问权限限制
class Person
{
public:
? ? int a = 30;
? ? void test1()
{
? ? ? ? cout << "test1" << endl;
? ? }
? ? void test2()
{
? ? ? ? cout << "test2" << endl;
? ? }
? ? Person test3()
{
? ? ? ? cout << "test3" << endl;
? ? ? ? return *this; // 返回的是对象 Person
? ? }
? ? void test4()
{
? ? ? ? cout << "test4:a:" << a << endl;
? ? }
? ? Person& test5(){
? ? ? ? cout << "test5" << endl;
? ? ? ? return *this;
? ? }
? ? void test6()
{
? ? ? ? cout << "test6:a:" <<a<< endl;
? ? }
};
int main()
{
? ? // 通过类创建一个对象 类名 对象名
? ? Person xiaoming;
? ? // 对象访问属性和行为 对象名.属性 ? 对象名.函数名();
? ? cout << xiaoming.a << endl;
? ? xiaoming.a = 50;
? ? xiaoming.test1();
? ? xiaoming.test2();
? ? // 迭代 xiaoming.test1().test2(); // xiaoming.test1()函数执行完了之后要返回给我xiaoming这个对象
? ? //xiaoming.test1().test2();
? ? // 在函数中返回对象
? ? // 在类里面 this指针 指向你通过这个类创建的对象 -- 因此*this代表要返回的对象。
? ?Person xm = xiaoming.test3(); // 返回的是小明的副本 - 重新创建了一个对象,小明里面的数据复制了一份给它
? xm.test4();
? //小明的改变不会影响vm
? xiaoming.a = 100;
? ?xiaoming.test4();
? xm.test4();
? ? // 在函数中返回对象的引用
? ? Person& xm1 = xiaoming.test5();
? ? xm1.test6();
? ? xiaoming.a = 200;
? ? xiaoming.test6();
? ? xm1.test6();
? ? xiaoming.test5().test6();
? ? return 0;
}
五、引用的本质
引用的本质在C++中就是指针常量(常指针),typedef& ref = val; //typedef* const ref = &val;
引用只是对指针进行了简单的封装,它的底层依然是通过指针实现的,引用占用的内存和指针占用的内存长度一样,在 32 位环境下是 4 个字节,在 64 位环境下是 8 个字节,之所以不能获取引用的地址,是因为编译器进行了内部转换。
例如:
int a = 10;
? int &p = a;
? p = 18;
? cout<<&p<<endl;
编译器会转化为:
int a = 10;
int *p = &a;
*p = 18;
cout << p << endl;
总结:不是变量 p 不占用内存,而是编译器不让获取它的地址。
六、引用与指针的区别
1、引用使用起来比指针便捷,可读性更强;
2、引用不占内存,指针占内存;
3、引用的值不能是NULL,指针的值可以是NULL;
4、指针有多级,引用只能有一级;
5、指针和引用的自增(++)自减(–)运算意义不一样。对指针使用 ++ 表示指向下一份数据,对引用使用 ++ 表示它所指代的数据本身加 1;自减(–)也是类似的道理。