繼承的應用

#include <iostream>
using namespace std;
class A
{
    public:
        void f(int i)
        {  cout<<i<<endl;  }
        void g()
        {  cout<<"A\n";  }
};

class B:private A 
{
  public:
    void h()
    {  cout<<"B\n";  }
     A::f; 
     //A::f; 該語句的含義是將類A 中的公有成員f() 
從私有繼承方式的派生類B 中申明為公有的
};
 

程式中A::f; 的含義是將類A 中的公有成員f() 從私有繼承方式的派生類B 中申明為公有的，B 的派生類物件可以訪問成員f()。因此在main()中，語句b.f(10); 是正確的。該語句稱為訪問申明，它是私有繼承方式中的一種呼叫機制，即在私有繼承方式下，用於恢復名字的訪問許可權。

int main()
{
    B b;
    b.f(10);//true
    b.g();    //error
    b.h();//true
    return 0;
}

語句b.g(); 是錯誤訪問，有編譯錯。若註釋該語句，執行結果為：10
                       B
將class B:private A 改為class B:public A，則無編譯錯，原程式輸出為：10
                               A
                               B
 

Dog類（派生類）從Ammal類（基類）派生的過程：

• 吸收基類成員：繼承後，派生類繼承基類的除了建構函式和解構函式之外的成員。本例中Dog類繼承了基類的Mammal類中的GetAge()、GetWeight()、SetAge()、SetWeight()、Speak()、itsAge、itsWeight;
• 改造基類成員：當派生類的同名屬性和行為具有和基類不同的特徵時，就要在派生類中重新宣告或者定義，賦予新的含義，從而完成對基類成員的改造。這樣就隱藏了基類中的同名成員（同名重寫/覆蓋規則）。本例中Dog類與Speak()函式進行改造，因為並不是所有動物都有共同語言。
• 新增新成員：派生類中新增新成員使得派生類在功能上有所擴充套件。本例中Dog類添加了新的類成員itsColor、GetColor()、SetColor( )，從而實現了派生類Dog在功能上的擴充套件。

基於專案的多檔案管理

//Ammal.h
#include <iostream>
using namespace std;
enum MyColor{BLACK, WHITE};
class Mammal
{
public:
	Mammal();
	 ~ Mammal();
	Mammal(int age, int weight):itsAge(age),itsWeight(weight){}
	int GetAge(){return itsAge;}
	int GetWeight(){return itsWeight;}
	void SetAge(int age){itsAge = age;}
	void SetWeight(int weight){itsWeight = weight;}
	void Speak(){cout<<"Mammal language!"<<endl;}
protected:
	int itsAge;     //年齡   
	int itsWeight;  //體重
};

//Ammal.cpp檔案中
#include "Ammal.h"
Mammal::Mammal()
{

}
Mammal::~Mammal()
{

}

//Dog.h
#include "Ammal.h"
class Dog : public Mammal
//公有繼承方式
{
public:
	Dog();
      ~Dog();
	MyColor GetColor(){return itsColor;}
	void SetColor(MyColor color){itsColor = color;}
	void Speak(){cout<<"Dog language!"<<endl;}
protected:
	MyColor itsColor;
};

//Dog.cpp
#include "Dog.h"
Dog::Dog()
{

}
Dog::~Dog()
{

}

//main.cpp
#include "Dog.h"
int main()
{
	Dog dog;
	dog.SetAge(25);
	dog.SetWeight(50);
	dog.SetColor(WHITE);
	cout<<"Ddog age = "<<dog.GetAge()<<endl;
	cout<<"Dog weight = "<<dog.GetWeight()<<endl;	
	cout<<"Dog color = "<<dog.GetColor()<<endl;	
	dog.Speak();
	return 0;
};

執行結果：
Dog age = 25
Dog weight = 50
Dog color = 1
Dog language!

管理步驟

1. 建立一個控制檯型別的專案L9.3,帶一個main.cpp檔案，其內容是main函式
2. 在L9.3專案中為Mammal類建立2個檔案（Ammal.h和Ammal.cpp檔案），為Dog類建立2個檔案（Dog.h和Dog.cpp檔案）

