【C++入门】引用详解（引用的特性、引用的使用、引用与指针的区别）(c++引用详解)

java8

帖子摘要：文章目录 1 引用概念2 引用特性3 使用场景4 常引用5 传值与传引用的效率比较5.1 值和引用作为函数参数的性能比较5.2 值和引用作为返回值类型的性能比较  6 引用和指针的区别  1 引用概念......
: O. L) i" T* o9 G( @0 {, B6 `2 d
大家好，欢迎来到Java吧（www.java8.com），交流、学习Java技术、获取Java资源无任何套路，今天说一说：“【C++入门】引用详解（引用的特性、引用的使用、引用与指针的区别）”


        
               
                    
1 C) W# {# b+ R                        
* c& d  i7 K+ W; j8 D7 f                    
3 n6 \* z% k9 S% U) F! G                    
/ ~7 C; B! G6 k; E* r( y 文章目录

1 引用概念

2 引用特性

3 使用场景

4 常引用

5 传值与传引用的效率比较

5.1 值和引用作为函数参数的性能比较

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

6 引用和指针的区别

9 e. |, i  \" ^+ c' [: R
7 o" }  W  \% ], c0 K, `/ Q1 引用概念
* B* f& [  ]+ i1 ?+ W
引用不是新定义一个变量而是给已存在的变量取了一个别名编译器不会为引用变量开辟内存空间它和它引用的变量共用一块内存空间。
格式引用类型& 引用变量名对象名 = 引用实体
: [% m: e* O( Y" J 注意 引用类型和引用实体是同种类型的。


引用示例
" G+ U; l7 C2 G
) b" ~, [, D) d" Q; h$ }
' u8 S- j; S, c% z+ V+ T
5 q+ P) x5 z# k7 f
2 引用特性
[ol]

引用在定义时必须初始化
. d6 F) v/ K5 |4 s& \* ? 示例

