C++ 之 第七课 引用篇

　　引用的介绍

什么是引用？引用就是别名，别名就是创建一个对象的另一个名称。创建引用的方法用&符号。在c++ 下你可以把它看作是另外的一种指针，通过引用类型我们同样也可以间接的操作对象，引用类型主要是用在函数的形式参数上，通常我们使用它是把类对象传递给一个函数。 引用对象采用类型名加上&符号和名称的方式进行定义。例如：(int &test;)，这里我们就定义了一个int类型的名为test 的引用，但是int &test;这样的方式是不能够被编译成功的，因为引用的定义必须同时给应用进行赋值操作，这里的赋值并不是说把变量的值传递给引用，而是把引用指向变量，写成这样就对了：(int &test=变量名;)。 

示例一：

int _tmain(int argc, _TCHAR* argv[])
{
    int a = 10;
    int &b = a;
    b = b + 2;
    cout<<&a<<"|"<<&b<<"|"<<a<<"|"<<b;
    getchar();

    return 0;
}

输出结果为：

从上面结果可以得知，a和b的地址是一样的，结果都为12.

　　那引用作为函数的形参又是怎样的呢？

示例二

#include<iostream>
using namespace std;
//---------------------------------------------------------------------------
void swap(int &a,int &b);
int _tmain(int argc, _TCHAR* argv[])
{
    int x, y;
    x = 5;
    y = 10;
    cout<<"main函数中x="<<x<<"y="<<y<<endl;
    swap(x,y);
    cout<<"调用函数swap中x="<<x<<"y="<<y;
    getchar();
    return 0;
}
void swap(int &a,int &b)
{
    int temp;
    temp = a;
    a = b;
    b = temp;

}

 　　从上结果分析得知，引用和指针的功能是一样的。

　　常引用

用const声明的引用就是常引用。常引用所引用的对象不能被更改。我们经常见到的是常引用作为函数的形参，这样不会发生对实参的误修改。常引用的声明形式为：const 类型说明符 &引用名。常引用作为函数形参的例子：

#include<iostream>
using namespace std;
void show(const double& r);
int main()
{   
   double d(9.5);
   show(d);
   return 0;
}
void show(const double& r)
 //常引用作形参，在函数中不能更新r所引用的对象。
{   
      cout<<r<<endl;   
}

       常对象

       所谓常对象，是指数据成员在它的生存期内不会被改变。定义常对象时必须对其进行初始化，并且不能改变其数据成员的值。常对象的声明形式为：类名 const 对象名 或者 const 类名 对象名。常对象的例子如下：

       

class A
 {
 public:
 A(int i,int j) {x=i; y=j;}
                     ...
 private:
 int x,y;
};
 A const a(6,8); //a是常对象，不能被更新

       如果程序中出现对常对象的数据成员修改的语句，编译器会报错。一般修改对象的数据成员有两种途径，一种是通过对象名访问公有数据成员并修改其值，而常对象的数据成员是不能被修改的；另一种是类的成员函数修改数据成员的值，而常对象不能调用普通的成员函数。可是这样的话，常对象就只剩数据，没有对外的接口了，这就需要为常对象专门定义的常成员函数了。

   类的常成员函数

       类中用const声明的成员函数就是常成员函数。常成员函数的声明形式为：类型说明符 函数名(参数表) const;。

     要提醒大家注意几点：a.常成员函数在声明和实现时都要带const关键字；b.常成员函数不能修改对象的数据成员，也不能访问类中没有用const声明的非常成员函数；c.常对象只能调用它的常成员函数，不能调用其他的普通成员函数；d.const关键字可以被用于参与对重载函数的区分，比如，如果有两个这样声明的函数：void fun(); void fun() const;，则它们是重载函数。

        #include<iostream>
        using namespace std;
        class R
        { 
        public:
                    R(int r1, int r2)    { R1=r1; R2=r2; }
                    void print();
                    void print() const;
        private:
                    int R1,R2;
        };
        void R::print()
        { 
                   cout<<R1<<":"<<R2<<endl;
        }
        void R::print() const
        { 
                  cout<<R1<<";"<<R2<<endl;
        }
        int main()
        { 
                 R a(5,4);
                 a.print(); //调用void print()
                 const R b(20,52);  
                 b.print(); //调用void print() const
                 return 0;
        }

       上面的R类中声明了两个同名函数print，第二个是常成员函数。在main函数中定义了两个对象a和b，b是常对象，通过a调用的是没有用const声明的函数，而通过b调用的是用const声明的常成员函数。

       类的常数据成员

       类的数据成员也可以是常量和常引用，用const声明的数据成员就是常数据成员。在任何函数中都不能对常数据成员赋值。构造函数对常数据成员初始化，只能通过初始化列表。

       #include<iostream>
       using namespace std;
       class A
        {
       public:
                       A(int i);
                       void print();
                       const int& r;
       private:
                       const int a;
                       static const int b;  //静态常数据成员
       };
      const int A::b=20; 
       A::A(int i):a(i),r(a) {}
       void A::print()
       {    
                     cout<<a<<":"<<b<<":"<<r<<endl; 
       }
       int main()
       {
                   //建立对象a1和a2，并以50和10作为初值，分别调用构造函数，通过构造函数的初始化列表给对象的常数据成员赋初值
                   A a1(50),a2(10);  
                   a1.print();
                   a2.print();
                   return 0;
       }

       此程序的运行结果是：

       50:20:50
       10:20:10