轻松搞定C++3 C++对C语言的拓展 引用

一 引用

1.1 变量名

变量名实质上是一段连续存储空间的别名，是一个标号(门牌号) 
通过变量来申请并命名内存空间. 
通过变量的名字可以使用存储空间. 

1.2 引用的概念

变量名，本身是一段内存的引用，即别名(alias).  引用可以看作一个已定义变量的别名。

1.3 规则

1  引用没有定义,是一种关系型声明。声明它和原有某一变量(实体)的关系。故  而类型与原类型保持一致,且不分配内存。与被引用的变量有相同的地址。  
2  声明的时候必须初始化,一经声明,不可变更。 
3  可对引用,再次引用。多次引用的结果,是某一变量具有多个别名。  
4  &符号前有数据类型时,是引用。其它皆为取地址。

1.4 引用作为函数参数

普通引用在声明时必须用其它的变量进行初始化，引用作为函数参数声明时不进行初始化。

#include  <iostream> 
using  namespace  std; 
struct  Teacher 
{ 
    char  name[64]; 
    int  age  ; 
}; 
void  printfT(Teacher  *pT) 
{ 
    cout<<  pT-­‐>age  <<endl; 
} 
//pT是t1的别名  ,相当于修改了t1 
void  printfT2(Teacher  &pT) 
{ 
    pT.age  =  33; 
    cout<<pT.age<<endl; 
} 
//pT和t1的是两个不同的变量 
void  printfT3(Teacher  pT) 
{ 
    cout<<pT.age<<endl; 
    pT.age  =  45;  //只会修改pT变量  ,不会修改t1变量 
} 
int  main(void) 
{ 
    Teacher  t1; 
    t1.age  =  35; 
    printfT(&t1); 
    printfT2(t1);  //pT是t1的别名 
    printf("t1.age:%d  \n",  t1.age);  //33 
    printfT3(t1)  ;//  pT是形参  ,t1  copy⼀一份数据  给pT 
    printf("t1.age:%d  \n",  t1.age);  //33 
    return  0; 
} 

1.5 引用的意义

1）引用作为其它变量的别名而存在，因此在一些场合可以代替指针
2）引用相对于指针来说具有更好的可读性和实用性 

c++中引入引用后,可以用引用解决的问题。避免用指针来解决。 

1.6 引用的本质

1）引用在C++中的内部实现是一个常指针 
 Type&  name     <===>     Type*  const  name 
2）C++编译器在编译过程中使用常指针作为引用的内部实现，因此引用所占用的空间大小与指针相同。 
3）从使用的角度，引用会让人误会其只是一个别名，没有自己的存储空间。这是C++为了实用性而做出的细节隐藏。 

引用在实现上，只不过是把：间接赋值成立的三个条件的后两步和二为一. 当实参传给形参引用的时候，只不过是c++编译器帮我们程序员手工取了一个实参地址，传给了形参引用（常量指针）。

1.7 引用作为函数的返回值（引用当左值）

当函数返回值为引用时,
若返回栈变量:不能成为其它引用的初始值（不能作为左值使用）

include  <iostream> 
using  namespace  std; 
int  getA1() 
{ 
    int  a; 
    a  =  10; 
    return  a; 
} 
int&  getA2() 
{ 
    int  a; 
    a  =  10; 
    return  a; 
} 
int  main(void) 
{ 
    int  a1  =  0; 
    int  a2  =  0; 
    //值拷⻉贝 
    a1  =  getA1(); 
    //将⼀一个引用赋给⼀一个变量，会有拷⻉贝动作 
    //理解：  编译器类似做了如下隐藏操作，a2  =  *(getA2()) 
    a2  =  getA2(); 
    //将⼀一个引⽤用赋给另一个引⽤用作为初始值，由于是栈的引用，内存非法 
    int  &a3  =  getA2(); 
    cout  <<"a1  =  "  <<a1<<endl; 
    cout  <<"a2  =  "  <<a2<<endl; 
    cout  <<"a3  =  "  <<a3<<endl; 
    return  0; 
} 

当函数返回值为引用时,

若返回静态变量或全局变量
可以成为其他引用的初始值（可作为右值使用，也可作为左值使用）

#include  <iostream> 
using  namespace  std; 
int  getA1() 
{ 
    static  int  a; 
    a  =  10; 
    return  a; 
} 
int&  getA2() 
{ 
    static  int  a; 
    a  =  10; 
    return  a; 
} 
int  main(void) 
{ 
    int  a1  =  0; 
    int  a2  =  0; 
    //值拷⻉贝 
    a1  =  getA1(); 
    //将⼀一个引用赋给一个变量，会有拷⻉贝动作 
    //理解：  编译器类似做了如下隐藏操作，a2  =  *(getA2()) 
    a2  =  getA2(); 
    //将⼀一个引⽤用赋给另一个引⽤用作为初始值，由于是静态区域，内存合法 
    int  &a3  =  getA2(); 
    cout  <<"a1  =  "  <<a1<<endl; 
    cout  <<"a2  =  "  <<a2<<endl; 
    cout  <<"a3  =  "  <<a3<<endl; 
    return  0; 
} 

引用作为函数返回值，

