C++多重继承，虚基类与友元

一.多重继承

就是一个类继承多个基类；

class <派生类名>：<派生方式1><基类名1>,```<派生方式n><基类名n>

class Derived:public:Base1,public:Base2

上述形式：基类之间由逗号隔开，且必须指明继承方式，否则默认为私有继承；

1.注意事项：

a.各种派生方式对于基类成员在派生类中的访问权限与单继承相同；

b.在使用多继承时，对基类成员的访问应无二义性

 2.二义性问题：

多重继承需要解决的主要问题：标识符不唯一造成的二义性，当继承的多个基类中有同名成员时就会造成二义性问题，这是不被允许的；

class Base1
{
public:
	int x;
	int a();
	int b();
};
class Base2
{
	int x;
	int a();
public:
	float b();
};
class Derived :Base1, Base2
{
	;
};

void d(Derived& e)
{
	e.x = 10;
	e.a();
	e.b();
}

int main()
{
	Derived ob;
	return 0;
}

像上述：Base1和Base2中都有相应的 x,a,b成员，此时就会造成二义性；

如何解决？

（1）使用域运算符“：：”（范围解析运算符）

派生类的基类之间没有继承关系，同时又没有共同的基类，（基类之间不是父与子的关系，也不是兄弟关系）则在引用同名成员时，可以在成员名前加上类名和域运算符来区别来自不同的基类的成员；

void d(Derived& e)
{
	e.Base1::x = 10;
	e.Base1::a();
	e.Base2::b();
}

使用域运算符，将d函数修改为这个形式就可以调用相应的函数，不再有二义性；非常直观

（2）使用同名覆盖的原则

在派生类中重新定义与基类中同名的成员（如果是成员函数，则参数表也要相同，参数不同则为重载）以屏蔽掉基类中的同名成员，在引用这些同名的成员时，引用的就是派生类中的成员；

class Base
{
public:
	int x;
	void show()
	{
		cout << "This is Base x=" << x << endl;
	}
};

class Derived :public Base
{
public:
	int x;
	void show()
	{
		cout << "This is Derived x=" << x << endl;
	}
};

int main()
{
	Derived ob;
	ob.x = 5;
	ob.show();
	ob.Base::x = 12;
	ob.Base::show();
	return 0;
}

此时直接调用类对象的成员就是派生类中的，不会产生歧义；

（3）使用虚基类（后面再提）

3.多重继承的构造函数和析构函数

在C++中声明多重继承构造函数的一般形式：

<派生类名>（参数总表）::基类名1（参数表）……基类名n（参数表n)，对象成员名1（对象成员参数表1）……对象成员名n（对象成员参数表n)

多重继承构造函数和析构函数的执行顺序与单继承相同，但是需要强调的是，基类之间的执行顺序是严格按照声明从左到右的顺序来的，与他们在定义派生类构造函数中的次序无关；

class Base1
{
	int x1;
public:
	Base1(int y1)
	{
		x1 = y1;
		cout << "constructing Based,x1=" << x1 << endl;
	}
	~Base1()
	{
		cout << "destructing Base1" << endl;
	}
};

class Base2
{
	int x2;
public:
	Base2(int y2)
	{
		x2 = y2;
		cout << "constructing Base2.x2=" << x2 << endl;
	}
	~Base2()
	{
		cout << "destructing Base2" << endl;
	}
};

class Derived :public Base2, public Base1
{
private:
	Base1 ob1;
	Base2 ob2;
public:
	Derived(int x, int y, int z, int v) :Base1(x), Base2(y), ob1(z), ob2(v)
	{
		cout << "constructing Derived" << endl;
	}
};

int main()
{
	Derived ob(1, 2, 3, 4);
	return 0;
}

上述代码的运行结果为：

由此我们可以理解上面那句话： 基类之间的执行顺序是严格按照声明从左到右的顺序来的，与他们在定义派生类构造函数中的次序无关；

在上述程序中，先继承的Base2，那么先执行基类Base2，之后再执行Base1；

在定义对象的时候，先定义的为ob1，那么先执行Base1的初始化，再执行Base2的初始化

二.虚基类

虚基类是指被virtual修饰，用来解决基类中由于同名成员的问题而产生的二义性问题；

1.虚基类的声明

在派生类的声明过程中进行的：class <派生类名>: virtual<派生方式><基类名>

只对紧跟在virtual后的基类起作用；

class Base1:virtual public Base

声明虚基类之后，虚基类的成员在进一步派生过程中和派生类一起维护同一个内存！

class Base
{
protected:
	int x;
public:
	Base()
	{
		x = 1;
	}
};

class Base1 :virtual public Base
{
public:
	Base1()
	{
		cout << "constructing Base1,x=" << x << endl;
	}
};

class Base2 :virtual public Base
{
public:
	Base2()
	{
		cout << "constructing Base2,x=" << x << endl;
	}
};

class Derived :public Base1, public Base2
{
public:
	Derived()
	{
		cout << "constructing Derived x=" << x << endl;
	}
};

int main()
{
	Derived obj;
	return 0;
}

由于把公共基类Base声明为类Base1和Base2的虚基类，所以由类Base1和类Base2派生的类Derived只有一个基类Base，在这里虚基类就可以避免二义性；按照顺序执行虚基类1，虚基类2的构造函数；（默认构造函数不需要调用，且这里都是没有参数的构造函数）

2.虚基类的构造函数和初始化

虚基类的初始化与一般的多继承的初始化在语法上是一样的，但构造函数的执行顺序不同；

（1）基类的构造函数；（2）虚基类的构造函数1；虚基类的构造函数2......(3)非虚基类的构造函数

class Base
{
protected:
	int x;
public:
	Base(int x1)
	{
		x = x1;
		cout << "constructing Base,x=" << x << endl;
	}
};

class Base1 :virtual public Base
{
	int y;
public:
	Base1(int x1, int y1) :Base(x1)
	{
		y = y1;
		cout << "constructing Base1,y=" << y << endl;
	}
};

class Base2 :virtual public Base
{
	int z;
public:
	Base2(int x1, int z1) :Base(x1)
	{
		z = z1;
		cout << "constructing Base2,z=" << z << endl;
	}
};

class Derived :public Base1, public Base2
{
	int xyz;
public:
	Derived(int x1, int y1, int z1, int xyz1) :Base(x1), Base1(x1, y1), Base2(x1, z1)
	{
		xyz = xyz1;
		cout << "constructing Derived xyz=" << xyz << endl;
	}
};

int main()
{
	Derived obj(1, 2, 3, 4);
	return 0;
}

 

在这里我们可以看出：虚基类Base的构造函数只执行了一次，因为当派生类Derived调用了虚基类Base的构造函数后，类Base1和Base2对虚基类的构造函数调用被忽略了！

注意事项：

a.virtual和派生方式的关键字的书写位置无关紧要，可以先写虚基类的关键字，也可以先写派生方式的关键字；

b.一个基类在作为某些类的虚基类的同时也可以作为另一些类的非虚基类；

c.虚基类构造函数的参数必须是由最新派生出来的类负责初始化，即使不是直接继承也是这样！（就是上面的derived：Base(x)，初始化x）

三.友元

友元是用关键字friend修饰的，它提供了不同的类或对象的成员函数之间，类的成员函数与一般函数之间进行数据共享的机制。

1.友元的引入

引入友元的目的：为了使类的私有成员和保护成员能够被其他类或其他成员函数访问；

分类：（1）友元函数：友元是普通函数或类的成员函数；（2）友元类：友元是一个类

（友元类的所有成员函数都称为友元函数）；

2.友元函数

友元函数不是当前类的成员函数，而是独立于当前类的外部函数；它可以是普通函数或者其他类的成员函数。友元函数定义后可以访问该类的所有对象的所有成员函数，包括私有成员，保护成员和公有成员；

友元函数使用之前必须要在类定义时声明：其定义可以在类内部进行，也可以在类外部进行，但通常都定义在类的外部；

C++将普通函数声明为友元函数的一般形式：

friend<数据类型><友元函数名>(参数表）

eg:friend double area(Rectangle &rectangle);

class Rectangle
{
	double length, width;
public:
	Rectangle(double a = 0, double b = 0)
	{
		length = a;
		width = b;
	}
	//Rectangle(Rectangle& r);//不重载也完全没影响啊！！！
	friend double area(Rectangle& rectangle);

};

double area(Rectangle& rectangle)
{
	return(rectangle.width * rectangle.length);
}
int main()
{
	Rectangle ob(4, 5);
	cout << "The area is:" << area(ob) << endl;
	return 0;
}

上述程序，如果把friend关键字去掉，那么在函数外定义的area函数就会报错，因为width和length都是类的私有成员，不可访问；但是加上友元定义就可以访问；

3.友元成员

如果一个类的成员函数是另一个类的友元函数，那么称这个成员函数为友元成员，那么通过该成员函数可以访问另一个类的成员，也可以访问自己所在类的成员；

——可以使得两个类相互访问；

class boy;
class girl
{
	char* name;
	int age;
public:
	girl(const char* n, int a)
	{
		name = new char[strlen(n) + 1];

		strcpy(name, n);
		age = a;
	}
	void prt(boy& b);
};

class boy
{
	char* name;
	int age;
public:
	boy(const char* n, int a)
	{
		name = new char[strlen(n) + 1];
		strcpy(name, n);
		age = a;
	}
    friend void girl::prt(boy& b);//声明友元成员
};

void girl::prt(boy& b)//定义友元成员
{
	cout << "girl's name" << name << " " << "age" << age << endl;
	cout << "boy's name" << b.name << " " << "age" << b.age << endl;
}

int main()
{
	girl gl("ztn", 19);
	boy bl("zhang", 18);
	gl.prt(bl);
	return 0;
}

在boy类内声明了girl类的成员函数prt为其友元，girl的prt既可以访问girl类的成员，也可以访问boy类的数据成员name和age；

上述：声明友元成员，定义友元成员等与上面的友元函数的区别就在于，此时存在两个类，该有友元成员可以访问另一个类的私有成员，保护成员和公有成员等；

上面也谈到：友元可以实现一般函数与成员函数之间，不同类之间进行数据共享的方式，那个人理解：友元函数：就可以实现一般函数与成员函数之间的数据共享，而友元成员则实现不同类之间的数据共享！

使用友元成员需注意：

（1）必须先定义成员函数所在的类；上述例子中就是先定义了girl

（2）声明友元函数时，要加上成员函数所在类的类名和作用域，使用域运算符

（3）在主函数中一定要创建类girl的一个对象，只有这样才能通过对象名调用友元函数。

（4）如果在类定义前要使用到该类的成员，需要在使用前对该类进行声明，如class boy;（那么在上面的程序中，就是先声明友元函数所在的类，但是并不定义，先将友元成员所在的类进行声明定义，再定义友元函数的所在的类）

4.友元类

一个类作为另一个类的友元，称这个类为友元类。友元类中的所有成员函数都成为另一个类的友元函数。友元类中的所有成员函数都可以通过对象名直接访问另一个类中的所有成员，从而实现不同类之间的数据共享；

friend class<友元类名>——friend class girl

class boy;
class girl
{
	char* name;
	int age;
public:
	girl(const char* n, int a)
	{
		name = new char[strlen(n) + 1];
		strcpy(name, n);
		age = a;
	}
	void prt(boy& b);
};

class boy
{
	char* name;
	int age;
	friend class girl;
public:
	boy(const char* n, int a)
	{
		name = new char[strlen(n) + 1];
		strcpy(name, n);
		age = a;
	}
};

void girl::prt(boy& b)
{
	cout << "girl's name" << name << " " << "age" << age << endl;
	cout << "boy's name" << b.name << " " << "age" << b.age << endl;
}

int main()
{
	girl gl("ztn", 18);
	boy bl("zhang", 19);
	gl.prt(bl);
	return 0;
}

其实可以看出和友元成员类似，最终的运行结果也一样！都实现了不同类之间的数据共享。

---