在專案名L9.3，右鍵單擊選擇新建檔案，新增新檔案,如圖:
檔案->新建->新建一個類，如圖：
系統自動加了框架程式碼

1. 輸入基類名Mammal
2. 勾選建構函式與解構函式
3. 預設檔名Mammal.cpp及
   Mammal.h
   

1. 輸入子類名
2. 勾選從其它類繼承
3. 選擇繼承方式
4. 輸入父類名
   

賦值相容規則（向上轉型）

一個公有派生類的物件在使用上可以被當作基類的物件，反之則禁止。具體表現在：

• 派生類的物件可以被賦值給基類物件。
• 派生類的物件可以初始化基類的引用。
• 指向基類的指標也可以指向派生類，即一個公有派生類物件的指標值可以賦值給（或初始化）一個基類指標。
• 利用這樣的指標或引用，只能訪問派生類物件中從基類繼承過來的成員，無法訪問派生類的自有成員。
  注意：派生類的拷貝建構函式如果要重新定義，其引數只有一個，即派生類物件引用，根據賦值相容規則，派生類物件可以用來初始化基類的拷貝建構函式的基類物件引用。

在C++中，這與Java不同，Java系統會自動呼叫子類中的方法。因為Java中預設是虛擬函式，動態繫結機制能識別出物件轉型前的型別。而C++中虛擬函式必須加virtual。所以Java中沒有賦值相容規則。

例9.4：賦值相容示例，要求用類的公有繼承方法輸出圓資訊，包括半徑和圓心。

#include <iostream>
using namespace std;
class Point
{protected:
	double x,y;	
public:
	Point(double a=0,double b=0)
	{x=a;y=b;	}
	void Show()
	{cout<<x<<","<<y<<endl;	}
};
class Circle:public Point
{	
public:	
    Circle(double a=0,double b=0,double c=0):Point(a,b)  
    {  r=c;  } 
    void Show();
private:
    double r;
};
void Circle::Show()
{	cout<<"半徑="<<r<<endl<<"圓心=";
	cout<<x<<","<<y<<endl;//等價於p.Show();	
}
int main()
{
Circle c1(100,100,10);//定義派生類物件 
Point p1=c1,*p2=&c1,&p3=c1;//基類物件、物件指標和物件引用 
p1.Show();
p2->Show();//賦值相容規則
p3.Show();	
return 0;
}

執行結果：100,100
100,100
100,100

組合與繼承的比較

• “包含 has-a”關係用組合來表達
• “屬於is-a”關係用繼承來表達
• 在更多的時候，組合關係比繼承更能使系統具有高度的靈活性，可維護行，並且提高系統的可重用性。

許多時候都要求將組合與繼承兩種技術結合起來使用，建立一個更復雜的類。

圓類設計與分析-平臺9.9題

設有一個Point類，有資料成員x和y。另有一個Color類，有資料成員a。
要求從Point類公有派生出Circle類，增加了資料成員r和顏色物件p，這3個類都定義了Show函式輸出其資料資訊。要求Circle類的定義採用組合與繼承技術結合。

