c++面向对象程序设计——基类和派生类

                                       基类和派生类
        一个大的应用程序通常由多个类构成，类与类之间互相协调工作。在面向对象技术中，类是数据与操作的集合，它们之间主要有三种关系：Has-A,Uses-A和Is-A.
        Has-A表示类的包含关系，用以描述一个类由多个“部件类”构成。在面向对象技术中，实现 Has-A关系用类成员表示，即子对象.
        Uses-A关系表示一个类部分的使用另一个类。在面向对象技术中，这种关系通过类之间成员函数的相互联系或对象参数传递实现。另外，通过定义有缘也能实现这种关系。
        Is-A表示一种分类表示，描述类的抽象和层次关系。

继承和派生类的基本概念

通过继承机制可以利用已有的数据类型来定义新的数据类型。根据一个类创建一个新的类的过程称为继承，也称为派生。新类自动具有原类的成员，根据需要还可以增加新的成员。派生新类的类称为基类，又称父类，而派生出来的称为派生类，又叫子类。
换句话说，继承就是创建一个具有别的类的属性和行为的新类的能力。派生类同样也能作为其他类的基类。这就产生了类的层次性。这样可能不太好理解，下面用一张图来解释。

派生类的操作：
（1）.可以增加新的数据成员。
（2）.可以增加新的成员函数。
（3）.可以重新定义已有的成员函数。
（4）.可以改变现有的成员的属性。
注意：尽管可以从基类中派生出其他类，但是，基类不会被改变。

继承的种类

在c++语言中，一个派生类可以从一个基类中产生，也可以从多个基类派生。单继承也就是从一个基类派生出的继承。而多继承就是从多个基类派生类中继承。

单继承

c++的两种继承方式，无论是哪一种继承方式，都有公有继承，私有继承和保护继承。不同的继承方式，派生类对基类成员拥有的权限不同。
单继承的一般形式：
class<派生类名>：<继承方式><基类名>
{
public:
<公有数据和函数>
protected：
<保护数据和函数>
private：
<受保护数据和函数>
}
下面用一段代码来实现：

//c++面向对象继承派，单继承;
#include
#include
using namespace std;
//创建基类;
class Point
{
	//公有成员;
public:
	void setxy(int myx, int myy) { X = myx, Y = myy; }
	void movexy(int x, int y) { X += x, Y += y; }
//受保护成员;
protected:
	int X, Y;
};
//创建派生类;
class Circle :public Point
{
public:
	void setr(int myx, int myy, int myr) { setxy(myx, myy); R = myr; }
	void display();
protected:
	int R;
};
void Circle::display()
{
	cout << "The postion of center is";
	cout << "(" << X << "," << Y << ")" << endl;
	cout << "The radius of Circle is" << R << endl;
}
int main(void)
{
	Circle c;//派生类对象;
	c.setr(4, 5, 6);
	cout << "The start data of circle:" << endl;
	c.display();
	c.movexy(7, 8);
	cout << "The new data of circle" << endl;
	c.display();
}

通过上面的代码我们可以很明确的看出对于派类的继承，派生类可以访问基类的公有和受保护成员，但是不能访问私有成员，这也就回到了我们前面学过的访问权限。那我们该如何去访问私有成员喃？

派生类的访问控制

        不同的继承方式下，基类中的成员在派生类中的访问权限也不同。基类成员在派生类中的访问权限不仅与继承方式有关，还与基类本身被声明的访问权限有关。
        有了继承之后，我们将会遇到一种新的访问权限：不可访问，所谓的不可访问是指一个成员甚至堆自身所在的类的模块来说也是不可访问的;
        在根类（不是从别的类派生出来的类）中，没有成员是不可以访问的，也就是都可以访问，对于根类来说，可用的访问权限是public，protected，private。但是在派生类中，可以存在第四种访问权限，不可以访问（inaccessible）。不可以访问的成员总是由基类继承而来，即要么是基类的不可访问成员，或者是基类的私有成员。

公有继承

回顾上面的程序（可以自己去试验一下），我们的派生类不能去访问基类的私有成员，那么我们就可以得出，当类的继承为公有继承时，在派生类中，基类的公有成员和收保护成员被继承后分别作为派生类的公有成员和受保护成员。这也就是为什么可以访问基类的公有成员和受保护成员的原因。

赋值兼容规则

（1）.派生类的对象可以赋给基类的对象
DerivedClass d
BaseClass b=d;
(2).派生类的对象可以初始化基类的引用
DerivedClass b;
BaseClass*d=b;
(3).派生类的对象的地址可以传递给基类的指针.
DerivedClass b;
BaseClass *d=&b;

私有继承

当类的继承方式是私有继承时，在派生类中，基类的公有成员和受保护成员作为派生类的私有成员，派生类成员可以访问基类访问他们，但是不能直接昂访问基类的私有成员.
例：

