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

这篇具有很好参考价值的文章主要介绍了【C++】引用 | auto类型 |范围for |使用nullptr的原因。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

1.引用

1. 概念

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

  • 比如说 李逵,在家称为"铁牛", 江湖上人称"黑旋风" 这两个称号都是他的
    c++ unable to deduce ‘const auto*’ from ‘nullptr’,C++,c++,算法,开发语言

2. 关于别名的理解

#include<iostream>
using namespace std;
int main()
{
	int a = 10;//引用
	int& b = a;
	b = 20;
	return 0;
}
  • b是a的引用,也就是起了一个别名,a再取了一个名称
    c++ unable to deduce ‘const auto*’ from ‘nullptr’,C++,c++,算法,开发语言
  • 同时改变别名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;
}

c++ unable to deduce ‘const auto*’ from ‘nullptr’,C++,c++,算法,开发语言

  • 由于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;
}

c++ unable to deduce ‘const auto*’ from ‘nullptr’,C++,c++,算法,开发语言
正常来说,是把n直接给ret,但是局部变量n随着count函数的销毁而销毁
所以ret再次访问到到原来函数栈帧,就会造成非法访问

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

临时变量作为返回值

c++ unable to deduce ‘const auto*’ from ‘nullptr’,C++,c++,算法,开发语言
将临时变量作为返回值
编译器是将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的值存在,但是依旧要通过临时变量来传递返回值,因为编译器是傻瓜式的处理问题.
此时临时变量是没必要存在,所以我们可以采用引用返回

减少拷贝

c++ unable to deduce ‘const auto*’ from ‘nullptr’,C++,c++,算法,开发语言
编译器将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;
}
  • 这个程序本身是错误的,结果是未定义的c++ unable to deduce ‘const auto*’ from ‘nullptr’,C++,c++,算法,开发语言
  • 先调用Add(1,2),由于是传引用返回,将c值3传给临时变量(作为c值的别名),再将临时变量传给ret,即ret是临时变量的别名,同理,ret也为c值的别名 (若Add栈帧销毁后空间没有被清理,ret值为3,若空间被清理,则为随机值)

c++ unable to deduce ‘const auto*’ from ‘nullptr’,C++,c++,算法,开发语言

  • 调用同一个函数,建立栈帧大小相同,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)


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模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【C++初阶】二、入门知识讲解(引用、内联函数、auto关键字、基于范围的for循环、指针空值nullptr)

    ========================================================================= 相关代码gitee自取 : C语言学习日记: 加油努力 (gitee.com)  ========================================================================= 接上期 : 【C++初阶】一、入门知识讲解 (C++、命名空间、C++输入输出、缺省参数、函数重载)-

    2024年02月04日
    浏览(64)
  • 【C++】语法小课堂 --- auto关键字 & typeid查看实际类型 & 范围for循环 & 空指针nullptr

    🚩 在早期C/C++中auto的含义是:使用auto修饰的变量,是具有自动存储器的局部变量,但遗憾的是一直没有人去使用它,大家可思考下为什么? C++11中,标准委员会赋予了auto全新的含义即:auto不再是一个存储类型指示符,而是作为一个新的类型指示符来指示编译器, auto定义的

    2024年02月13日
    浏览(40)
  • 【c++速通】入门级攻略:引用详解 | auto的类型推导 | 不一样的for循环 | nullptr版本空指针

    🎥 屿小夏 : 个人主页 🔥个人专栏 : C++入门到进阶 🌄 莫道桑榆晚,为霞尚满天! 上篇文章中,对函数重载和内联函数的作用和特性使用,进行了精细的详解。 引用和指针混不清?引用的抽丝剥茧!还有不用写类型可以自动推导的?for遍历竟然还有我们没见过的面

    2024年02月08日
    浏览(46)
  • 【C++】auto & 范围for & nullptr

    目录 一,auto 1,类型别名思考 2,auto 简介 3,auto 的使用细则 1,auto 与指针和引用结合起来使用 2,同一行定义多个变量 3,auto 不能推导的场景 二,基于范围的for循环 1,范围 for 的语法 2,范围 for 的使用条件 三,指针空值 nullptr 1,类型别名思考 随着程序越来越复杂,程序

    2024年02月08日
    浏览(45)
  • 【C++初阶】C++入门——内联函数、auto、范围for、nullptr

     普通的函数在调用的时候会开辟函数栈帧,会产生一定量的消耗,在C语言中可以用 宏函数 来解决这个问题,但是宏存在以下缺陷: 复杂、容易出错、可读性差、不能调试 。为此,C++中引入了 内联函数 这种方法。  以 inline 修饰 的函数叫做内联函数, 编译时 C++编译器会

    2024年02月16日
    浏览(40)
  • C++入门:内联函数,auto,范围for循环,nullptr

    目录 1.内联函数 1.1 概念 1.2 特性  1.3 内联函数与宏的区别 2.auto(C++11) 2.1 auto简介 2.2 auto的使用细则 2.3 auto不能推导的场景 3.基于范围的for循环(C++11) 3.1 范围for的语法 3.2 范围for的使用方法 4.指针空值nullptr(C++11) 4.1 C++98中的指针空值 以inline修饰的函数叫做内联函数,编

    2024年02月11日
    浏览(35)
  • 【C++杂货铺】内联函数、auto、范围for、nullptr

     普通的函数在调用的时候会开辟函数栈帧,会产生一定量的消耗,在C语言中可以用 宏函数 来解决这个问题,但是宏存在以下缺陷: 复杂、容易出错、可读性差、不能调试 。为此,C++中引入了 内联函数 这种方法。  以 inline 修饰 的函数叫做内联函数, 编译时 C++编译器会

    2024年02月16日
    浏览(55)
  • 【C++深入浅出】初识C++下篇(auto关键字、范围for、nullptr指针)

    目录 一. 前言 二. auto 2.1 auto的引入 2.2 auto简介 2.3 auto的使用细则 2.4 auto不能推导的场景 三. 基于范围的for循环(C++11) 3.1 范围for的语法 3.2 范围for的原理 3.3 范围for的使用条件 四. 指针空值nullptr(C++11)         上期我们介绍了c++新增的两个重要语法:引用和内联函数,今

    2024年02月11日
    浏览(60)
  • C++修炼之练气期第十层——auto | 范围for | nullptr

    🌸作者简介: 花想云 ,在读本科生一枚,致力于 C/C++、Linux 学习。 🌸 本文收录于 C++系列,本专栏主要内容为 C++ 初阶、C++ 进阶、STL 详解等,专为大学生打造全套 C++ 学习教程,持续更新! 🌸 相关专栏推荐: C语言初阶系列 、 C语言进阶系列 、 数据结构与算法 本章为

    2023年04月09日
    浏览(39)
  • 【C++心愿便利店】No.3---内联函数、auto、范围for、nullptr

    👧个人主页:@小沈YO. 😚小编介绍:欢迎来到我的乱七八糟小星球🌝 📋专栏:C++ 心愿便利店 🔑本章内容:内联函数、auto、范围for、nullptr 记得 评论📝 +点赞👍 +收藏😽 +关注💞哦~ 提示:以下是本篇文章正文内容,下面案例可供参考 通过对C语言的学习,对于宏有了一定

    2024年02月11日
    浏览(42)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包