C++入门篇引用&&内联函数&&auto&&范围for&&nullptr

Posted 芒果再努力

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了C++入门篇引用&&内联函数&&auto&&范围for&&nullptr相关的知识,希望对你有一定的参考价值。

文章目录

6.引用

C语言中函数的传参有两种方式:

1.传值 2.传址

虽然这两种方式都可以实现函数传参但是却各自有着自己的优缺点:

传值:无法改变形参的值

传址:不是很形象而且不安全

在升级版C++中为了解决这种问题就使用了引用&


概念


引用不是新定义一个变量,而是给已存在变量取了一个别名

编译器不会为引用变量开辟内存空间,它和它引用的变量共用同一块内存空间,


引用的方法:

  • 类型& 引用变量名(对象名) = 引用实体;

例子1

#include<iostream>
using namespace std;
int main()

    int a = 10;
    //引用定义
    int& b = a;
    //取地址
    int* pa = &a;

    //编译器不会为引用变量开辟内存空间
    cout << "&a = " << &a << endl;
    cout << "&b = " << &b << endl;//引用变量和他引用的变量地址相同

    cout << "pa =  " << pa << endl;//pa是指针,保存的是a的地址

引用在语法层面看,我们要理解成没有开辟新空间,就是对原来的变量取了一个别名


例子

void TestRef()

    int a = 10;
    int& ra = a;//<====定义引用类型
    printf("%p\\n", &a);
    printf("%p\\n", &ra);

注意:引用类型必须和引用实体是同种类型的

//err
int main()

	int a = 10;
	double& b = a;


引用特性

  • 1.引用在定义时必须初始化
int a = 10;
int& b;//err必须初始化


  • 2.一个变量可以有多个引用-类似一个人可以有多个代号
int  a = 10;
int& b = a;
int& c = b;
int& d = a;

  • 3.引用一旦引用一个实体,再不能引用其他实体
int main()

    int a = 10;
    int& b = a;
    cout << "b = " << b << endl;
    cout << "&a = " << &a << endl;
    int c = 20;
    b = c;
    //这里是把b变成c的别名还是把c的值赋给b?
    cout << "b = " <<b<< endl;
    cout << "&b = " << &b << endl;
    return 0;

所以是把c的值赋给b ,引用一旦引用一个实体,再不能引用其他实体


  • 4.引用变量的名不能和其它变量名同名
int main()

	int a = 10;
	int& b = a;
	double b = 1.1;//err


总结:

  • 引用必须初始化
  • 一个变量可以有多个引用(就好比一个人可以有多个绰号)
  • 引用一旦引用实体,再不能引用其他实体
  • 不能建立引用数组
  • 不能建立引用的引用
  • 没有引用的指针
  • 可以取引用的地址(其实也就是取变量的地址)
  • 区别引用声明符&和地址运算符&,(出现在声明中的&是引用声明符其他的是地址运算符)

常引用

若加了const修饰的变量:称为常变量,仍是变量,但是只可读,不可写(不可修改变量的值),

case 1: 权限放大 err

//b和a占用同一块空间
const int a = 10; //a :只读
int& b = a; //b:可读可写

case2:权限不变:可以

const int a = 10;
const int& b = a;//a和b都是只读

int a = 10;
int& b = a;//a和b都是可读可写

case3:权限缩小 - 可以

int a  = 10;//a:可读可写
const int& b = a; //b:只可读

对于类型不同的变量进行引用要加const

因为类型不同的变量赋值会产生临时变量,这个临时变量是不能修改的,所以要用const修饰

int main()

    double d = 3.14;
    //int& rd = d; //err类型不同
    const int& b = d;//OK
    return 0;


总结:

int a = 10;
int& b = a;//OK   
//double& d = a;//err  
const double& d = a;//OK

b就是a的别名,类型相同的引用不会创建临时变量

double&类型的引用 只能引用double类型的变量 要引用类型必须要一致

