C++多重继承及多态性原理实例详解

#include <iostream>
using namespace std;
class BaseA {
public:	void fun() { cout << "A.fun" << endl; }
};
class BaseB {
public:
	void fun() { cout << "B.fun" << endl; }
	void tun() { cout << "B.tun" << endl; }
};
class Derived :public BaseA, public BaseB {
public:
	void tun() { cout << "D.tun" << endl; }
	void hun() { fun(); } //此处调用出现二义性,编译无法通过
};
int main() {
	Derived d, * p = &d; d.hun();
	return 0;
}

#include <iostream>
using namespace std;
class Base {
public:
	void fun() { cout << "A.fun" << endl; }
	Base(int x = 1, int y = 2) :x(x), y(y) {}
	int x, y;
};

class Derived :public Base{
public:
	void tun() { cout << "D.tun" << endl; }
	void fun() { cout << "D.fun" << endl; }
	Derived(int x = 0) :x(x) {}
	int x;
};
int main() {
	Derived d, * p = &d;
	d.fun();	//输出的结果为	D.fun
	cout << p->x << " " << p->y << " " << p->Base::x << endl; //输出为 0 2 1
	d.Base::fun(); //输出为	A.fun
}

#include <iostream>
using namespace std;
class Base {
public:
	Base(int n) { nv = n; cout << "Member of Base" << endl; }
	void fun() { cout << "fun of Base" << endl; }
private:
	int nv;
};
class A:virtual public Base {	//声明Base为虚基类,作为间接基类都需要使用virtual关键字
public:
	A(int a) :Base(a) { cout << "Member of A" << endl; }
private:
	int na;
};
class B :virtual public Base { //声明Base为虚基类，作为间接基类都需要使用virtual关键字
public:
	B(int b) :Base(b) { cout << "Member of B" << endl; }
private:
	int nb;
};
class Derived :public A, public B {
public:
	Derived(int n) :Base(n), A(n), B(n) { cout << "Member of Derived" << endl; }
  //派生类的构造函数初始化列表，先调用基类Base的构造函数，再依次调用间接基类A、B的构造函数
  //由于虚基类Base中没有默认构造函数（允许无参构造），所以从Base类继承的所有派生类的构造函数初始化表中都需要显式调用基类（包括间接基类）的构造函数，完成初始化
private:
	int nd;
};
int main() {
	Derived de(3); de.fun();//不会产生二义性
	return 0;
}

#include <iostream>
using namespace std;
class Base {
public:
	virtual void print() { cout << "Base-print" << endl; }
};
class Derived :public Base {
public:
	void print() { cout << "Derived-print" << endl; }
};
void display(Base* p, void(Base::* pf)()) {
	(p->*pf)();
}
int main() {
	Derived d; Base b;
	display(&d, &Base::print);	//输出Derived-print
	display(&b, &Base::print);	//输出Base-print
  return 0;
}

#include <iostream>
#define PI 3.14159265
using namespace std;
class Point {
public:
	Point(double x = 0, double y = 0) :x(x), y(y) {}
	double area_static() { return 0; }	//不是虚函数，只会在编译期绑定，形成静态联编
	virtual double area_dynamic() { return 0; } //用虚函数声明，则编译时只做赋值兼容的合法性检查，而不做绑定
private:
	double x, y;
};
class Circle :public Point {
public:
	Circle(double r = 1.0) :r(r) {} //由于基类中的构造函数非必须显式传参，所以系统会自动调用基类带默认参数的构造函数
	Circle(double x, double y, double r=1.0) :Point(x, y), r(r) {} //重载一个可传坐标点、半径值参数的构造函数
	double area_static() { return PI * r * r; } //静态联编
	double area_dynamic() { return PI * r * r; } //动态联编（仍为虚函数），为使可读性更好，可在不缺省virutal关键字
private:
	double r;
};
int main() {
	Point o(2.5, 2.5); Circle c(2.5, 2.5, 1);
	Point* po = &o, * pc = &c, & y_c = c;
//下面五个全部为静态联编，无论指针指向的是基类还是派生类，由于指针类型为基类类型，且调用的不是虚函数，则统一绑定为基类中的函数
	cout << "Point area =" << o.area_static() << endl;	//值为0
	cout << "Circle area=" << c.area_static() << endl;	//值为3.14159
	cout << "the o area from po:" << po->area_static() << endl; //值为0
	cout << "the c area from pc:" << pc->area_static() << endl;	//值为0
	cout << "the c area from cite y_c:" << y_c.area_static() << endl; //值为0
//下面三个为动态联编，有指针（或引用）、虚函数，则所调用的虚函数会在运行时通过vptr指针找到虚函数表	，根据指针指向的实际对象（而非指针类型）来判定调用谁的函数
	cout << "the o area from po:" << po->area_dynamic() << endl; //值为0
	cout << "the c area from pc:" << pc->area_dynamic() << endl; //值为3.14159
	cout << "the c area from cite y_c:" << y_c.area_dynamic() << endl; //值为3.14159
  //强制使用静态联编
  cout << "the c area calculated by Point::area_():" << pc->Point::area_dynamic() << endl; //值为0
	return 0;
}