引用说明:
(1) double & rr=1; 等价与 double temp； temp＝double（1）； double & rr＝temp；
(2) int *a; int * & p=a; int b=8; p=&b; //正确，指针变量的引用
void & a=3; //不正确，没有变量或对象的类型是void
int & ri=NULL； //不正确，有空指针，无空引用
(3) int & ra=int; //不正确，不能用类型来初始化
int *p=new int; int & r=*p; //正确
(4) 引用不同于一般变量，下面类型声明是非法的：
int &b[3]; //不能建立引用数组
int & *p; //不能建立指向引用的指针
int &&r; //不能建立引用的引用
(5) 当使用&运算符取一个引用的地址时，其值为所引用变量的地址，

一段代码：

#include <iostream>

using namespace std;

void freePtr1(int* p1)

{

   delete p1;

   p1 = NULL;

}

void freePtr2(int*& p2)

{

   delete p2;

   p2 = NULL;

}

void main()

{

   int *p1 = new int;

   *p1 = 1;

   freePtr1(p1);

   int *p2 = new int;

   *p2 = 2;

   freePtr2(p2);

   system("pause");

}

思考：在freePtr1和freePtr2 的比较中，你能发现它们的不同点吗？

二、对代码进行解释：

#include <iostream>

using namespace std;

void freePtr1(int* p1)

{

   //未释放内存前 ->  p1 Address : 0012FDDC  p1 value : 003429B8，在这里，p1它也是一个变量，既然是一个变量，那么它将会以值的传递，把外部变量p1传到栈内，在栈内产生一个地址：0012FDDC，当然，它的值不会变仍然是指向堆地址：003429B8 。

   delete p1; //系统回收p1值的地址003429B8处的内存。

p1 = NULL;//对p1赋以NULL值即：00000000，注意：p1本身的地址并没有变，变的是p1的值。

   //释放内存后 ->  p1 Address : 0012FDDC  p1 value : 00000000，出栈后，p1由于是一个临时对象，出栈后它会自动被视为无效。

}

void freePtr2(int*& p2)

{

   //未释放内存前 ->  p2 Address : 0012FEC8  p2 value : 003429B8，p2是一个指针的引用，即引用指向指针，记住引用的特点：对引用的对象直接操作。所以它的地址和值与栈外的main()函数中，p2的值是同一个。

   delete p2; //对p2所引用的指针进行释放内存，即：系统回收main()函数中 p2的值 003429B8 地址处的内存。

   p2 = NULL;//对main()函数中p2的指针赋以NULL值。

   //释放内存后 ->  p2 Address : 0012FEC8  p2 value : 00000000，由于操作的对象都是main()函数中的p2,所以它将应用到原变量中。

}

void main()

{

   int *p1 = new int;

//释放内存前->  p1 Address : 0012FED4  p1 value : 003429B8

   freePtr1(p1);

   //释放内存后->  p1 Address : 0012FED4  p1 value : 003429B8

   int *p2 = new int;

   //释放内存前->  p2 Address : 0012FEC8  p2 value : 003429B8

   freePtr2(p2);

   //释放内存后->  p2 Address : 0012FEC8  p2 value : 00000000

   system("pause");

}
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
指针引用的经典用法：

#include <iostream>
using namespace std;

void all1(int **p)
{
 int *pp = new int;
 *p = pp;
}
void all2(int*& p)
{
 int *pp = new int;
 p = pp;
}

void main()
{
 int *a1;
 all1(&a1);
 *a1 = 1;
 cout<<*a1<<endl;

 int *a2;
 all2(a2);
 *a2 = 2;
 cout<<*a2<<endl;
 

}
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
【转载】自：http://www.cppblog.com/mzty/archive/2005/12/08/1621.html

派生类中析构函数
由于析构函数也不能继承，因此派生类的析构函数中将调用直接基类的析构函数。执行派生类析构函数的顺序正好与指向派生类的构造函数的顺序相反。先调用派生类的析构函数，再调用子对象类的析构函数，最后调用直接基类的析构函数。

