在Java、C#中有關鍵詞abstract指明抽象函式、抽象類，但是在C++中沒有這個關鍵詞，很顯然，在C++也會需要只需要在基類宣告某函式的情況，而不需要寫具體的實現，那C++中是如何實現這一功能的，答案是純虛擬函式。 含有純虛擬函式的類是抽象類，不能生成物件，只能派生。他派生的類的純虛擬函式沒有被改寫，那麼它的派生類還是個抽象類。定義純虛擬函式就是為了讓基類不可例項化化，因為實例化這樣的抽象數據結構本身並沒有意義，或者給出實現也沒有意義。

一.  純虛擬函式

在許多情況下，在基類中不能給出有意義的虛擬函式定義，這時可以把它說明成純虛擬函式，把它的定義留給派生類來做。定義純虛擬函式的一般形式為：

class 類名{

 virtual 返回值型別 函式名（引數表）= 0;  // 後面的"= 0"是必須的，否則，就成虛函數了

};

純虛擬函式是一個在基類中說明的虛擬函式，它在基類中沒有定義，要求任何派生類都定義自己的版本。純虛擬函式為各派生類提供一個公共介面。

二. 抽象類

1. 如果一個類中至少有一個純虛擬函式，那麼這個類被稱為抽象類（abstract class）。

2. 抽象類特點，即抽象類必須用作派生其他類的基類，而不能用於直接建立物件例項。

一個抽象類不可以用來建立物件，只能用來為派生類提供一個介面規範，派生類中必須過載基類中的純虛擬函式，否則它仍將被看作一個抽象類。

3. 在effective c++上中提到，純虛擬函式可以被實現（定義）（既然是純虛擬函式，為什麼還可以被實現呢？這樣做有什麼好處呢？下文中“巧用純虛解構函式實現介面類”中將說明這一功能的目的。），但是，不能建立物件例項，這也體現了抽象類的概念。

三. 虛解構函式

虛解構函式: 在解構函式前面加上關鍵字virtual進行說明，稱該解構函式為虛解構函式。雖然建構函式不能被宣告為虛擬函式，但解構函式可以被宣告為虛擬函式。

一般來說，如果一個類中定義了虛擬函式， 解構函式也應該定義為虛解構函式。

例如：

class B

{

 virtual ~B();  //虛解構函式

  …

下面介紹一些例項：

#include <stdio.h>

class Animal
{
public:
     Animal()	//建構函式不能被宣告為虛擬函式
     {
	printf(" Animal construct! \n");
     }
     virtual void shout() = 0;
     virtual void impl() = 0;
     virtual ~Animal() {printf(" Animal destory! \n");};   // 虛解構函式
};


void Animal::impl()        // 純虛擬函式也可以被實現。
{
     printf(" Animal: I can be implement! \n");
}


class Dog: public Animal
{
public:
     Dog()
     {
	printf(" Dog construct! \n");
     }
     virtual void shout() // 必須要被實現，即使函式體是空的
     {
		 printf(" Dog: wang! wang! wang! \n");
     }
     virtual void impl()
     {
		 printf(" Dog: implement of Dog!  \n");
     }
     virtual ~Dog() {printf(" Dog destory! \n");};   // 虛解構函式
};


class Cat: public Animal
{
public:
     Cat()
     {
	printf(" Cat construct! \n");
     }
     virtual void shout() // 必須要被實現，即使函式體是空的
     {
		 printf(" Cat: miao! miao! miao! \n");
     }
    
