面向对象程序设计

1、引用

引用的定义（定义了一个引用，并且将其初始化为引用某个变量）：

      类型名  &引用名=某变量名；

int n=4;

int &r=n;//r引用了n，r的类型是int &

某个变量的引用，等价于这个变量，相当于给这个变量取了一个别名。

注意：（1）定义引用的时候一定要将其初始化成引用某个变量。

（2）初始化之后，它就一直引用该变量，不会再引用别的变量了。

（3）引用只能引用变量，不能引用常量和表达式。

（4）引用可以作为函数的返回值。

         这时可以把一个函数调用的结果写在=（赋值号）的左边,对一个函数调用的结果可以赋值。           例如：

          int n;

          int &set(){ return n;}

          int main(){

          set()=40;//等价于对n进行赋值

           }

          注意：引用作为函数的返回值时不要返回一个函数的局部变量。

（5）常引用

        在定义引用时，前面加const关键字。

        int   n;

        const   int &r=n;

        注意：不能用常引用去修改其引用的内容。

        int   n=100;

        const  int &r=n;

        r=200;//编译错

        n=300；//没问题

  （6）常引用和非常引用

        const  T &和 T &是不同的类型。

        T &类型的引用或者T类型的变量可以用来初始化const T &类型的引用。

        const T 类型的常变量和const T &类型的引用不能用来初始化T &类型的引用，除非进行强制

 类型转换。

2、const关键字的用法

    （1）定义常量(有类型)

             const   int  n=100;

    （2）定义常量指针

             不可以通过常量指针修改其指向的内容。

              int  n,m;

              const  int *p=&n;

              *p=5;//出错

               n=4;//可以

               p=&n;//可以，常量指针的指向发生变化

             不可以把常量指针赋值给非常量指针，反过来可以。

               const   int *p1;

                int *p2;

                p1=p2;//ok

                p2=p1;//error

                p2=(int  *) p1;//ok,强制类型转换

              函数参数为常量指针时，可以避免函数内部不小心改变参数指针所指地方的内容。

      （3）定义常引用

              不能通过常引用修改其引用的内容。

3、动态内存分配

     （1）用new运算符实现动态内存分配

              *第一种用法，分配一个变量

                P=new  T;

               T是任意的类型名，P是类型为T*的指针。

                动态分配出一块大小是sizeof(T)字节的内存空间，并且该内存空间的起始地址赋值给P。

               int  *p;     p= new int ;    *p=5;

               *第二中用法，分配一个数组

               T是任意的类型名，P是类型为T*的指针，N是要分配的数组元素的个数，可以使整型表

达式。

              P=new  T[N];

            动态分配出一块大小是N*sizeof(T)字节的内存空间，并且该内存空间的起始地址赋值给P。

            int  *p;  int  i=5; p=new  int[i*20];  p[0]=20; p[100]=30;//编译没问题。运行时导致数组越界

 （2）new运算符的返回值类型

          new  T ；  new  T[n];

          这两个表达式的返回类型都是T  *

         int  *p=new int;

   (3)  用delete运算符释放动态分配的内存空间

        用new动态分配的内存空间，一定要用delete运算符进行释放

        delete  指针；//该指针必须指向new出来的空间

        int  *p=new int;  *p=5;   delete p;    delete p;//异常，一片空间不能被delete多次释放

        用delete运算符释放动态分配的数组

        用delete释放动态分配的数组，需要使用[]

        delete []  指针；//该指针必须指向new出来的数组

        int  *p=new int[20];  p[0]=5;   delete[] p; 

4、内联函数、函数重载、函数缺省参数

     （1）内联函数

         函数调用是有时间开销的。如果函数本身只有几条语句，执行的非常快，而且函数被反复执

行很多次，相比之下调用函数所产生的的这个开销就会显得很大。

         为了减少函数调用的开销，引入了内联函数机制。编译器处理对内联函数的调用语句时，是

将整个函数的代码插入到调用语句处，而不会产生调用函数的语句。

         在函数定义的前面加上“inline”关键字

          inline int  set(){  int  a=10;   return  a; }

      （2）函数重载

         一个或者多个函数，名字相同，然而参数个数或参数类型不同。

         编译器根据调用语句中的参数个数和类型判断应该调用哪个函数。

       （3）函数缺省参数

          定义函数时，可以让最右边的连续若干个参数缺省，那么调用函数的时候，若相应

位置不写参数，参数就是缺省值。

          void  fun(int a,int b=1,int c=2){}

           fun (10);//等效于fun(10,2,3);

           fun(10,8);//等效于fun(10,8,3);

           fun（10，，8）;//不行，只能最右边的连续若干个参数缺省，如果出现缺省

则，右边都需要缺省