例如：分析下列程序的输出结果，掌握派生类构造函数的定义格式和执行顺序，以及派生类析构函数的调用方法。

 1#include<iostream>
 2using namespace std;
 3class A
 4{
 5public:
 6    A()
 7    {
 8         a=0;
 9         cout<<"Default constructor called. A\n";
10    }
11    A(int i)
12    {
13        a=i;
14        cout<<"Constructor called. A\n";
15    }
16    ~A()
17    {
18        cout<<"Destructor called. A\n";
19    }
20    void Print()
21    {
22        cout<<a<<",";
23    }
24    int Geta()
25    {
26        return a;
27    }
28private:
29    int a;
30};
31class B:public A
32{
33public:
34    B()
35    {
36        b=0;
37        cout<<"Default constructor called. B\n";
38    }
39    B(int i,int j,int k);
40    ~B()
41    {
42        cout<<"Destructor called. B\n";
43    }
44    void Print()
45    {
46        A::Print();
47        cout<<b<<","<<aa.Geta()<<endl;
48    }
49private:
50    int b;
51    A aa;
52};
53
54B::B(int i,int j,int k):A(i),aa(j),b(k)
55{
56    cout<<"Constructor called. B\n";
57}
58int main()
59{
60    B bb[2];
61    bb[0]=B(8,3,9);
62    bb[1]=B(17,-18,19);
63    int i;
64    for(i=0;i<2;i++)
65        bb[i].Print();
66    return 0;
67}
68

Default constructor called A.
Default constructor called A.
Default constructor called B.
Default constructor called A.
Default constructor called A.
Default constructor called B.
Constructor called. A
Constructor called. A
Constructor called. B
Destructor called. B
Destructor called. A
Destructor called. A
Constructor called. A
Constructor called. A
Constructor called. B
Destructor called. B
Destructor called. A
Destructor called. A
8,9,3
17,19,-18
Destructor called. B
Destructor called. A
Destructor called. A
Destructor called. B
Destructor called. A
Destructor called. A

派生类B的构造函数定义如下：
B( int i, int j, int k):A(i),aa(j),b(k)
{....}

该构造函数的成员初始表有3项：A(i)是调用直接基类的一个参数的构造函数给基类数据成员初始化；aa(j)是调用子对象的构造函数给子对象数据成员初始化；b(k)是对派生类本事的数据成员b初始化，该项可放在函数体内。
主函数中先创建一个B类的数组bb，它有两个元素，每个元素创建时调用一次B类的默认构造函数，该构造函数隐含调用基类默认构造函数，子对象类默认构造函数和自身函数体，因此，显示3条信息。
程序中的两条给数组元素bb[0]和bb[1]赋值的语句，共显示出12行信息。因为每调用一次派生类中带有3个参数的构造函数，则要显示输出3行信息，创建一个临时对象，完成了赋值任务后，要将临时对象释放掉，调用一次派生类B的析构函数，又要产生3行信息，注意其顺序与调用构造函数时所显示的3行信息顺序相反。
程序最后显示的6行信息是程序结束前将对象数组bb的两个元素释放掉所产生的。

#include<iostream>
using namespace std;

class Base1
{
    int d1;
    public:
    Base1(int i)
    {
        d1=i;
        cout<<"constructing Base1 "<<d1<<endl;
    }
};
class Base2
{
    int d2;
    public:
    Base2(int j)
    {
        d2=j;
        cout<<"constructing Base2 "<<d2<<endl;
    }
};
class Base3
{
    int d3;
    public:
    Base3(int k=0)
    {
        d3=k;
        cout<<"constructing Base3 "<<d3<<endl;
    }
};
class Derived:public Base3,public Base1,public Base2
{
    int d4;
    Base1 memberObj1;
    Base3 memberObj3;
    Base2 memberObj2;
    public:
    Derived(int a,int b,int c,int d,int e)
           :memberObj2(d),memberObj3(b),memberObj1(c),Base2(a),Base1(b)
    {
        d4=e;
        cout<<"constructing Derived "<<d4<<endl;
    }
};
int main()
{
    Derived obj(1,2,3,4,5);
    return 0;
}

私有继承方式：
在私有继承时，派生类的成员函数可访问直接基类中的公有成员和保护成员，而不可访问间接基类中的任何成员；派生类的对象不可访问基类中的任何成员。

保护继承方式：
保护继承方式将使得基类中的公有成员和保护成员都成为派生类中的保护成员，这样是派生类的对象不可访问基类中的所有成员。同时使得派生类的成员函数可访问直接基类和间接基类中的公有成员和保护成员。
对单个类来讲，保护成员和私有成员没有什么区别，该类的对象都不能访问。但对继承来讲，保护成员不同于私有成员，保护成员可被派生类中成员函数访问，而私有成员不可被派生类访问。保护成员又与公有成员不同，保护成员在任何继承方式下也不能被派生类的对象访问，而公有成员在公有继承下可被派生类的对象访问。

◆公有继承和赋值兼容