     virtual void impl()
     {
		 printf(" Cat: implement of Cat!  \n");
     }
     virtual ~Cat() {printf(" Cat destory! \n");};   // 虛解構函式
};


/*
Animal f()  // error, 抽象類不能作為返回型別
{
      
}

void display( Animal a) //error, 抽象類不能作為引數型別
{
    
}
*/


//ok，可以宣告抽象類的引用
Animal &display(Animal &a)
{
       Dog d;
       Animal &p = d;
       return p;
      
}

void test_func()
{
     //Animal a;  // error: 抽象類不能建立物件
    
    Dog dog;   //ok，可以宣告抽象類的指標
    Cat cat;   //ok，可以宣告抽象類的指標
   
    printf("\n");

    Animal *animal = &dog;
    animal->shout();
    animal->impl();
   
    printf("\n");
   
    animal = &cat;
    animal->shout();
    animal->impl();
   
    printf("\n");
}

int main()
{
    test_func();

    while(1);  
}


//result:
/*
Animal construct!
Dog construct!
Animal construct!
Cat construct!

Dog: wang! wang! wang!
Dog: implement of Dog!

Cat: miao! miao! miao!
Cat: implement of Cat!

Cat destory!
Animal destory!
Dog destory!
Animal destory!
*/
(YC：程式碼已除錯無誤)

看如下程式碼：

#include <stdio.h>


class A
{
protected:
	virtual ~A()
	{
		printf(" A: 解構函式  \n");
	}
};
class B : public A
{
public:
	virtual ~B()
	{
		printf(" B: 解構函式  \n");
	}
};
int _tmain(int argc, _TCHAR* argv[])
{
	//A* p1 = new A;              //error：[1]有問題
	//delete p1;


	B* p2 = new B;		     //ok：[2]沒問題，輸出結果為：
	delete p2;  		     /* B: 解構函式
                                        A: 解構函式*/（注意此處還是會呼叫A的解構函式的，不過編譯沒問題）
                 
	//A* p3 = new B;
	//delete p3;                 //error：[3] 有問題


	return 0;
}

Case１：

class A
{
protected:
	A()
	{
		printf(" A: A()  \n");
	}
};

int _tmain(int argc, _TCHAR* argv[])
{
	A* p1 = new A;                //編譯不通過，無法訪問protected建構函式
	delete p1;

	return 0;
}

Case2：

class A
{
protected:
	~A()
	{
		printf(" A: ~A()  \n");
	}
};

int _tmain(int argc, _TCHAR* argv[])
{
	A* p1 = new A;                //編譯通過，此時因為僅僅是用到了A的建構函式，還不需要它的解構函式
	return 0;
}

（附：如果將main中改為：
int _tmain(int argc, _TCHAR* argv[])
{
	A a;
	return 0;
}
則編譯出錯，提示無法訪問protected成員A::~A().兩種情況出現差異的原因是什麼？

）

Case3：

class A
{
protected:
	~A()
	{
		printf(" A: ~A()  \n");
	}
};
int _tmain(int argc, _TCHAR* argv[])
{
	A* p1 = new A;                
	delete p1;                //編譯失敗，因為編譯器發現A的解構函式是protected
	return 0;
}

所以，一種可行的辦法貌似是這樣的：

class A
{
protected:
	virtual ~A()
	{
		printf(" A: ~A()  \n");
	}
};

class B : public A
{
};

int _tmain(int argc, _TCHAR* argv[])
{
	B* p =new B;       //ok:這種情況下確實是可行的（YC：仔細看會發現這種情況同“（1）看如下程式碼”下面的程式碼中ok的情況相同）
	delete  p;
	return 0;
}

由於B public繼承自A，所以其可以完全訪問A的構造或解構函式，但是：

int _tmain(int argc, _TCHAR* argv[])
{
    A* p =new B;
    delete  p;                //error：由於p變成指向A的指標，字面上編譯器需要知道A的解構函式，然後A的解構函式又是protected
    return 0;
}

即便像這樣B顯示過載了A的解構函式：

class A
{
protected:
	virtual ~A()
	{
		printf(" A: ~A()  \n");
	}
};
class B : public A
{
public:
	virtual ~B()
	{
		printf(" B: ~B()  \n");
	}
};
int _tmain(int argc, _TCHAR* argv[])
{
	A* p =new B;
	delete  p;        //error：也還是不行，因為過載是執行時的事情，在編譯時編譯器就認定了A的解構函式，結果無法訪問
	return 0
}

小結：

其實上面protected的思路是對的，無非是讓父類無法例項化，那麼為了讓父類無法例項化，其實還有一個方法，使用純虛擬函式。

class A
{
public:            //這裡就不用protected了
    virtual ~A() = 0;
};
class B : public A
{
};
int _tmain(int argc, _TCHAR* argv[])
{
    B* p =new B;
    delete  p;		//編譯ok，連結error
    return 0;
}

那麼如何修改上述程式碼可以達到既可以去除上述error，又可以讓基類不能被例項化呢？如下所示：

class A
{
public:					//這裡就不用protected了
	virtual ~A() = 0                //它雖然是個純虛擬函式，但是也可以被實現
	{                               //這個語法很好很強大（完全是為了實現其介面類而弄的語法吧）
		printf(" A: ~A()  \n");
	}
};
class B : public A
{
};
int _tmain(int argc, _TCHAR* argv[])
{
	B* p =new B;
	delete  p;
	A* p2 =new B;
	delete  p2;            //不用擔心編譯器報錯了，因為此時A的解構函式是public
	return 0;
}
//result：
/*
 A: ~A()
 A: ~A()
*/ 

如此終於大功告成了，注意，不能將建構函式替代上面的解構函式的用法，因為建構函式是不允許作為虛擬函式的。

補充：以上那個語法就真的只是為了這種情況而存在的，因為一般我們在虛類中申明的介面：

virtual foo()= 0;

virtual foo()= 0 {}

這兩種寫法是完全沒有區別的，純虛擬函式的預設實現，僅僅在它是解構函式中才有意義！！！

所以可以說，老外是完全為了這一個目的而發明了這種語法...

最終的介面類

classInterface
{
public:       
    virtual ~Interface() = 0 {}
};