int和double之间可以隐式转换 编译器在这个过程中生成了一个临时变量 d引用的不是a ,而是引用的是生成的临时变量,因为临时变量具有常性 所以前面要加const

结论:

1.类型不同的变量进行引用要加const

2.const Type &可以接受任何类型的对象

int a = 10;
char c = 'a';
double d = 3.14;
//const int& i1 = a;//OK
//const int& i1 = c;//OK
//const int& i1 = d;//OK

验证不同类型,引用的不是本身,而是临时变量


例子

假设x是一个大对象或者是深拷贝的对象,那么尽量使用引用传参,减少拷贝

而且如果函数中不改变传的参数,尽量使用const引用传参

//引用传参
void func(int& x)

    cout<< x <<endl;

int main()

   const int a = 10;
   const int&b = a;
   func(a);//err  a可读 引用传参给x,x是可读可写,权限放大,err
   func(10);//err 10是常数只可读


//引用传参,加上const修饰后
//x变成只可读了,权限不变,所以可以
void func(const int& x)

    cout << x << endl;

int main()

    const int a = 10;
    const int& b = a;
    func(a);  //10
    func(10); //10


#define M 10
int main()

    const int& b = M;//ok,b:只可读 M:只可读 权限不变
   // int& c = M;//err M是常数只可读,而c可读可写,权限扩大


引用的使用场景

1.引用做函数参数

case1:

//函数修饰名:_Z4swappipi
void Swap(int* p1,int* p2)//传地址

    int tmp = *p1;
    *p1 = *p2;
    *p2 = tmp;

//函数修饰名:_Z4swapii
void Swap(int r1,int r2)//传值

    int tmp = r1;
    r1 = r2;
    r2 = tmp;

//函数修饰名:_Z4swapriri
void Swap(int& r1,int& r2) //传引用

    int tmp = r1;
    r1 = r2;
    r2 = tmp;


问1:上述三个交换函数构成函数重载吗

函数修饰名不同,构成函数重载,但是Swap(x,y)调用时会存在歧义,它不知道调用的是传值还是传引用


传引用相当于把空间传过去,改变形参的内容,实参的内容也会发生改变

//r1,r2就是a,b的别名,r1,r2的改变就是改变a,b
void Swap(int& r1, int& r2) //传引用

    int tmp = r1;
    r1 = r2;
    r2 = tmp;

int main()

    int a = 1;
    int b = 2;
    cout << "a =  "<< a<<" b = "<<b << endl;
    Swap(a, b);
    cout << "a =  " << a << " b = " << b << endl;
    return 0;


case2:二级指针 = = 传指针的引用

首先要知道:

函数内要改变整形变量的值:传一级指针

要改变一级指针的内容:传二级指针

但是使用指针的引用就不用这么麻烦,改变一级指针,只需要传一级指针的引用即可

//传一级指针
void func1(int* pa)

	pa = (int*)malloc(sizeof(int)*4);

//传二级指针
void func2(int** ppa)

	*ppa = (int*)malloc(sizeof(int) * 4);

//传引用
void func3(int*& pa)

	pa = (int*)malloc(sizeof(int) * 4);

int main()

	int* p = NULL;
	cout << "p = " << p << endl; //NULL

	func1(p);//传一级指针
	cout << "p = " << p << endl;

	func2(&p);//传二级指针
	cout << "p = " << p << endl;

	func3(p);//传引用
	cout << "p = " << p << endl;
	return 0;

函数内部为p开辟一块空间

传二级指针和传一级指针引用都可以改变一级指针的内容


2.引用做返回值

首先,我们要知道:所有的传值返回都会生成临时变量(临时拷贝)

临时变量 (临时拷贝存在哪里)

  • 如果返回的变量比较小(4/8个字节),一般是寄存器eax充当临时变量
  • 如果返回的变量比较大(如:结构体),临时变量存放在调用该函数的栈帧中

例子