基类中的私有成员和不可访问成员在派生类中是不可访问的。
所谓不可访问即是不可见，不能够进行操作。
赋值兼容规则是指在公有继承情况下，派生类的对象可作为基类的对象来使用，即派生类对象就是基类对象，正如前面讲过的派生类是基类的子类型。
假如D类公有继承B类，D类是B类的子类型。赋值兼容规则指出：

1、派生类的对象可以赋值给基类的对象。例如：
   D  d;
   B  b;
   b=d;
这是允许的。如果d=b；则是非法的。

2、派生类的对象的地址值可用来给指向基类对象的指针赋值。例如：
   D  d;
   B  *pd=&d;
这是允许的。如果反过来，则是非法的。

3、派生类的对象可以用来初始化基类对象的引用。例如：
   D  d;
   B  &rd=d;
这是允许的。如果反过来就是非法的。

例如，分析下列程序：

 1#include<iostream>
 2using namespace std;
 3class M
 4{
 5    public:
 6       M()
 7       {
 8           m=0;
 9       }
10       M(int i)
11       {
12           m=i;
13       }
14       void Print()
15       {
16           cout<<m<<endl;
17       }
18       int Getm()
19       {
20           return m;
21       }
22    private:
23       int m;
24};
25class N:public M
26{
27    public:
28       N()
29       {
30           n=0;
31       }
32       N(int i,int j):M(i),n(j)
33       {
34       }
35       void Print()
36       {
37           cout<<n<<",";
38           M::Print();
39       }
40    private:
41       int n;
42};
43
44void fun(M &p)
45{
46    cout<<p.Getm()-5<<",";
47    p.Print();
48}
49int main()
50{
51    M m(17),q;
52    N n(13,18);
53    n.Print();
54    q=n;
55    q.Print();
56    M *pm=new M(16);
57    N *pn=new N(15,19);
58    pm=pn;
59    pm->Print();
60    fun(*pn);
61    N n1(21,34);
62    M &rm=n1;
63    rm.Print();
64    n1.Print();
65    return 0;
66}
67

    静态数据成员定义在类体内，定义时前边加关键字static。
    静态数据成员定义后，必须再对它进行初始化。静态数据成员被定义在类体内，但是对它的初始化在类体外进行。
具有一下特点：
    1、定义在类体内，初始化在类体外。初始化后才可使用。
    2、静态数据成员是属于类的，而不是属于某个对象的。静态数据成员是所有对象共享的，使用它可以节省内存。因此，引用静态数据成员时可以使用类名，其格式如下所示：
    <类名>::<静态数据成员名>
    3、定义静态数据成员像定义一般数据成员一样，应该给出数据类型和访问权限。
    4、静态数据成员的寿命是长的，被存放在内存的静态工作区。

    静态成员函数可定义在类体内，也可定义在类体外，定义在类体外时按成员函数的定义格式，但不必加static关键字。
    静态成员函数的实现可以直接引用静态数据成员，但不能直接一哟你非静态数据成员。如果引用非静态成员时，则可通过对象来引用。
    使用类名和作用域运算符引用静态成员函数的格式如下：
    <类名>::<静态成员函数名>(<参数表>)
    使用对象引用静态成员函数的格式如下：
    <对象名>. <静态成员函数名>(<参数表>)
    特点：
    1、由于静态成员函数是用于处理类的，因此不能使用this指针。
    2、由于静态成员函数的程序代码在编译阶段就被分配内存空间了，因此不能被定义为虚函数。

 1#include<iostream>
 2using namespace std;
 3class M
 4{
 5   public:
 6      M(int a)
 7      {
 8         A=a;
 9         B+=a;
10         }
11      static void fun(M m);
12   private:
13      int A;
14      static int B;
15};
16
17void M::fun(M m)
18{
19   cout<<"A="<<m.A<<endl;
20   cout<<"B="<<B<<endl;
21   }
22int M::B=1;
23int main()
24{
25   M P(8),Q(18);
26   M::fun(P);
27   Q.fun(Q);
28}
29

在主函数中，出现了两种调用静态成员函数的格式，前一种使用类名和作用域运算符后一种使用的是对象名。即M::fun(P);
和Q.fun(Q);
两种方式都可以。