$ m+ x8 F: e5 {9 n8 U# z2 W
$ U# q4 t( D; z/ D, P; R& J/ N  Z# i

一个变量可以有多个引用也可以对引用再进行引用或者说可以为变量取多个别名也可以为别名再取别名
% C" v9 }) T1 K) ]/ n/ ]! [ 示例


2 g. q* F2 `: \- f, f

引用一旦引用一个实体就不能再引用其它实体[/ol]
, v( B: B7 i1 V' L, J
$ K( c; x, f6 q3 }
$ i" t* T0 e/ l3 }: h
( s# t$ _6 Z% X$ C5 Z& m3 使用场景
8 Y2 Z- \( \3 ~) C6 j[ol]

引用做参数[/ol]

void Swap(int& num1, int& num2)
{
        int temp = num1;
        num1 = num2;
        num2 = temp;
5 l( \# A9 g2 |! u
}
+ m; D( k1 w  e) J2 G
复制代码

引用做返回值[/ol]
前言传值返回
/ P# ?# _2 r# M

当用值作为返回值时不是直接将变量返回而是返回变量的一份临时拷贝临时变量。考虑到对于函数中的局部变量在调用完函数时即被销毁此时需要返回的变量也会被销毁空间不再属于该变量因此选择在销毁前将变量值拷贝到一个临时变量中这个临时变量一般由寄存器4/8个字节大小充当如eax如果返回值过大则会选择在上层栈帧中创建临时变量再将临时变量作为返回值返回。


0 A  I+ a3 o) X! K

那如果作为返回值的变量出作用域后不会被销毁那还会产生临时变量吗事实上编译器不管需要返回的变量出作用域后会不会被销毁在返回时都会产生临时变量。
6 ?9 G# P  ]' Y# Y. \

! O$ n- \8 }2 Z( D4 o

$ T' ^' M, ]& w' j& C& \传引用返回

2 K/ N, F. A. ^5 D4 u$ w3 N; x2 G

那既然需要返回的变量都不会被销毁将其再拷贝到临时变量中是不是麻烦了些因此在下面我们以引用作为返回值但这不是说就不会创建临时变量了临时变量依然会被创建但这个临时变量相当于返回变量的一个别名因为该变量出作用域后不会被销毁因此我们依然可以进行访问此时临时变量与返回变量共用一块空间相比于传值返回中间就减少了拷贝的过程返回时同样将临时变量赋值给接收的变量即可可以认为传引用返回就相当于将变量直接返回了。

& o* p( b6 b% F( I- L$ k1 j9 o' @
5 u3 f2 ~/ F- V$ P! m
; A4 |2 k: p1 S# f" v9 T+ C# H 下面再看一段示例代码
  X) E& h. E8 t' v% E6 S' }9 I

int& Add(int a, int b)
{
* k, v6 j. Y6 N' m% W
        int c = a + b;
        return c;
& _5 R8 |' N! M2 O* V+ W
}
2 f1 k, T+ g9 R! {2 q
int main()
{
        int& ret = Add(1, 2);
        Add(3, 4);
        cout  
示例输出结果
  q! w2 a( A4 ^+ j0 T
 
: \$ `, P2 C& v  B- o( g& L
[img]/295380211e044714a055a86bee97be3c.png[/img]
 
2 `6 P, l7 V0 H' b; x( B5 T
 
" K# I+ B( a% f, z
[b]说明对于以出了作用域即被销毁的变量作为返回值的如果使用传引用返回实际上是无意义的因为局部变量的空间已被销毁不再属于该变量再通过传引用返回的别名去访问该空间时其值是不确定的无法确保得到的还是正确结果。[/b]
; m7 t8 Y6 G5 J- X2 }, ]  _: m7 t8 r. w
 
2 v8 r2 R/ G3 f! W4 k* V
[img]/8d0e2362b3814b1ea6094fb032a52fe7.png[/img]
 
 
[b] 
 [b]注意如果函数返回时出了函数作用域如果返回对象还在空间还没还给系统如静态变量、全局变量、上一层栈帧中的变量、malloc开辟的等等则可以使用引用返回否则必须使用传值返回。[/b]
 
[/b] 
( Y: x* e6 T1 U  H9 o2 h! b/ E
[u][*]传引用返回还可修改返回值。
2 x% b8 n& q3 q% |8 ]) C" Z; y# l
 示例代码[/u] 
[code]#define N 10
typedef struct Array {
        int a[N];
% V1 `( E! H! K) N
        int size;
}AY;
% Q: N  k7 ?/ A% ?* O" u% Q! n
//查找数组中某个下标位置的元素
: U, L9 S- S9 ~" `
int& PosAt(AY& ay, int i) {
. A3 T# z2 ^; r# Q
        assert(i  
3 i9 t: Y7 [' G) d, Q$ s6 r
示例输出结果
! x4 j, Y2 A* s& q1 Q
 
) z$ r: ~* ~$ t) N& h( j7 A+ Y
[img]/17e2e59d104a4d93a20bf8bbc6305bd6.png[/img]
% {1 T; R$ j+ }: u/ ]
 
 
4 常引用 
/ Q5 x& Z% A! n/ }) d  |: q) s4 {
[b] 
% q( u) }9 x# m" b
 [b]指针和引用在赋值和初始化时权限可以保持或缩小但不能放大。[/b]
/ q# L4 G# M1 u4 O. @/ c
 
$ r" j: E1 f' ~7 q
[/b] 
* L* ?6 G- l% }5 @" `
示例代码
 