class Circle:private Point//声明私有派生类;
{
  public:
  void setr(int myx,int myy,int myr){setxy(myx,myy);R=myr;}
  void displaysy(
;
protected:
int R;
}

尤其要记住，在子类对象中，只能访问公有成员，其他的都不可以访问，一定要注意这一点。

多继承

神什么叫做多继承？回想前面我们学到的单继承，那么通过字面意思多继承其实就是多个基类的继承。
单继承其实可以看作时多继承的一个特例，多继承可以看作是多个单继承的组合，他们有很多相同的特性。每个基类与派生类的关系可以通过将这个基类与派生类视为一个单继承进行讨论。

多继承的定义格式

一个类由多个基类派生的一般形式：
class<派生类名>:<继承方式><基类名1>,~~~~<继承方式><基类名2>
{
<定义派生类的自己的成员>
}
话不多说，直接上代码：

#include
using namespace std;
class Baseclass1 
{
public:
	void seta(int x) 
	{
		a = x;
	}
	void showa()
	{
		cout << "a=" << a << endl;
	}
private:
	int a;
};
class Baseclass2
{
public:
	void setb(int x)
	{
		b = x;
	}
	void showb()
	{
		cout << "b=" << b << endl;
	}
private:
	int b;
};
//多继承;
class Derivedclass :public Baseclass1, private Baseclass2
{
public:
	void setbc(int x, int y)
	{
		setb(x);
		c = y;
	}
	void showbc()
	{
		showb();
		cout << "c=" << c << endl;
	}
private:
	int c;
};
int main(void)
{
	Derivedclass obj;
	obj.seta(5);
	obj.showa();
	obj.setbc(7, 9);
	obj.showbc();
}

通过上面的程序我们不难发现，类Derivedclass的对象的数据结构由类Baseclass1中的成员和类Baseclass中的成员和类Derivedclass中的成员共同构成。

二义性和支配规则

上面的程序我们在构建不同类的成员的时候都是不同的声明，但是我们在解决某些问题的时候，可能会出现多个基类的成员函数相同，那么我们在访问的时候，会不会出现不确定的情况？这就是我们今天学的二义性
我们先来看一个程序：

#include
using namespace std;
class Baseclass1 
{
public:
	void seta(int x) { a = x; }
	void show() { cout << "a=" << a << endl; }
private:
	int a;
};
class Baseclass2
{
public:
	void setb(int x) { b = x; }
	void show() { cout << "b=" << b << endl; }
private:
	int b;
};
class Derivedclass :public Baseclass1, public Baseclass2 
{

};
int main(void)
{
	Derivedclass obj;
	obj.seta(2);
	obj.show();//出现二义性，不能编译;
	obj.setb(4);
	obj.show();//出现二义性，不能编译;
}

上面的程序在编译的时候会报错，由于我们没指名调用的函数是呢哪一个类的成员，所以编译器无法识别，那我们如何来解决这种情况喃？
若要消除二义性，需要使用作用域运算符：：;

我们只需要将上面的程序更改如下就可以避免二义性;
obj.Baseclass1::show();
obj.Baseclass2::show();
}

我们除了这一种解决情况，。是不是就没有其他的解决方案？
我们也可以通过在派生类Derivedclass总定义下列函数show()，然后去掉主函数中的第一个obj.show（）语句;

#include
using namespace std;
class Baseclass1 
{
public:
	void seta(int x) { a = x; }
	void show() { cout << "a=" << a << endl; }
private:
	int a;
};
class Baseclass2
{
public:
	void setb(int x) { b = x; }
	void show() { cout << "b=" << b << endl; }
private:
	int b;
};
class Derivedclass :public Baseclass1, public Baseclass2 
{
public:
	void show()
	{
		Baseclass1::show();
		Baseclass2::show();
	}
};
int main(void)
{
	Derivedclass obj;
	obj.seta(2);
	obj.setb(4);
	obj.Derivedclass::show();
}

最终得到的结果和上面的程序结果一样。

支配规则

类X中的名字N支配类Y中的同名的名字N，是指类X一类Y作为它的一个基类。

访问共同基类的成员时可能出现二义性

如果一个派生类从多个基类派生而来，而这些基类又有一个共同的基类，则在这个派生类中访问这个共同基类中的成员时可能产生二义性.

//#include
//using namespace std;
//class Baseclass1 
//{
//public:
//	void seta(int x) { a = x; }
//	void show() { cout << "a=" << a << endl; }
//private:
//	int a;
//};
//class Baseclass2
//{
//public:
//	void setb(int x) { b = x; }
//	void show() { cout << "b=" << b << endl; }
//private:
//	int b;
//};
//class Derivedclass :public Baseclass1, public Baseclass2 
//{
//public:
//	void show()
//	{
//		Baseclass1::show();
//		Baseclass2::show();
//	}
//};
//int main(void)
//{
//	Derivedclass obj;
//	obj.seta(2);
//	obj.setb(4);
//	obj.Derivedclass::show();
//}
#include
using namespace std;
class Base
{
protected:
	int val;
};
class Baseclass1 :public Base
{
public:
	void seta(int x) { val = x; }
};
class Baseclass2 :public Base
{
public:
	void setb(int x) { val = x; }
};
class Derivedclass :public Baseclass1, public Baseclass2
{
public:
	void show() { cout << "val=" << val << endl; } //h含义不清，不能编译;}
};
int main(void)
{
	Derivedclass obj;
	obj.seta(2);
	obj.show();
	obj.setb(4);
	obj.show();
}
程序分析：该程序中四个类的关系如下图，由于两条继承路径上的成员val
相互之间没有支配关系。