◆指向类的成员函数的指针
读程序：

 1#include<iostream>
 2using namespace std;
 3class A
 4{
 5   public:
 6      A(int i)
 7      {a=i;}
 8      int fun(int b)
 9      {return a*c+b;}
10      int c;
11   private:
12      int a;
13};
14
15int main()
16{
17   A x(18);
18   int A::*pc;
19   pc=&A::c;
20   x.*pc=5;
21   int(A::*pfun)(int);
22   pfun=&A::fun;
23   A *p=&x;
24   cout<<(p->*pfun)(10)<<endl;
25   return 0;
26}
27

    友元类是一种友元，它把一个类作为另一个类的友元。
    特点：
    例如，Y类是X类的友元类，则Y类中的成员函数可以访问X类中的所有成员，包含私有成员和保护成员。否则一个类的成员函数是不可访问另一个类中的私有成员和保护成员的。另外，友元类的关系是不可逆的。

 1#include<iostream>
 2using namespace std;
 3class X
 4{
 5   friend class Y;
 6   public:
 7      void Set(int i)
 8      {
 9         x=i;
10         }
11      void Display()
12      {
13         cout<<"x="<<x<<","<<"y="<<y<<endl;
14         }
15   private:
16      int x;
17      static int y;
18};
19class Y
20{
21   public:
22      Y(int i,int j);
23      void Display();
24   private:
25      X a;
26};
27
28int X::y=10;
29Y::Y(int i,int j)
30{
31   a.x=i;
32   X::y=j;
33   }
34void Y::Display()
35{
36    cout<<"x="<<a.x<<","<<"y="<<X::y<<endl;
37   }
38int main()
39{
40   X b;
41   b.Set(15);
42   b.Display();
43   Y c(16,19);
44   c.Display();
45   b.Display();
46   return 0;
47}
48

 1#include<iostream>
 2using namespace std;
 3class N
 4{
 5public:
 6    N(int i,int j)
 7    {
 8        x=i;
 9        y=j;
10    }
11    void Print()
12    {
13        cout<<x<<","<<y<<endl;
14    }
15    int Getxy()
16    {
17        return x+y;
18    }
19private:
20    int x,y;
21};
22
23N &fun()
24{
25    static N a(23,45);
26    return a;
27}//返回值的类型为N ，所以在主函数可以被p赋值。
28int main()
29{
30    N p(18,25);
31    p.Print();
32    cout<<fun().Getxy()<<endl;
33    fun()=p;
34    cout<<fun().Getxy()<<endl;
35    return 0;
36}

运行结果为：
18，25

使用运算符delete释放变量和数组
格式：delete  <指针名>
使用delete运算符释放数组的格式：
delete [] <指针名>

 1#include<iostream>
 2#include<cstdlib>
 3using namespace std;
 4int main()
 5{
 6   int *p,*pa;
 7   p=new int(10);
 8   pa=new int[10];
 9   if(!pa)
10   {
11      cout<<"Error!"<<endl;
12      exit(1);
13      }
14   int i;
15   for(i=0;i<10;i++)
16   pa[i]=i+10;
17   for(i=0;i<10;i++)
18   cout<<pa[i]+*p<<" ";
19   cout<<endl;
20   delete p;
21   delete pa;
22   return 0;
23   }
24

 1#include<iostream>
 2#include<cstring>
 3using namespace std;
 4class A
 5{
 6   public:
 7      A(char *str);
 8      ~A();
 9   private:
10      char string[80];
11};
12
13A A0("Test 1");
14A::A(char *str)
15{
16   strcpy(string,str);
17   cout<<"Constructor called of "<<string<<".\n";
18   }
19A::~A()
20{
21   cout<<"Destructor called of "<<string<<".\n";
22   }
23void fun()
24{
25   A A1("FunObject");
26   A A6("Test 2");
27   static A A2("Internal-StaticObject");
28   cout<<"In fun().\n";
29   }
30A A7("Test 3");
31A A3("GolbalObject");
32static A A4("External-StaticObject");
33int main()
34{
35   A A5("MainObject");
36   cout<<"In main(),before calling fun().\n";
37   fun();
38   cout<<"In main(),after calling fun().\n";
39   return 0;
40   }
41

Constructor called of Test 1.
Constructor called of Test 3.
Constructor called of GolbalObject.
Constructor called of External-StaticObject.
Constructor called of MainObject.
In main(),before calling fun().
Constructor called of FunObject.
Constructor called of Test 2.
Constructor called of External-StaticObject.
In fun().
In main(),after calling fun().
Destructor called of Test 2.
Destructor called FunObject.
In main(),after calling fun().
Destructor called of MainObject.
Destructor called of Internal-StaticObject.
Destructor called of External-StaticObject.
Destructor called of GolbalObject.
Destructor called of Test 3.
Destructor called of Test 1.

仔细观察外部函数和主函数对象的先后顺序：
先从全局对象开始然后主函数，然后再被调用函数的对象，即外部函数的对象。注意是一调用完外部函数，立即释放外部函数的对象，然后才继续主函数的释放。