[code]//传值返回
4 Z4 c1 U/ `  y% ]
int Count() {
1 D8 F9 p% ~; k) c( J
        int n = 0;
        n++;
        return n;
, V6 ]" @2 a$ [: z4 X
}
void TestConstRef() {
1 j2 S1 p9 h1 ?" x- X
        //示例1
# l) A7 C# N  ^& n
        const int a = 10;//const修饰的变量具有常属性不可修改
        //错误语法权限被放大。ra引用与a共用一块空间而a具有常属性
% ]: ~2 N* M+ k+ M0 P1 v! O8 y
        //如果ra引用不具有常属性则修改ra的值时则违背了a的常属性
5 }" {8 @% g6 ?2 I; N! H
        //int& ra = a;//编译时会报错
9 I1 S7 n; H, |+ u
        const int& ra = a;//正确语法
; P& i8 g4 p/ l; h2 k
        //示例2
        //int& b = 10;//错误语法10为常量引用权限放大
        const int& b = 10;//正确语法使引用变量b也具有常属性
. q. Q# j* h3 n! V: I" _$ t
        //示例3
" L' X/ D2 e7 a# H7 m5 z
        //Count函数是传值返回的返回的是临时变量临时变量具有常属性
        //int& ret = Count();//编译报错
  x7 c3 y) Q* I. o0 ^3 |; z- T
        const int& ret = Count();//正确语法ret为返回的临时变量的常引用
# w8 M! n, F+ B( m4 u
        int ret2 = Count();//正确语法将返回的临时变量赋值给ret2
" h% R) d( H& _0 z7 q
        //示例4
        double d = 3.14;
        //int& rd = d;//编译报错引用类型与引用实体不是同一种类型
( S2 a. t* v2 W  A3 g0 q5 Q
        //解释
0 K( q$ W4 ]1 X
        //在进行类型转换无论是强制类型转换还是自动类型提升时都会产生临时变量
        //如有int i = 0; (double)i其并不是直接将int型变量i转换为double型
+ N7 C* E; Y* d6 j6 A2 K0 b: g9 |
        //而是通过一个临时变量将i转化为double如果是double d = i;则是再将临时变量赋值给d
        
/ m0 j( W: t* I1 z, ^. @' I
        //下句代码则表示rd为double型变量d强制转换为int型变量时产生的 临时变量 的常引用
        //但注意rd本质上并不是d的引用二者也不是共用一个空间
        //d仍是double型变量rd则为int型
        const int& rd = d;//编译通过
0 t% Q1 G& ~; Q1 P+ t* S
        printf("d = %f\nrd = %d\nd的地址为%p\nrd的地址为%p\n", d, rd, &d, &rd);
}
int main() {
        TestConstRef();
% G4 p7 s0 G- L2 U- K, ~5 _
        return 0;
}
0 P5 h4 H' @  F) K
复制代码

: @7 s1 _0 C. \( O. ?1 L; l- ]* X
' _8 t6 ^/ S, H8 R6 w7 }
3 _; Z! N2 c% ~: ]: _9 B1 D/ j
5 传值与传引用的效率比较
( B4 o9 P8 X5 J9 o+ z7 s& c! n
2 T) z+ O2 f4 Q8 ]; Y 以值作为参数或者返回值类型在传参和返回期间函数不会直接传递实参或者将变量本身直接返回而是传递实参或者返回变量的一份临时拷贝因此用值作为参数或返回值类型效率是非常低下的尤其是当参数或者返回值类型非常大时效率就更低了。
. |  O8 S: T, N$ c

, a7 T1 _% o3 C( j& K下面用两段测试代码来比较传值与传引用的效率

5.1 值和引用作为函数参数的性能比较
: U% d5 G3 l4 ?测试代码

#include [i]
using namespace std;
#include 
struct A { int a[100000]; };
void TestFunc1(A a) {}
; x  l, M; h& H0 [. W
void TestFunc2(A& a) {}
void TestRefAndValue()
8 C0 |; i# S' J" U  w
{
        A a;
        // 以值作为函数参数
        size_t begin1 = clock();
        for (size_t i = 0; i  
测试结果
 
[img]/f224be09a82d4d1abdf3c5bc084d084d.png[/img]
+ [* z& @$ m* w  ?4 T
 分析从测试结果来看值作为参数的函数运行时间要比引用作为参数的函数运行时间多得多以引用作为参数能很好提升程序运行效率。
 
* A$ g7 T* v' q4 U
 
[size=5]5.2 值和引用作为返回值类型的性能比较[/size] 
; R3 N- Z9 |/ x1 l: c1 ?
测试代码
( a: r  W: p, S) _4 V" n
 
- L2 n; R* T$ y. f+ d; Q# H
[code]#include [i]
using namespace std;
#include 
struct A { int a[10000]; };
A a;
// 值返回
1 P6 T$ w2 h2 m& F
A TestFunc1() { return a; }
// 引用返回
) g9 ~. }/ r  E5 w$ D& \9 n* s
A& TestFunc2() { return a; }
void TestReturnByRefOrValue()
{
        // 以值作为函数的返回值类型
        size_t begin1 = clock();
2 s% }- ]# `" r* N+ h. F( w
        for (size_t i = 0; i  
测试结果
 
[img]/313208fbe306450091e11f3460c7b2c8.png[/img]
 分析从测试结果来看值作为返回值类型的函数运行时间要比引用作为返回值类型的函数运行时间多得多以引用作为返回值类型能很好提升程序运行效率。
 
1 ]% ?* N$ V% z3 H  O1 Q
 