//传值返回
int Add(int x, int y)

	int c = x + y;
	return c;

int main()

	int ret = Add(1, 2);
	cout << "ret = " << ret << endl;//3
	return 0;


假设用传引用返回

引用返回的含义:不会生成c的拷贝返回,直接返回c的引用

传值返回:返回对象会拷贝给临时对象,临时对象做返回,现在用传引用返回,返回的是返回对象的引用(别名)

int& Add(int x, int y)

	int c = x + y;
	return c;

int main()

	int ret = Add(1, 2);
	cout << "ret = " << ret << endl;

当前代码的问题:

  • 1.存在非法方法,因为Add函数返回的值是c的引用,所以Add函数栈帧销毁之后,会去访问c位置的空间取值
  • 2.如果Add函数栈帧销毁,清理空间,那么取c的值的时候就是随机值,给ret的就是随机值,这个取决于编译器的实现
    • 如果后序没有新的函数栈帧开辟或者新的函数栈帧不足以覆盖c的内容,得到的还是c的值,否则就是随机值

tmp是c的别名,相当于返回c的引用,如果c的空间被清掉,c的值变成随机值,ret的值就会是随机值


如:后面的函数栈帧把原来c的空间被覆盖了

int& Add(int x,int y)

    int c = x + y;
    return c;

int main()

    int& ret = Add(1,2);//ret也是c的引用
    cout << "ret = " <<ret <<  endl;
    printf("11111\\n");
    cout << "ret = " << ret << endl;
    return 0;

注意:此时ret也是c的引用

printf也是函数,会把原来c变量空间的栈帧覆盖,导致ret的值为随机值


注意:如果函数返回时,出了函数作用域,如果返回对象还未还给系统,则可以使用引用返回,如果已经还给系统了,则必须使用传值返回,

返回引用的话效率高 不用创建临时变量 只要返回的实体不会随着函数结束而销毁的话 都可以以引用的方式返回

通俗点说:就是出了作用域,变量还在的,就可以用引用的方式,可以提高效率


例子1:static的变量

//传引用返回
int& Count()

    //n放在静态区,出了函数栈帧也不销毁,所以可以使用传引用返回
    static int n = 0;
    n++;
    return n;

int main()

    int a = Count();
    cout << "a = " << a << endl; //1

    a = Count();
    cout << "a = " << a << endl; //2
    return 0;


例子2:

//传引用返回
char& func(char* str, int i)

    return str[i];

int main()

    char arr[10] = "Mango";
    char c = func(arr, 3);
    cout << "c = " << c << endl;//g
    c = func(arr, 2);
    cout << "c = " << c << endl;//n

出了作用域,str[i]的空间没有被销毁,所以可以用传引用返回,str[i]这个是数组的空间

str[i]不是局部变量 局部变量是在函数中创建的 str[i]不是在函数中创建的


例子3

//方式1: ok
int& fun()

    int* p =(int*)malloc(sizeof(int));
    return *p;

//方式2: err
int*& fun()

    int* p =(int*)malloc(sizeof(int));
    return p;

方式1是正确的,方式2是错误的!

原因:p是局部变量,出了作用域就销毁了,但是*p(malloc出来的空间还在),所以 return *p可以,return p 不可以


例子4:用引用返回实现可读可写

#define N 5
int& func(int i)

	static int a[N];
	return a[i];//返回的是a[i]的别名

int main()

	//读
	for (size_t i = 0; i < N; i++)
	
      //func[i]返回的是a[i]的别名
      //相当于a[i] = i + 1
		func(i) = 1 + i;
	
	//写
	for (size_t i = 0;i < N;i++)
	
 		//func[i]返回的是a[i]的别名
       //相当于打印a[i]对应的值
		cout << func(i) << " " ; // 1 2 3 4 5
	
	return 0;


注意:若把引用取消就会报错


原因:此时是值返回,会生成一个临时变量,返回的是a[i]的临时变量,临时变量具有常性(是右值:不可以被修改)


