【C++】引用 | auto类型 |范围for |使用nullptr的原因

文章目录

• 1.引用
• • 1. 概念
  • 2. 关于别名的理解
  • 3. 引用的特性
  • • 1.引用必须在定义时初始化
  • 2.一个变量可以有多个别名
  • • 3.引用一旦引用一个实体，再不能引用其他实体
  • 4.使用场景
  • • 1. 引用做参数
    • 2. 引用做返回值
    • • 1. 传值返回
      • • 是否为n直接返回
        • 临时变量作为返回值
        • 编译器傻瓜式判断
        • 减少拷贝
        • 调用者修改返回对象
      • 3. 例题
  • 5. 常引用
  • • 权限放大
    • 权限保持
    • 权限缩小
    • 临时变量具有常性
    • 类型转换产生临时变量
  • 6.指针和引用的区别
• 2. auto类型
• • • 使用
• 3. 范围for
• 3.面试题：为什么C++推荐使用nullptr？

1.引用

1. 概念

• 引用不是新定义一个变量，而是给已存在的变量取别名，编译器不会为引用变量开辟内存空间，它和它引用的变量公用同一块内存空间

• 比如说 李逵，在家称为”铁牛”， 江湖上人称”黑旋风” 这两个称号都是他的

  

2. 关于别名的理解

#include
using namespace std;
int main()
{
	int a = 10;//引用
	int& b = a;
	b = 20;
	return 0;
}

• b是a的引用，也就是起了一个别名，a再取了一个名称

  

• 同时改变别名b的值，也会改变a本身的值

3. 引用的特性

1.引用必须在定义时初始化

#includeusing namespace std;int main(){	int a = 10;	int& b;//错误举例	return 0;}

• 若使用引用不初始化，b是谁的别名？

2.一个变量可以有多个别名

#includeusing namespace std;int main(){	int a = 10;	int& b = a;	int& c = a;	int& d = a;	return 0;}

• b、c、d都是a的别名

3.引用一旦引用一个实体，再不能引用其他实体

#includeusing 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
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本身

pa与pb的交换就可以看作a与b的交换

2. 引用做返回值

1. 传值返回

是否为n直接返回

#include
using namespace std;
int count()
{
    int n = 0;
    n++;
    return n;
}
int main()
{
    int ret=count();
    return 0;
}

正常来说，是把n直接给ret，但是局部变量n随着count函数的销毁而销毁

所以ret再次访问到到原来函数栈帧，就会造成非法访问

所以说明并不是使用n作为返回值

临时变量作为返回值

将临时变量作为返回值

临时变量通常是由寄存器(存4个字节/8个字节)充当

编译器傻瓜式判断

#include
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
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
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
using namespace std;
int main()
{
    const int c = 2;
    int& d = c;//错误 权限放大
    return 0;
}

• c由const修饰,权限为只读， d权限为可读可写，将只读转化为可读可写是权限放大的表现，会报错
• 说明权限不可以放大

权限保持

#include
using namespace std;
int main()
{
    const int c = 2;
    const int& d = c;//权限保持
    return 0;
}

c的权限为只读，d的权限为只读

c和d的权限相同，可以使d作为c的别名

说明权限可以保持

权限缩小

#include
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
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
using namespace std;
int main()
{
    int a = 0;
    //int b = a;
    auto b = a;//b的类型不是我自己显示声明的，而是自动推导的
    cout << typeid(b).name() << endl;//获取变量类型 当前结果为int
    return 0;
}

b的类型不是我自己显示声明的，而是自动推导的

typeid( ).name() 获取变量的类型

使用

用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须

加&

#include
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
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
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)

NULL实际是一个宏，在c头文件中可以看到如下代码

#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
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;
}