6 引用和指针的区别 
[u][*]在 [code]语法概念上
复制代码

引用就是一个别名没有独立空间和其引用实体共用一块空间。而指针是有开辟独立空间的空间中存放的是指向的变量的空间地址。
示例代码

int main()
{
& b( k+ {- U1 ~6 J# B* ^3 Z
        int a = 10;
( h- a; T7 W+ `/ Q! s
        int& ra = a;//引用a
# B5 i4 C% b' i) B0 U5 G3 F
        int* pa = &a;//指向a
        cout  
示例输出结果
4 |, G. _  T1 d
 
7 k6 R6 b! Z5 N8 l" r
[img]/52b0034359af40f1935cb383deaedcc3.png[/img]
, ]/ U& }9 T* ^
 
 
[u][*]引用在 [code]底层实现上
复制代码

实际是有空间的因为引用是按照指针方式来实现的。
; ?( v* o+ U) I% M! F9 G 示例代码
7 n  Z8 X  p$ i' I' s

int main()
{
% n# Y3 _/ {' Z& [2 W
        int a = 10;
        int& ra = a;
        ra = 20;
# i+ ~4 f0 U' K7 K) R. S2 {
        int* pa = &a;
        *pa = 20;
! ?! N. H7 m5 D- N
        return 0;
8 H- {( e0 R; H) i. M
}
6 _/ c  Y+ W. T4 j8 H- W. s5 q
复制代码

进入调试通过反汇编查看引用和指针的汇编代码对比发现**在汇编代码中引用和指针的实现相同都是开辟了独立的空间将指向变量的地址赋值给了引用变量或指针变量。**
9 P  S7 M- d& x3 Z* c* ^2 G# v
1 q4 c/ ?  i/ e; W
+ h; m+ N2 V! i
/ p# P$ S9 ~8 m, @* q- E引用和指针的不同点
- G5 @* ^- o7 m  ]
[ol]

引用在概念上是定义一个变量的别名指针则是存储一个变量的地址。

引用在定义时必须初始化指针则没有要求。

引用在初始化时引用一个实体后就不能再引用其它实体而指针可以在任何时候指向任何一个同类型实体。

没有NULL引用但有NULL指针。

在

sizeof
复制代码

中的含义不同引用结果为引用类型的大小但指针始终是地址空间所占字节个数32位平台下占4个字节。

引用自加即引用的实体增加1指针自加即指针向后偏移一个所指向实体类型的大小。

有多级指针但没有多级引用。

访问实体方式不同指针需要显示解引用引用是由编译器自己处理。

引用比指针使用起来相对安全。不会有类似空指针等的问题。[/ol]
7 A$ o0 l! {" ~, p1 {% K, O+ R
& K. v* m; x  w; [/ {; r7 ~以上是我对C++中引用相关的一些学习记录总结如有错误希望大家帮忙指正也欢迎大家给予建议和讨论谢谢
               
$ e, u3 Y6 T" p; Q% N, J               
               
本文来源csdn，由Java吧转载发布，观点不代表Java吧的立场，转载请标明来源出处：https://www.java8.com