右值:表达式的返回值,常量,可以认为是右值

右值的特点:右值不能被修改,如果引用一个一直,要用const修饰

普通引用引的就是左值,const引用引的是右值

例子1:


例子2:


例子3:表达式的返回值也是右值

int x1 = 1;
int x2 = 2;
int& r = x1+x2;


所以要写成:

const int& r = x1+x2;

传值,传引用的效率比较

以值作为参数或者返回值类型,在传参和返回期间,函数不会直接传递实参或者将变量本身直接返回,而是传递实参或者返回变量的一份临时的拷贝,

因此用值作为参数或者返回值类型,效率是非常低下的,尤其是当参数或者返回值类型非常大时,效率就更低


测试代码
//传值传参和传引用传参的效率对比
#include <time.h>
struct A int a[10000]; ;
void TestFunc1(A a)
void TestFunc2(A& a)
void TestRefAndValue()

    A a;
    // 以值作为函数参数
    size_t begin1 = clock();
    for (size_t i = 0; i < 10000; ++i)
        TestFunc1(a);
    size_t end1 = clock();
    // 以引用作为函数参数
    size_t begin2 = clock();
    for (size_t i = 0; i < 10000; ++i)
        TestFunc2(a);
    size_t end2 = clock();
    // 分别计算两个函数运行结束后的时间
    cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
    cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;


值和引用作为返回值类型的性能比较

测试代码
//传值返回和传引用返回的对比
#include <time.h>
struct A int a[10000]; ;
//a是全局结构体变量,出了函数还在,所以可以使用传引用返回
A a;//a的大小为4W字节 
// 值返回 - 传值返回都会生成临时变量(临时拷贝),每次拷贝4W字节
A TestFunc1()  return a;
// 引用返回 - 没有拷贝
A& TestFunc2() return a;
void TestReturnByRefOrValue()

    // 以值作为函数的返回值类型
    size_t begin1 = clock();
    for (size_t i = 0; i < 100000; ++i)
        TestFunc1();
    size_t end1 = clock();
    // 以引用作为函数的返回值类型
    size_t begin2 = clock();
    for (size_t i = 0; i < 100000; ++i)
        TestFunc2();
    size_t end2 = clock();
    // 计算两个函数运算完成之后的时间
    cout << "TestFunc1 time:" << end1 - begin1 << endl;
    cout << "TestFunc2 time:" << end2 - begin2 << endl;


传值和指针在作为传参以及返回值类型上效率相差很大,


==总结:==引用的作用主要体现在传参和传返回值

  • 1.引用传参和传返回值,有些场景下面,可以提高性能(大对象+ 深拷贝对象)

  • 2.引用传参和传返回值,输出型参数和输出型返回值,通俗来说,有些场景下,形参的改变可以改变形参(传引用,二者占用同一块空间),有些场景下,引用返回,可以改变返回对象

  • 不能返回栈空间上的引用

  • 传值,传地址,传引用的效率比较

    引用>地址>值


引用和指针的区别

在语法概念上引用就是一个别名,没有独立空间,和其引用实体共用同一块空间


在底层实现上实际是有空间的,因为引用是按照指针方式来实现的,


  • 引用和指针的汇编代码对比
int main()

    int a = 10;
    int& ra = a;
    ra = 20;
    int* pa = &a;
    *pa = 20;
    return 0;

<

以上是关于C++入门篇引用&&内联函数&&auto&&范围for&&nullptr的主要内容,如果未能解决你的问题,请参考以下文章

C++入门语法第一篇:(命名空间缺省参数函数重载引用内联函数)

C++引用,内联函数,函数重载二义性总结_C++

c++基础篇——c++快速入门(下)

C++入门基础

超详细的C++入门学习(命名空间,缺省参数,内联函数,函数重载等)

C++入门(命名空间,缺省参数,函数重载,引用,内联函数,auto,范围for)