在上一篇文章中,我们讲述了c++对c语言的加强,在这篇文章中,我们开始学习c++对c语言的扩展_引用
引用
变量名
- 变量名实质上是一段连续存储空间的别名,是一个标号(门牌号).
- 通过变量来申请并命名内存空间
- 通过变量的名字可以使用存储空间.
问题:对一段连续的内存空间只能取一个别名吗?
引用的概念
- 变量名,本身是一段内存的引用,即别名(alias).引用可以看作一个已定
义变量的别名. - 引用的语法:Type& name = var;
- 基本用法
#include<iostream>
using namespace std;
int main(void)
{
int a=10;//c编译器分配4个字节内存,a内存空间的别名
int &b=a;//b就是a的别名
a=11;//直接赋值
{
int *p=&a;
*p=12;
cout<<a<<endl;
}
b=14;
cout<<"a = "<<a <<", b = "<<b<<endl;
return 0;
}
规则
- 引用没有定义,是一种关系型声明。声明它和原有某一变量(实体)的关系.故而类型与原类型保持一致,且不分配内存.与被引用的变量有相同的地址.
- 声明的时候必须初始化,一经声明,不可变更.
- 可对引用,再次引用.多次引用的结果,是某一变量具有多个别名.
- &符号前有数据类型时,是引用.其它皆为取地址.
int main(void)
{
int a,b;
int &r=a;
int &r=b;//错误,不可更改原有的引⽤关系
float &rr=b;//错误,引⽤类型不匹配 cout<<&a<<&r<<endl; //变量与引⽤ 具有相同的地址。
int &ra = r; //可对引⽤更次引⽤,表⽰a变量有两个别名,分别是 r和 ra
return 0;
}
引用作为函数的参数
- 普通引用在声明时必须用其它的变量进行初始化,引用作为函数参数声明时不进行初始化,
#include<iostream>
using namespace std;
struct Teacher
{
char name[64];
int age;
};
void printfT(Teacher *pT)
{
cout<<pT->age<<endl;
}
//pT是t1的别名,相当于修改了t1
void printfT2(Teacher &pT)
{
pT.age=33;
cout<<pT.age<<endl;
}
//pT和t1的是两个不同的变量
void printfT3(Teacher pT)
{
cout<<pT.age<<endl;
pT.age=45;//只会修改pT变量,不会修改t1变量
}
int main(void)
{
Teacher t1;
t1.age = 35;
printfT(&t1);
printfT2(t1); //pT是t1的别名
printf("t1.age:%d \n", t1.age); //33
printfT3(t1) ;// pT是形参 ,t1 copy⼀份数据 给pT
printf("t1.age:%d \n", t1.age); //33
return 0;
}
引用的意义
- 引用作为其它变量的别名而存在,因此在一些场合可以代替指针
- 引用相对于指针来说具有更好的可读性和实用性
在c语言中.
void swap(int a, int b); //⽆法实现两数据的交换
void swap(int *p, int *q); //开辟了两个指针空间实现交换
void swap(int &a,int &b)
{
int tmp;
tmp=a;
a=b;
b=tmp;
}
int main()
{
int a=3,b=5;
cout<<"a = "<<a<<"b = "<<b<<endl;
swap(a,b);
cout<<"a = "<<a<<"b = "<<b<<endl;
return 0;
}
c++中引入引用后,可以用引用解决的问题,避免用指针来解决,
引用的本质
- 单独定义的引用,必须初始化,说明很像一个变量.
- 引用在c++中内部实现是一个常指针.Type& name;<–>Type* const name;
- c++编译器在编译过程中使用常指针作为引用的内部实现,因此引用所占的空间大小与指针相同
- 从使用的角度,引用会让人误会其只是一个别名,没有自己的存储空间.这是C++为了实用性而做出的细节隐藏.
//程序的输入方式
void func(int &a)
{
a=5;
}
c++内部的实现
void func(int* const a)
{
*a=5;
}
间接赋值的3各必要条件:
- 定义两个变量 (一个实参一个形参)
- 建立关联 实参取地址传给形参
- *p形参去间接的修改实参的值
引用在实现上,只不过是把:间接赋值成立的三个条件的后两步和二为一.
引用作为函数的返回值(引用当左值)
- 当函数返回值为引用时:若返回栈变量,不能成为其它引用的初始值(不能作为左值使用).
#include<iostream>
int getA1()
{
int a=10;
return a;
}
int& getA2()
{
int a=10;
return a;
}
int main()
{
int a1=0;
int a2=0;
a1=getA1();//值拷贝
//将⼀个引⽤赋给⼀个变量,会有拷⻉动作
//理解: 编译器类似做了如下隐藏操作, a2=*(getA2())
a2=getA2();
//将⼀个引⽤赋给另⼀个引⽤作为初始值, 由于是栈的引⽤,内存⾮法
int &a3=getA2();
cout<<"a1="<<a1<<endl;
cout<<"a2="<<a2<<endl;
cout<<"a3="<<a3<<endl;
return 0;
}
- . 当函数返回值为引用时:若返回静态变量或全局变量,可以成为其他引用的初始值(可作为右值使用,也可作为左值使用)
#include<iostream>
using namespace std;
int getA1()
{
static int a;
a=10;
return a;
}
int& getA2()
{
static int a;
a=10;
return a;
}
int main(void)
{
int a1 = 0;
int a2 = 0;
//值拷⻉
a1=getA1();
//将⼀个引⽤赋给⼀个变量,会有拷⻉动作
//理解: 编译器类似做了如下隐藏操作, a2 = *(getA2())
a2=getA2();
//将⼀个引⽤赋给另⼀个引⽤作为初始值, 由于是静态区域,内存合法
int &a3=getA2();
cout<<"a1="<<a1<<endl;
cout<<"a2="<<a2<<endl;
cout<<"a3="<<a3<<endl;
return 0;
}
- 引用作为函数返回值,如果返回值为引用可以当左值.如果返回值为普通变量不可以当左值.
#include<iostream>
using namespace std;
//函数当左值
//返回变量的值
int func1()
{
static int a1=10;
return a1;
}
//返回变量本⾝
int& func2()
{
static int a2 = 10;
return a2;
}
int main(void)
{
//函数当右值
int c1 = func1();
cout<<"c1="<<c1 <<endl;
int c2=func2();//函数返回值是⼀个引⽤,并且当右值
cout<<"c2="<<c2<<endl;
//函数当左值
//func1()=100;//error
func2()=100;//函数返回值是⼀个引⽤,并且当左值
c2=func2();
cout<<"c2="<<c2<<endl;
return 0;
}
指针引用
#include<iostream>
#include<string.h>
#include<stdlib.h>
using namespace std;
/*
指针的引用
*/
struct Teacher {
char name[64];
int age;
};
//在被调用函数中,获取资源
int getTeacher01(Teacher **p)
{
Teacher *tmp = NULL;
if (p == NULL)
{
return -1;
}
tmp = (Teacher *)malloc(sizeof(Teacher));
if (tmp == NULL)
{
return -2;
}
tmp->age = 33;
//p是实参的地址,*实参的地址,去间接的修改是实参的值
*p = tmp;
}
//c++中的指针引用
int getTeacher02(Teacher* &tmp)
{
//给tmp赋值,相当于给main函数的pT1赋值
tmp = (Teacher *)malloc(sizeof(Teacher));
if (tmp == NULL)
{
return -1;
}
tmp->age = 20;
}
int main(void)
{
/*
c语言二级指针的使用
Teacher *pT1 = NULL;
getTeacher01(&pT1);
cout << "age : " << pT1->age << endl;
*/
//c++的引用(指针的引用)
//引用的本质:间接赋值后两个要求,让c++帮我们做了
Teacher *pT1 = NULL;
getTeacher02(pT1);
cout << "age : " << pT1->age << endl;
cout << endl;
system("pause");
return 0;
}
常量引用
const 引用有较多使用.它可以防止对象的值被随意修改.因而具有一些特性.
1.const 对象的引用必须是const 的,将普通引用绑定到const 对象是不合法的. 这个原因比较简单.既然对象是const的,表示不能被修改,引用当然也不能修改,必须用 const 引用。实际上,const int a=1;int &b=a;这种写法是不合法的
2. const 引用可使用相关类型的对象(常量,非同类型的变量或表达式)初始化.这个是const引用与普通引用最大的区别.这个是 const 引用与普通引用最大的区别.
#include<iostream>
#include<string.h>
#include<stdlib.h>
using namespace std;
void method01()
{
//普通引用
int a = 10;
int &b = a;
printf("%d\n", b);
//常引用
int x = 20;
const int &y = x;//常引用:让变量引用拥有只读属性,不能通过y修改x
//y = 21; 错误写法
/*
常引用初始化,分为两种情况:
1>.用变量初始化常量引用
int x1=30;
const int &y1=x1;
2>.用常量(字面量)初始化常量引用
const int a=10; -->c++编译器把a放到符号表中
int &m=41; -->普通引用引用一个字面量,没有内存地址
(引用就是给内存取多个门牌号)(多个别名)
const int &m=43;-->常引用存在一个内存地址,会分配内存空间
3>.
常引用相当于:const int* const e;
普通引用相当于;int* const e1;
*/
}
struct Teacher {
char name[64];
int age;
};
int printTeacher(const Teacher &p)
{
//p.age = 10; 错误的,只有只读功能
//常引用让实参拥有只读属性
printf("t1 : %d\n", p.age);
return 0;
}
int main(void)
{
Teacher t1;
t1.age = 36;
printTeacher(t1);
cout << endl;
system("pause");
return 0;
}
- const引用的原理
- const 引用的目的是,禁止通过修改引用值来改变被引用的对象.const引用的初化特性较为微妙,可通过如下代码说明:
double val = 3.14;
const int &ref = val;
double &ref2 = val;
cout<<ref<<" "<<ref2<<endl;
val=4.14;
cout<<ref<<" "<<ref2<<endl;
上述输出结果为 3 3.14 和 3 4.14.因为 ref 是 const 的,在初始化的过程中已经给定值,不允许修改.而被引用的对象是val,是非const的,所以 val的修改并未影响ref 的值,而 ref2 的值发生了相应的改变
那么,为什么非 const 的引用不能使用相关类型初始化呢?实际上,const引用 使用相关类型对象初始化时发生了如下过程:
int temp=val;
const int &ref = temp;
如果 ref 不是 const 的,那么改变 ref 值,修改的是 temp,而不是 val.期望对 ref 的赋值会修改 val 的程序员会发现 val 实际并未修改.
结论
- const int & e 相当于 const int * const e
- 普通引用 相当于 int *const e
- 当使用常量(字面量)对const引用进行初始化时,C++编译器会为常量值分配空间,并将引用名作为这段空间的别名
- 使用字面量对const引用初始化后,将生成一个只读变量