如果返回值为引用可以当左值, 如果返回值为普通变量不可以当左值。

#include  <iostream> 
using  namespace  std; 
//函数当左值 
//返回变量的值 
int  func1() 
{ 
    static  int  a1  =  10; 
    return  a1; 
} 
//返回变量本⾝身  ,  
int&  func2() 
{ 
    static  int  a2  =  10; 
    return  a2; 
} 
int  main(void) 
{ 
    //函数当右值 
    int  c1  =  func1(); 
    cout  <<  "c1  =  "  <<  c1  <<endl; 
    int  c2  =  func2();  //函数返回值是⼀一个引用,并且当右值  
    cout  <<  "c2  =  "  <<  c2  <<endl; 
    //函数当左值 
    //func1()  =  100;     //error 
    func2()  =  100;       //函数返回值是⼀一个引用,并且当左值  
    c2  =  func2(); 
    cout  <<  "c2  =  "  <<  c2  <<endl; 
    return  0; 
} 

总结:

当函数返回值为引用时,

1)若返回栈变量:不能成为其它引用的初始值（不能作为左值使用）

2)若返回静态变量或全局变量 可以成为其他引用的初始值（可作为右值使用，也可作为左值使用）

3)如果返回值为引用可以当左值, 如果返回值为普通变量不可以当左值。

1.8 指针引用

常量的二级指针

#include  <iostream> 
using  namespace  std; 
struct  Teacher 
{ 
    char  name[64]; 
    int  age  ; 
}; 
//在被调⽤用函数  获取资源  
int  getTeacher(Teacher  **p) 
{ 
    Teacher  *tmp  =  NULL; 
    if  (p  ==  NULL) 
    { 
        return  -‐1; 
    } 
    tmp  =  (Teacher  *)malloc(sizeof(Teacher)); 
    if  (tmp  ==  NULL) 
    { 
        return  -‐2; 
    } 
    tmp-‐>age  =  33; 
    //  p是实参的地址   *实参的地址  去间接的修改实参的值 
    *p  =  tmp; 
    return  0; 
} 
//指针的引⽤用  做函数参数 
int  getTeacher2(Teacher*  &myp) 
{ 
    //给myp赋值  相当于给main函数中的pT1赋值 
    myp  =  (Teacher  *)malloc(sizeof(Teacher)); 
    if  (myp  ==  NULL) 
    { 
        return  -­‐1; 
    } 
    myp-­‐>age  =  36; 
    return  0; 
} 
void  FreeTeacher(Teacher  *pT1) 
{ 
    if  (pT1  ==  NULL) 
    { 
        return  ; 
    } 
    free(pT1); 
} 
int  main(void) 
{ 
    Teacher  *pT1  =  NULL; 
    //1  c语⾔言中的二级指针 
    getTeacher(&pT1); 
    cout<<"age:"<<pT1-‐>age<<endl; 
    FreeTeacher(pT1); 
    //2  c++中的引⽤用  （指针的引⽤用） 
    //引⽤用的本质  间接赋值后2个条件  让c++编译器帮我们程序员做了。      
    getTeacher2(pT1); 
    cout<<"age:"<<pT1-‐>age<<endl; 
    FreeTeacher(pT1); 
    return  0; 
} 

1.9 const 引用

const  引用有较多使用。它可以防止对象的值被随意修改。因而具有一些特性:

(1)const  对象的引用必须是  const  的,将普通引用绑定到  const  对象是不合法的。这个原因比较简单。既然对象是  const  的,表示不能被修改,引用当然也不  能修改,必须使用  const  引用。

(2)const  引用可使用相关类型的对象(常量,非同类型的变量或表达式)初始化。引用必须初始化

1.10 const 引用的原理

const  引用的目的是,禁止通过修改引用值来改变被引用的对象。const 引用的  初始化特性较为微妙,可通过如下代码说明: 

double  val  =  3.14; 
const  int  &ref  =  val; 
double  &  ref2  =  val; 
cout<<ref<<"  "<<ref2<<endl; //3 3.14
val  =  4.14; 
cout<<ref<<"  "<<ref2<<endl; //3 4.14

因为const 引用相关对象时会生成一个新的对象.

#include  <iostream> 
using  namespace  std; 
int  main(void) 
{ 
    //1>  ⽤用变量  初始化  常引⽤用 
    int  x1  =  30; 
    const  int  &y1  =  x1;  //⽤用x1变量去初始化  常引⽤用 
    //2>  ⽤用字⾯面量  初始化  常量引⽤用 
    const  int  a  =  40;   //c++编译器把a放在符号表中 
    //int  &m  =  41;  //error  ,  普通引⽤用  引⽤用⼀一个字⾯面量  请问字⾯面量有没有内存地址 
    const  int  &m  =  43;   //c++编译器  会  分配内存空间  
                        //  int  temp  =  43 
                        //  const  int  &m  =  temp; 
    return  0; 
}

结论：
1）const int & e 相当于 const int * const e
2）普通引用 相当于 int *const e
3）当使用常量（字面量）对const引用进行初始化时，C++编译器会为常量值
分配空间，并将引用名作为这段空间的别名
4）使用字面量对const引用初始化后，将生成一个只读变量