C/C++高阶语法：引用

1、C++中的引用：引用是C++中引入的新特性，开发的过程中起着重要的作用。

2、引用的声明以及定义：

       引用就是对象的另一个名字。在实际程序中，引用主要用作函数的形参。引用是一种复合类型，通过在变量名前添加&符号来定义。

       引用必须用与该引用同类型的对象初始化。

<pre name="code" class="cpp">int   var = 12;
int  &num = var;//没问题，将int型的引用指向int型的对象
char &ch = var; //错误，char类型的对象不能指向int型的对象
char &chNew;    //错误，引用一经定义必须初始化

 3、引用就是它绑定的对象的另一个名字。

       当引用初始化之后，只要改引用存在，它就保持绑定到初始化时指向的对象，不可能将引用绑定到另一个对象.   

int var = 12; //定义一个int型的对象
int &num = var; //将num指向var，此时num只是var的别名
num =  14;  //修改num的值，此时也就是直接修改var的值，此时var = 14

int data = 23; 
num = data;//你进行此举或许是想将num指向data，但是不能达到你想要的效果。该语句就是讲data的拷贝赋值给num，也就是将data的拷贝赋值给var，此时var = 23.

4、引用在实际中的作用就是和函数结合起来，首先看一下引用做函数参数。

void swap(int &,int &);

      这是每个教材上都会讲到的，确实，引用在函数中差不多就是这样用的。

     

#include <iostream>

using namespace std;

void swapRef(int &lhr,int& rhr)
{
    int temp = lhr;
    lhr = rhr;
    rhr = temp;
}

void swapCopy(int lho,int rho)
{
    int temp = lho;
    lho = rho;
    rho = temp;
}

void swapPointer(int *lhp,int *rhp)
{
    int temp = *lhp;
    *lhp = *rhp;
    *rhp = temp;
}

int main()
{
    int a = 12;
    int b = 23;

        cout<<"Before Swap:"<<endl;
    cout<<"a="<<a<<" "<<"b="<<b<<endl;


    cout<<"Apply reference:"<<endl;
    swapRef(a,b);
    cout<<"a="<<a<<" "<<"b="<<b<<endl;


    cout<<"Apply Copy:"<<endl;
    swapCopy(a,b);
    cout<<"a="<<a<<" "<<"b="<<b<<endl;


    cout<<"Apply Pointer:"<<endl;
    swapPointer(&a,&b);
    cout<<"a="<<a<<" "<<"b="<<b<<endl;

    return 0;
}

 运行的结果如图所示：

   可以看到：

          1）、通过引用能够交换a和b的值，这也间接证实了引用是对象的另一个名字。

          2）、想要通过拷贝（形参是实参的拷贝）来再次交换a和b的值，不能够实现

          3）、能够通过指针来交换a和b的值

5、在C++中引用当然还是在类中的使用，引用不仅能够做函数参数，还能返回引用

       首先附上源码供大家鉴赏

#include <iostream>
#include <string>
#include <string.h>
using namespace std;

class Teacher
{
private:
    char *pName;
    string  addr;
    double income;
public:
    Teacher():pName(NULL),addr(" "),income(0.0)
    {

    }

    //析构函数
    ~Teacher();

    //拷贝构造函数
    Teacher(const Teacher &m_Teacher);

    //赋值操作符
    Teacher& operator = (const Teacher &m_Teacher);

    //输出操作符重载
    friend ostream & operator<<(ostream &out,const Teacher&m_Teacher);

    void SetName(const char* pCh)
    {
        pName = new char[12];
        strcpy(pName,pCh);
    }

    void SetIncom(const double &db_Income)
    {
        income = db_Income;
    }

    void SetAddress(const string &str)
    {
        addr = str;
    }
};

Teacher::Teacher(const Teacher &m_Teacher)
{
    this->addr = m_Teacher.addr;
    this->income = m_Teacher.income;

    if(NULL != m_Teacher.pName)
    {
        int m_Lenth = strlen(m_Teacher.pName);
        pName = new char[m_Lenth];
        if(NULL != pName)
            strcpy(pName,m_Teacher.pName);
    }
}

Teacher& Teacher::operator=(const Teacher &m_Teacher)
{
    if(this != &m_Teacher)
    {
        this->addr = m_Teacher.addr;
        this->income = m_Teacher.income;

        if(NULL != m_Teacher.pName)
        {
            int m_Lenth = strlen(m_Teacher.pName);
            pName = new char[m_Lenth+1];

            if(NULL != pName)
                strcpy(pName,m_Teacher.pName);
        }

    }

     return *this;
}

ostream& operator<<(ostream &out,const Teacher &m_Teacher)
{
    out<<m_Teacher.addr<<" "<<m_Teacher.pName<<"  "<<m_Teacher.income<<endl;

    return out;
}

Teacher::~Teacher()
{
    if(NULL!=this->pName)
    {
        delete [] pName;
        pName = NULL;
    }
}

int main()
{
    double db_income = 12378.9;
    string str = "beautiful";
    const char *pCh = "Anny";

    Teacher t1;
    t1.SetIncom(db_income);
    t1.SetName(pCh);
    t1.SetAddress(str);
    cout<<t1<<endl;

    Teacher t2;
    t2 = t1;
    cout<<t2<<endl;


    return 0;
}

    程序运行的结果：

   

      这已经是一个设计标准的类了，其中实现了对类成员的封装，实现来操作符的重载。不过我们这里暂且不看这些，我们需要了解的是其中所涉及到的引用。

      涉及到的const引用：

Teacher& operator = (const Teacher &m_Teacher);

    //输出操作符重载
friend ostream & operator<<(ostream &out,const Teacher&m_Teacher);

     const引用就是在函数定义内部不能修改原对象，这时的引用最好设置为const引用，而且也应该设置为const引用。如下所示：

void SetIncom(const double &db_Income)
    {
        income = db_Income;
    }

    void SetAddress(const string &str)
    {
        addr = str;
    }

     函数返回引用：

 Teacher& operator = (const Teacher &m_Teacher);

     我们使用引用，主要是避免了对象的赋值，这节省了不少的程序运行速度和内存开销，所以我们在程序中尽量使用返回引用，而不是返回一份对象的拷贝。

     在函数返回引用时，千万不要返回临时对象的引用。因为在函数返回时，临时对象销毁，返回引用会使得对象指向一个不存在的对象，造成程序的崩溃。

      如下所示：

int &GetData(const int &num)
{
       int temp = num;
       return 2*temp;
}

      temp 时函数内部的临时对象，函数在返回时temp已经销毁，若使用：int data = GetData(5);则程序会报错，因为data引用一个不存在的对象。我们在书写程序的时候一定要   避免。

6、引用一个数组：

 

#include <iostream>
using namespace std;

void SetArray(int (&Array)[10])
{
    int num = 0;
    for(int i=0;i<10;i++)
    {
        cin>>num;
        Array[i] = num;
    }

}

void PrintArray(const int (&Array)[10])
{
    for(int i=0;i<10;i++)
        cout<<Array[i]<<"  ";
}

int main()
{
    int m_Array[10];
    SetArray(m_Array);
    PrintArray(m_Array);

    return 0;
}

     程序运行的结果：

     这里把数组的引用拿出来是想告诉数组的引用是如何实现的，实际上并没有多难。

7、看了这么多的例子，想必大家对引用了解的也差不多了吧，如果还有不明白的，欢迎相互交流。

      或许大家还有对指针和引用之间的关系有些疑问，没关系，下一会给大家讲到的。