#include <iostream>
using namespace std;
enum MyColor{BLACK, WHITE,RED,YELLOW,GREEN};
class Point
{protected:
	double x,y;	
public:
	Point(double a,double b)
	{x=a;y=b;
	cout<<"呼叫Point類帶參建構函式"<<endl;
	}
	Point()
	{x=0;y=0;
	cout<<"呼叫Point類無參建構函式"<<endl;
	}
	void Show()
	{	cout<<x<<","<<y;	}	
};
class Color
{
protected:
		MyColor a;
public:	
	Color(MyColor b) 
	{a=b;
	 cout<<"呼叫Color類帶參建構函式"<<endl; 
	}
	Color() 
	{a=BLACK;
	 cout<<"呼叫Color類無參建構函式"<<endl; 
	}
	Color(Color &r) 
	{a=r.a;
	 cout<<"呼叫Color類拷貝建構函式"<<endl; 
	}
	void Show()
	{
		cout<<"顏色=";
		switch (a)
		{
			case 0:cout<<"BLACK"<<endl;break;
			case 1:cout<<"WHITE"<<endl;break;
			case 2:cout<<"RED"<<endl;break;
			case 3:cout<<"YELLOW"<<endl;break;
			case 4:cout<<"GREEN"<<endl;break;
			default:cout<<"QITA"<<endl;
		}
	}	
};
class Circle:public Point
{	
public:	
    Circle(double a,double b,double c,Color &d):Point(a,b),p(d)  
    {  r=c;  }     	
	void Show();
private:
	double r;
	Color p;	
};
void Circle::Show()
{
	cout<<"半徑="<<r<<endl<<"圓心=("<<x<<","<<y<<")"<<endl;
	p.Show();		
}

int main()
{
	Color b(RED);
	Circle c1(100,100,10,b);//定義圓物件
	c1.Show();//呼叫成員函式		
	return 0;
}

//組合和繼承結合時，先呼叫基類建構函式，再呼叫組合物件的建構函式，最後呼叫派生類的建構函式。

執行結果：
呼叫Color類帶參建構函式
呼叫Point類帶參建構函式
呼叫Color類拷貝建構函式
半徑=10
圓心=(100,100)
顏色=RED

基類的成員函式在派生類中過載

例9.6 基類的成員函式在派生類中過載示例1
#include <iostream>
using namespace std;
class A  
{  int a;
public:  
    void fn()  
    {a=0;
    cout<<"A::"<<a<<endl;
    }   
    void fn(int a)  
    {this->a=a;
    cout<<"A::"<<a<<endl;
    }  
};    
class B : public A  
{  
  int b;   
};  
 int main()  
{  B b;  //B類沒有對fn函式進行同名覆蓋
    b.fn(3);
    b.fn();
    return 0;  
}

結果：
A::3
A::0

例9.7：基類的成員函式在派生類中過載示例2-在例9.6基礎上改

#include <iostream>
using namespace std;
class A  
{  int a;
public:  
    void fn()  
    {cout<<"A::0"<<endl;}    
    void fn(int a)  
    {this->a=a;
    cout<<"A::"<<a<<endl;}  
};    
class B : public A  
{  
public:  
    void fn(int a)  //B類對fn函式進行同名覆蓋
    {cout<<"B::"<<a<<endl;}  
};    
int main()  
{   B b;  
    b.fn(3);
    b.fn();
    return 0;  
}


結果：
錯誤資訊：no matching function for call to 'B::fn()'

例9.8：基類的成員函式在派生類中過載示例2修改

#include <iostream>
using namespace std;
class A  
{  int a;
public:  
    void fn()  
    {cout<<"A::0"<<endl;}    
    void fn(int a)  
    {this->a=a;
    cout<<"A::"<<a<<endl;}  
};    
class B : public A  
{  
public:  
    void fn(int a)  //同名覆蓋 
    {cout<<"B::"<<a<<endl;}  
    void fn()  //同名覆蓋 
    {A::fn();//用類名::,將隱藏的A類函式呼叫 
    }  
};    
int main()  
{   B b;  
    b.fn(3);//同名覆蓋，呼叫B類重寫的函式 
    b.A::fn(3);//用類名::,將隱藏的A類函式呼叫 
    b.fn();//同名覆蓋，間接呼叫隱藏的A類函式 
    return 0;  
}

當派生類寫一個和基類同名（無論引數列表相同或不相同）的函式時，此時發生的動作叫“覆蓋”。覆蓋的意思，就是基類的同名函式，在派生類內，將變得無法直接呼叫（但可以間接呼叫）。

要訪問A的過載函式，一種方式是直接用基類名：：函式，可以將隱藏的基類函式呼叫，比如：b.A::fn(3); 還有一種方法是間接呼叫，在派生類中再寫一個同名函式，裡面程式碼用基類名：：函式間接呼叫，比如：b.fn();。