若要消除二义性，我们依旧要使用作用域运算符;
程序更改为：

//#include
//using namespace std;
//class Baseclass1 
//{
//public:
//	void seta(int x) { a = x; }
//	void show() { cout << "a=" << a << endl; }
//private:
//	int a;
//};
//class Baseclass2
//{
//public:
//	void setb(int x) { b = x; }
//	void show() { cout << "b=" << b << endl; }
//private:
//	int b;
//};
//class Derivedclass :public Baseclass1, public Baseclass2 
//{
//public:
//	void show()
//	{
//		Baseclass1::show();
//		Baseclass2::show();
//	}
//};
//int main(void)
//{
//	Derivedclass obj;
//	obj.seta(2);
//	obj.setb(4);
//	obj.Derivedclass::show();
//}
#include
using namespace std;
class Base
{
protected:
	int val;
};
class Baseclass1 :public Base
{
public:
	void seta(int x) { val = x; }
};
class Baseclass2 :public Base
{
public:
	void setb(int x) { val = x; }
};
class Derivedclass :public Baseclass1, public Baseclass2
{
public:
	void show() { cout << "val=" << Baseclass1::val<< endl; } //h含义不清，不能编译;}
	//void show() { cout << "val=" << Baseclass2::val << endl; }
};
int main(void)
{
	Derivedclass obj;
	obj.seta(2);
	obj.show();
	obj.setb(4);
	obj.show();
}

注意：void show(){cout<<"val="<<Base::val<<endl;也有二义性;

示例类Derivedclass的对象包含基类Base的两个基类子对象：

#include
using namespace std;
class Base
{
protected:
	int val;
};
class Baseclass1 :public Base
{
public:
	void seta(int x) { val = x; }
};
class Baseclass2 :public Base
{
public:
	void setb(int x) { val = x; }
};
class Deviredclass :public Baseclass1, public Baseclass2
{
public:
	void show();
};
void Deviredclass::show()
{
	cout << "Baseclass val=" << Baseclass1::val << endl;
	cout << "Baseclass2 val=" << Baseclass2::val << endl;
}
int main(void)
{
	Deviredclass obj;
	obj.seta(3);
	obj.setb(4);
	obj.show();
}

通过上述例子我们不难看出，对于基类Base，在访问Base的成员时，发生了冲突，这个时候就要用到作用域运算符。如上图。

虚基类

引进虚基类的目的是为了解决二义性问题，使得公共基类在他的派生类对象中只产生一个基类子对象。
虚基类说明格式如下：
virtual<继承方式>基类名
virtual是说明虚基类的关键字。虚基类的说明是在派生类名的后面。在派生类中使用关键字virtual会导致他们共享基类Base的同一个单独公共对象。因此，Base是虚基类。

代码演示：

#include
using namespace std;
class Baseclass1 
{
public:
	void seta(int x) { a = x; }
	void show() { cout << "a=" << a << endl; }
private:
	int a;
};
class Baseclass2
{
public:
	void setb(int x) { b = x; }
	void show() { cout << "b=" << b << endl; }
private:
	int b;
};
class Derivedclass :public Baseclass1, public Baseclass2 
{
public:
	void show()
	{
		Baseclass1::show();
		Baseclass2::show();
	}
};
int main(void)
{
	Derivedclass obj;
	obj.seta(2);
	obj.setb(4);
	obj.Derivedclass::show();
}
//#include
//using namespace std;
//class Base
//{
//protected:
//	int val;
//};
//class Baseclass1 :public Base
//{
//public:
//	void seta(int x) { val = x; }
//};
//class Baseclass2 :public Base
//{
//public:
//	void setb(int x) { val = x; }
//};
//class Derivedclass :public Baseclass1, public Baseclass2
//{
//public:
//	void show() { cout << "val=" << Baseclass1::val<< endl; } //h含义不清，不能编译;}
//	//void show() { cout << "val=" << Baseclass2::val << endl; }
//};
//int main(void)
//{
//	Derivedclass obj;
//	obj.seta(2);
//	obj.show();
//	obj.setb(4);
//	obj.show();
//}
//
#include
using namespace std;
class Base
{
protected:
	int val;
};
class Baseclass1 :public virtual Base
{
public:
	void seta(int x) { val = x; }
};
class Baseclass2 :public virtual Base
{
public:
	void setb(int x) { val = x; }
};
class Deviredclass :public Baseclass1, public Baseclass2
{
public:
	void show();
};
void Deviredclass::show()
{
	cout << "Baseclass val=" << val << endl;
}
int main(void)
{
	Deviredclass obj;
	obj.seta(3);
	obj.show();
	obj.setb(4);
	obj.show();
}

注意：

一个派生类可以公有或私有继承一个或多个虚基类，关键字virtual和关键字public，private的位置无关紧要，但是要放在基类名之前。比呢且virtual支队精髓气候的基类名起作用。