普通引用
引用概念
引用是C++对C的重要扩充。 （一种给函数传递地址的途径）
基本语法:
Type& ref = val;
注意事项：
- &在此不是求地址运算，而是起标识作用。
- 类型标识符是指目标变量的类型
- 必须在声明引用变量时进行初始化。
- 引用初始化之后不能改变。
- 不能有NULL引用。必须确保引用是和一块合法的存储单元关联。
- 建立对数组的引用。
void test01(){
int a = 10;
//给变量a取一个别名b
int& b = a;
cout << "a:" << a << endl;
cout << "b:" << b << endl;
cout << "------------" << endl;
//操作b就相当于操作a本身
b = 100;
cout << "a:" << a << endl;
cout << "b:" << b << endl;
cout << "------------" << endl;
//一个变量可以有n个别名
int& c = a;
c = 200;
cout << "a:" << a << endl;
cout << "b:" << b << endl;
cout << "c:" << c << endl;
cout << "------------" << endl;
//a,b,c的地址都是相同的
cout << "a:" << &a << endl;
cout << "b:" << &b << endl;
cout << "c:" << &c << endl;
}
//2. 使用引用注意事项
void test02(){
//1) 引用必须初始化
//int& ref; //报错:必须初始化引用
//2) 引用一旦初始化，不能改变引用
int a = 10;
int b = 20;
int& ref = a;
ref = b; //不能改变引用
}
//3. 建立数组引用方法一
typedef int ArrRef[10];
int arr[10];
ArrRef& aRef = arr;
for (int i = 0; i < 10;i ++){
aRef[i] = i+1;
}
for (int i = 0; i < 10;i++){
cout << arr[i] << " ";
}
cout << endl;
//4. 建立数组引用方法二
int(&f)[10] = arr;
for (int i = 0; i < 10; i++){
f[i] = i+10;
}
for (int i = 0; i < 10; i++){
cout << arr[i] << " ";
}
cout << endl;
引用做函数参数
普通引用在声明时必须用其它的变量进行初始化
引用作为函数参数声明时不进行初始化
//05复杂数据类型 的引用
struct Teacher
{
char name[64];
int age ;
};
void printfT(Teacher *pT)
{
cout<<pT->age<<endl;
}
//pT是t1的别名 ,相当于修改了t1
void printfT2(Teacher &pT)
{
//cout<<pT.age<<endl;
pT.age = 33; //这里用.操作符
}
//pT和t1的是两个不同的变量
void printfT3(Teacher pT)
{
cout<<pT.age<<endl;
pT.age = 45; //只会修改pT变量 ,不会修改t1变量
}
void main()
{
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 //---> pT = t1
printf("t1.age:%d \n", t1.age); //35
cout<<"hello..."<<endl;
system("pause");
return ;
}
引用的意义
引用作为其它变量的别名而存在，因此在一些场合可以代替指针
引用相对于指针来说具有更好的可读性和实用性
引用本质思考
思考1：C++编译器背后做了什么工作？
思考2：对同一内存空间可以取好几个名字吗？
思考3：普通引用有自己的空间吗？
单独定义的引用时，必须初始化；说明很像一个常量
引用的本质
- 引用在C++中的内部实现是一个指针常量
Type& name < -------- > Type* const name - C++编译器在编译过程中使用常指针作为引用的内部实现，因此引用所占用的空间大小与指针相同。
- 从使用的角度，引用会让人误会其只是一个别名，没有自己的存储空间。这是C++为了实用性而做出的细节隐藏
当实参传给形参引用的时候，只不过是c++编译器帮我们程序员手工取了一个实参地址，传给了形参引用（指针常量）
函数返回值是引用(引用当左值)
C++引用使用时的难点：
- 当函数返回值为引用时
- 若返回栈变量
- 不能成为其它引用的初始值
- 不能作为左值使用
若返回静态变量或全局变量：
- 可以成为其他引用的初始值
- 即可作为右值使用，也可作为左值使用
返回值是基础类型，当引用：
int getAA1()
{
int a;
a = 10;
return a;
}
//基础类型a返回的时候，也会有一个副本
int& getAA2()
{
int a;
a = 10;
return a;
}
int* getAA3()
{
int a;
a = 10;
return &a;
}
返回值是static变量，当引用：
//static修饰变量的时候，变量是一个状态变量
int j()
{
static int a = 10;
a ++;
printf("a:%d \n", a);
return a;
}
int& j1()
{
static int a = 10;
a ++;
printf("a:%d \n", a);
return a;
}
int *j2()
{
static int a = 10;
a ++;
printf("a:%d \n", a);
return &a;
}
void main22()
{
// j()的运算结果是一个数值，没有内存地址，不能当左值。。。。。
//11 = 100;
//*(a>b?&a:&b) = 111;
//当被调用的函数当左值的时候，必须返回一个引用。。。。。
j1() = 100; //编译器帮我们打造了环境
j1();
*(j2()) = 200; //相当于我们程序员手工的打造 做左值的条件
j2();
system("pause");
}
返回值是形参，当引用：
int g1(int *p)
{
*p = 100;
return *p;
}
int& g2(int *p)
{
*p = 100;
return *p;
}
//当我们使用引用语法的时候 ，我们不去关心编译器引用是怎么做的
//当我们分析乱码这种现象的时候，我们才去考虑c++编译器是怎么做的。。。。
void main23()
{
int a1 = 10;
a1 = g2(&a1);
int &a2 = g2(&a1); //用引用去接受函数的返回值，是不是乱码，关键是看返回的内存空间是不是被编译器回收了。。。。
printf("a1:%d \n", a1);
printf("a2:%d \n", a2);
system("pause");
}
指针引用
#include "iostream"
using namespace std;
struct Teacher
{
char name[64];
int age;
};
int getTe(Teacher **myp )
{
Teacher *p = (Teacher *)malloc(sizeof(Teacher));
if (p ==NULL)
{
return -1;
}
memset(p, 0, sizeof(Teacher));
p->age = 33;
*myp = p; //
return 0;
}
//指针的引用
int getTe2(Teacher* &myp)
{
//相当于给实参的p开辟空间
myp = (Teacher *)malloc(sizeof(Teacher));
myp->age = 34;
return 0;
}
void main333()
{
Teacher *p = NULL;
//getTe(&p);
getTe2(p);
printf("age:%d \n", p->age);
system("pause");
}
常引用
使用变量初始化const引用
思考cost int &a = b PK const int &a = 10;
案例1：
int main()
{
int a = 10;
const int &b = a; //不能再通过b去修改a了
//int *p = (int *)&b;
//b = 11; //err
*p = 11; //只能用指针来改变了
cout<<"b--->"<<a<<endl;
printf("a:%d\n", a);
printf("b:%d\n", b);
printf("&a:%d\n", &a);
printf("&b:%d\n", &b);
system("pause");
return 0;
}
案例2：
void main41()
{
int a = 10;
const int &b = a; //const引用 使用变量a初始化
a = 11;
//b = 12; //通过引用修改a,对不起修改不了
system("pause");
}
struct Teacher1
{
char name[64];
int age;
};
void printTe2(const Teacher1 *const pt)
{
}
//const引用让变量(所指内存空间)拥有只读属性
void printTe(const Teacher1 &t)
{
//t.age = 11;
}
void main42()
{
Teacher1 t1;
t1.age = 33;
printTe(t1);
system("pause");
}
使用字面量常量初始化const引用
思考1：用变量对const引用初始化，const引用分配内存空间了吗？
思考2：用常量对const引用初始化，const引用分配内存空间了吗？
void main()
{
//普通引用
int a = 10;
int &b = a;
//常量引用 ：让变量引用只读属性
const int &c = a;
//常量引用初始化 分为两种
//1 用变量 初始化 常量引用
{
int x = 20;
const int& y = x;
printf("y:%d \n", y);
}
//2 用常量 初始化 常量引用
{
//int &m = 10; //引用是内存空间的别名 字面量10没有内存空间 没有方法做引用
const int &m = 10; //此时会开辟一个空间
}
cout<<"hello..."<<endl;
system("pause");
return ;
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
