指针和引用

                                                                                             指针和引用

     （1）int a = 10;  

              int b  = 20; 

              int &rn = a;

              rn = b;

              rn是a的一个别名，对rn的赋值其实就是对a的赋值,执行完后a = 20;

      （2）int a = 1;

               int b = 10;

               int * p = &a;

               int *&pa = p;//pa是p的引用

               pa = &b;//pa指向b的地址。pa是p的引用，所以此时p也指向了b的地址、

      （3）引用类型的变量在声明的时候必须同时初始化。p没有被初始化因此p是个野指针，对野指针的内容赋值是非常危险的，会导致程序运行时崩溃。

      （4）交换两个字符串可以采用的方法

             void swap(char **x, char **y);

             void swap(char *&x, char *&y);

      （5）对一个临时变量建立引用会发生错误

             float  f1(float r)

            {

                   f=r*r*pi;

                   return f;

             }//f为全局变量

             float& b = f1();

             

            这种方式最节省内存空间。但是注意他所引用的变量的有效期，此处全局变量f的有效期肯定长于引用d，所以安全

             float& f2(float r)

             {

                     f = r*r*pi;

                     return f;

             }

             float& d = f2();//主函数不使用定义变量而是使用全局变量的引用

            

       （6）使用错误，不能使用常量引用修改引用变量的值

               void f(const int &arg)

                {

                           arg = 10;       

                } 

     

                不能使用常量类型变量定义非常量的引用。

                const int b=10;

                int  &c = b;

                int a = 7;

                const int &d = a;

                d++;//不能使用常量引用修改变量的值

                对于常量类型，其引用也必须是常量类型。对于非常量类型。其引用可以是常量的也可以是非常量的。但是要注意无论什么情况下都不能使用常量引用修改其引用变量的值

        （7）指针和引用的不同

                    引用必须在创建的时候初始化而指针不用

                    引用一旦被指向一个对象则就不能修改为另一个对象的引用，但是指针可以改变指向

                    不存在NULL引用

                    引用不会指向空值因此使用之前不用测试他的合法性，但是指针则需要经常做测试

               

                     传引用比传指针安全？

                            不存在空引用，并且引用一旦被指向一个对象，他就不能改变为另一个对象的引用

          （8）int a[5] = {1,2,3,4,5};

                      int *ptr = (int *) (&a+1);

                      *(a+1)//  =2;

                      *(ptr-1)  // = 5;     

               a和&a的地址是一样的，但是意思不一样，a是数组的首地址，&a是对象首地址。a+1是数组下一元素的地址，而&a+1是下一个对象的地址及a[5]

           （9） char *a = "abc";

                    char *b = "abc";他俩在内存中占有同一快内存并且不能被修改

                    a[0] = 'B';错的

          （10）对于类成员函数而言，并不是一个对象对应一个单独的成员函数体，而是此类的所有对象公用这个成员函数体，当程序被编译完成以后此成员函数地址即已确定，我们用类成员函数时，会将当前对象的this指针传给成员函数。一个类的成员函数体只有一份，而成员函数之所以把属于此类的各个对象的数据区分开，就在于每次执行类成员函数时都会把当前对象的this指针传入成员函数，函数体内所有对类数据成员的访问都会被转化为this->数据成员的方式

           （11）

                   int *p = new int[10];p为数组指针，记着要delete

                   int   (*a[2]) （int，int）;函数指针数组

                   typedef int (*p) (int x, int y);

                   int fun(int x, int y);

                   p = fun;

           （12）

                   野指针造成的原因：指针变量未被初始化，任何指针变量被创建时候都不会成为NULL指针，他的默认值乱指一气。指针变量创建时就要初始化好

                   delete p 或者free p以后没有置NULL;

           （13）动态内存传递

                   char *str1 = NULL;

                   char *str2 = NULL;

                   char *str3 = NULL;

                   void getmemory1(char **p, int num)

                   {

                            p = (char *)malloc(sizeof(char) * num);

                   }

                  void getmemory2(char *&p, int num)

                  char *getmemory3(int num)

                  {

                            char *p = (char *)malloc(sizeof(char) * num);

                  }

                  getmemory1(&str1, 20);

                  getmemory2(str2, 20);

                  str4 = getmemory3(20);

                  free(str1);

                  free(str2);

                  free(str3);

                  str1 = str2 = str3 = NULL;