1.引用
1. 概念
-
引用不是新定义一个变量,而是给已存在的变量取别名,编译器不会为引用变量开辟内存空间,它和它引用的变量公用同一块内存空间
-
比如说 李逵,在家称为"铁牛", 江湖上人称"黑旋风" 这两个称号都是他的
2. 关于别名的理解
#include<iostream>
using namespace std;
int main()
{
int a = 10;//引用
int& b = a;
b = 20;
return 0;
}
-
b是a的引用,也就是起了一个别名,a再取了一个名称
- 同时改变别名b的值,也会改变a本身的值
3. 引用的特性
1.引用必须在定义时初始化
#include<iostream>
using namespace std;
int main()
{
int a = 10;
int& b;//错误举例
return 0;
}
- 若使用引用不初始化,b是谁的别名?
2.一个变量可以有多个别名
#include<iostream>
using namespace std;
int main()
{
int a = 10;
int& b = a;
int& c = a;
int& d = a;
return 0;
}
- b、c、d都是a的别名
3.引用一旦引用一个实体,再不能引用其他实体
#include<iostream>
using namespace std;
int main()
{
int a = 10;
int& b = a;
int c = 2;
b = c;
return 0;
}
- 由于b与c的地址不同,说明b不是c的别名 b值与c值相等,而是将c的值传给b
4.使用场景
1. 引用做参数
#include<iostream>
using namespace std;
void swap(int& pa, int& pb)
{
int tmp = pa;
pa = pb;
pb = tmp;
}
int main()
{
int a = 1;
int b = 2;
swap(a, b);
cout << "a= " << a <<" "<<"b=" << b << endl;
return 0;
}
把pa作为a的别名,即a本身
把pb作为b的别名,即b本身
pa与pb的交换就可以看作a与b的交换
2. 引用做返回值
1. 传值返回
是否为n直接返回
#include<iostream>
using namespace std;
int count()
{
int n = 0;
n++;
return n;
}
int main()
{
int ret=count();
return 0;
}
正常来说,是把n直接给ret,但是局部变量n随着count函数的销毁而销毁
所以ret再次访问到到原来函数栈帧,就会造成非法访问
所以说明并不是使用n作为返回值
临时变量作为返回值
将临时变量作为返回值
编译器是将n的值给予一个临时变量,临时变量的类型是int,再通过临时变量传给ret
临时变量通常是由寄存器(存4个字节/8个字节)充当
编译器傻瓜式判断
#include<iostream>
using namespace std;
int count()
{
static int n = 0;
n++;
return n;
}
int main()
{
int ret=count();
return 0;
}
static修饰后n在静态区,所以count栈帧的销毁不影响n,虽然n的值存在,但是依旧要通过临时变量来传递返回值,因为编译器是傻瓜式的处理问题.
此时临时变量是没必要存在,所以我们可以采用引用返回
减少拷贝
编译器将n的值传给临时变量,类型是int&,相当于n的别名,
再把临时变量传给ret,相当于将n本身传给ret,减少拷贝
调用者修改返回对象
#include<iostream>
using namespace std;
#define N 100
typedef struct arry//静态数组
{
int a[N];
int size;
}ay;
int& posat(ay& arr,int i)//传引用返回,返回的是arr.a[i]本身
{
return arr.a[i];
}
int main()
{
ay arr;
int i = 0;
for ( i = 0; i < N; i++)
{
posat(arr, i) = i;//将arr.a[i]的值进行赋值
}
for (i = 0; i < N; i++)//打印静态数组的值
{
cout << posat(arr, i) << " ";
}
return 0;
}
出了posat作用域还在,因为ay.a[i]属于结构体的局部变量,所以可以使用传引用返回,从而修改静态数组的值
3. 例题
#include<iostream>
using namespace std;
int& Add(int a, int b)
{
int c = a + b;
return c;
}
int main()
{
int& ret = Add(1, 2);
Add(3, 4);
cout << "Add(1,2) is :" << ret << endl;//7
cout << "Add(1,2) is :" << ret << endl;//随机值
return 0;
}
- 这个程序本身是错误的,结果是未定义的
- 先调用Add(1,2),由于是传引用返回,将c值3传给临时变量(作为c值的别名),再将临时变量传给ret,即ret是临时变量的别名,同理,ret也为c值的别名 (若Add栈帧销毁后空间没有被清理,ret值为3,若空间被清理,则为随机值)
- 调用同一个函数,建立栈帧大小相同,c处于位置也是相同,(若Add栈帧销毁后空间没有被清理,ret值为7,若空间被清理,则为随机值)
- 第一次空间未被清理,ret值为7,cout是一次函数调用,会建立函数栈帧覆盖掉Add栈帧,所以下一次为随机值
5. 常引用
权限放大
#include<iostream>
using namespace std;
int main()
{
const int c = 2;
int& d = c;//错误 权限放大
return 0;
}
- c由const修饰,权限为只读, d权限为可读可写,将只读转化为可读可写是权限放大的表现,会报错
- 说明权限不可以放大
权限保持
#include<iostream>
using namespace std;
int main()
{
const int c = 2;
const int& d = c;//权限保持
return 0;
}
c的权限为只读,d的权限为只读
c和d的权限相同,可以使d作为c的别名
说明权限可以保持
权限缩小
#include<iostream>
using namespace std;
int main()
{
int a = 5;
const int& b = a;//权限缩小
return 0;
}
a的权限为可读可写,b的权限为只读,b可以作为a的别名
说明权限可以缩小
临时变量具有常性
int count()
{
int n = 0;
n++;
return n;
}
int main()
{
const int& ret = count();
return 0;
}
- 传值返回,返回的是临时变量,ret作为临时变量的别名,临时变量具有常性,所以需加const修饰ret
类型转换产生临时变量
#include<iostream>
using namespace std;
int main()
{
int i = 2;
const double& d = i;
}
- i的值传给临时变量,临时变量类型为double,再使d作为临时变量的别名,临时变量具有常性,所以d要有const修饰
6.指针和引用的区别
- 1.引用概念上定义一个变量的别名,指针储存一个变量的地址
- 2.引用在定义时必须初始化,指针没有要求
- 3.引用在初始化时引用一个实体,就不能再引用其他实体,而指针可以在任何地方指向任何一个同类型实体
- 4.没有NULL引用,但有NULL指针
- 5.在sizeof含义不同,引用结果为引用类型的大小,但指针结果为地址空间所占字节个数
- 6.引用自加即引用的实体增加1,指针自加即指针向后偏移一个类型的大小
- 7.有多级指针,但是没有多级引用
- 8.访问实体方式不同,指针需要显式引用,引用编辑器自己处理
- 9.引用比指针使用起来更加安全
2. auto类型
自动推导类型
简化代码 类型很长时,可以考虑自动推导
#include<iostream>
using namespace std;
int main()
{
int a = 0;
//int b = a;
auto b = a;//b的类型不是我自己显示声明的,而是自动推导的
cout << typeid(b).name() << endl;//获取变量类型 当前结果为int
return 0;
}
b的类型不是我自己显示声明的,而是自动推导的
使用b初始化a,b的类型是什么,a的类型就是什么
typeid( ).name() 获取变量的类型
使用
用auto声明指针类型时,用auto和auto*没有任何区别,但用auto声明引用类型时则必须
加&
#include<iostream>
using namespace std;
int main()
{
int x = 10;
auto a = &x;
auto* b = &x;
auto& c = x;
cout << typeid(a).name() << endl;//int * __ptr64
cout << typeid(b).name() << endl;//int * __ptr64
cout << typeid(c).name() << endl;//int
return 0;
}
3. 范围for
基于一个范围去遍历数组,范围for被称之为语法糖
#include<iostream>
using namespace std;
int main()
{
int arr[] = { 1,2,3,4,5 };
for (auto e: arr)
{
cout << e << " ";
}
cout << endl;
return 0;
}
自动依次取数组中的数据赋值给e对象,自动判断结束
int main()
{
int arr[] = { 1,2,3,4,5 };
for (auto e : arr)
{
e *= 2;
cout << e << " ";//2 4 6 8 10
}
cout << endl;
for (auto e: arr)
{
cout << e << " ";//1 2 3 4 5
}
return 0;
}
数组中的内容没有被修改
因为是赋值给e,所以e的改变不会影响数组中的值
若想要影响数组中的内容
int main()
{
int arr[] = { 1,2,3,4,5 };
for (auto& e : arr)
{
e *= 2;
cout << e << " ";//2 4 6 8 10
}
cout << endl;
for (auto& e: arr)
{
cout << e << " ";//2 4 6 8 10
}
return 0;
}
使用引用即可改变数组中的内容,使e作为数组中内容的别名
3.面试题:为什么C++推荐使用nullptr?
#include<iostream>
using namespace std;
void f(int)
{
cout << "f(int)" << endl;
}
void f(int*)
{
cout << "f(int*" << endl;
}
int main()
{
f(0);//f(int)
f(NULL);//f(int)
return 0;
}
正常来说,认为0匹配f(int),而NULL指针匹配f(int*)
但实际两者都输出 f(int)文章来源:https://www.toymoban.com/news/detail-794564.html
NULL实际是一个宏,在c头文件中可以看到如下代码文章来源地址https://www.toymoban.com/news/detail-794564.html
#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif
- 在C++中 NULL被define定义成了0,不在C++中为((void *)0)
- 在C++11中引入新关键字nullptr,sizeof(nullptr)与sizeof((void*)0)字节数相同
所以建议指针空值使用nullptr
#include<iostream>
using namespace std;
void f(int)
{
cout << "f(int)" << endl;
}
void f(int*)
{
cout << "f(int*)" << endl;
}
int main()
{
f(NULL);//f(int)
f(nullptr);//f(int*)
return 0;
}
到了这里,关于【C++】引用 | auto类型 |范围for |使用nullptr的原因的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!