c++类——类与类之间的关系

¶（一）依赖：

¶1. 概念：

是一种使用关系，耦合度最弱。类A使用类B的一部分属性和方法，不会主动改变类B的内容，但是类B的变化会影响到A。具有偶然性、临时性。

¶2. 体现：

• 类B作为类A的成员函数参数。

• 类B作为A的成员函数的局部变量

• 类A的成员函数调用的类B的静态方法

¶3. 代码：

#include<iostream>
using namespace std;
class B
{
public:
	static void showB()
	{
		cout << "showB" << endl;
	}
};
class A
{
public:
	void CallB1() 
	{
		B::showB();
		return;
	}
	void CallB2(B b) 
	{
		b.showB();
		return;
	}
	void CallB3() 
	{
		B b;
		b.showB();
		return;
	}
};

int main() 
{
	B b;
	A a;
	a.CallB1();
	a.CallB2(b);
	a.CallB3();
	return 0;
}
//运行结果：
//showB
//showB
//showB

¶（二）关联：

¶1. 概念：

关联是对象之间的一种引用关系，用于表示一类对象与另一类对象的联系。

关连也是一种弱从属关系，是可以有方向的，可以是单向也可以是双向的。

关联体现的是两个类之间的一种强依赖关系，不存在偶然性和临时性，一般是长期性的、平等的。

依赖和关联都是一个类用乐另一个类，但是前者是使用，后者是拥有。

¶2. 体现：

• 被关联类B以类的属性形式出来在关联类A中。

• 关联类A引用了一个类型为被关联类B的全局变量。

¶3. 代码：

#include<iostream>
using namespace std;
//A和B是关联关系：
class Me;
class You
{
private: 
	Me* pm;
public:
	void printMe();
	void printYou();
};
class Me
{
private:
	You* py;
public:
	void printme();
	void printyou();
};
void You::printMe()
{
	cout << "You:" << endl;
	pm->printme();
	return;
}
void You::printYou()
{
	cout << "我中有你" << endl;
	return;
}
void Me::printyou()
{
	cout << "Me:" << endl;
	py->printYou();
	return;
}
void Me::printme()
{
	cout << "你中有我" << endl;
	return;
}
int main() 
{
	Me zzh;
	zzh.printyou();
	zzh.printme();
	You xxx;
	xxx.printMe();
	xxx.printYou();
	return 0;
}

//
//Me:
//我中有你
//你中有我
//You :
//你中有我
//我中有你

¶（三）聚合：

¶1. 概念：

聚合关系又名委托关系，聚合关系是关联关系的一种，是一种强关联关系，是整体和部分之间的关系，是has-a的关系。

聚合关系也是一种弱所属关系，整体和部分之间是可分离的，具有各自的生命周期，部分可以属于多个整体的对象，也可以为多个整体对象共享。

聚合和关联的区别主要是语义，关联的两个对象一般是平等的，而聚合一般不是平等的。

¶2. 体现：

聚合通过成员对象来实现的。

聚合需要配合语义，结合上下文才能判断出是否为聚合，无法直接判断。

¶3. 代码：

#include<iostream>
using namespace std;
class Husband;
class Wife;
class House
{
private:
	string name;
public:
	House(string s="家"):name(s){}
	void showname()
	{
		cout << "家:" << name << endl;
	}
};
class Husband 
{
private:
	House h;
	string name;
public:
	Husband(string s1, string s2="zzh") :h(s1),name(s2) 
	{
	}
	void showHouse() 
	{
		h.showname();
		cout << "丈夫" << name << endl;
	}
};
class Wife
{
private:
	House h;
	string name;
public:
	Wife(string s1, string s2 = "xxx") :h(s1), name(s2)
	{
	}
	void showHouse()
	{
		h.showname();
		cout << "妻子:"<<name << endl;
	}
};
int main() 
{
	Husband me("home");
	Wife who("Home");
	me.showHouse();
	who.showHouse();
	return 0;
}
//运行结果：
//家:home
//丈夫zzh
//家 : Home
//妻子 : xxx

¶（四）组合：

¶1. 概念：

也是关联关系的一种特例，是整体和部分的关系，一个对象（是部分）被放到另一个对象中（是整体），是contains-a的关系。

是一种强所属关系（比聚合更强），和聚合不同的是，整体和部分是不可分的，具有相同的生命周期，整体（组合类）可以控制部分（被组合类）的生命周期，整体的对象不存在，则部分的对象也不存在，也就是部分对象不能独立存在。

相比聚合，组合的两个对象的不平等性进一步加大。

¶2. 体现：

同聚合关系，组合也是通过成员对象来实现的。

组合也需要配合语义，结合上下文才能判断出是否为聚合，无法直接判断。

聚合和组合的最关键区别是两个对象的生命周期是否一致，而不是出现的形式。

¶3. 代码：

#include<iostream>
using namespace std;
class eye
{
private:
	double lefteyesight;
	double righteyesight;
public:
	eye(double d1, double d2) :lefteyesight(d1), righteyesight(d2) 
	{
	}
	void printeyesight() 
	{
		cout << "左眼:" << lefteyesight << endl;
		cout << "右眼:" << righteyesight << endl;
		return;
	}
};
class person
{
private:
	eye e;
	int sex;
public:
	person(int x=0, double d1 = 1.0, double d2 = 1.0) :e(d1, d2), sex(x){}
	void printperson() 
	{
		cout << "性别:" << sex << endl;
		e.printeyesight();
		return;
	}
};
int main() 
{
	person p;
	p.printperson();
	return 0;
}
//运行结果:
//性别:0
//左眼 : 1
//右眼 : 1

¶（五）实现：

¶1. 概念：

是接口与实现类之间的关系，在此关系中，类实现接口，类中的操作实现了接口中所声明的所有的抽象操作。

¶2. 体现：

接口通过纯虚函数来实现，多态就是通过虚函数来实现的。

¶3. 代码：

#include<iostream>
using namespace std;
class person
{
public:
	virtual void printperson() = 0;
};
class student:public person
{
private:
	string name;
public:
	student(string s="zzh") :name(s) {}
	void printperson()
	{
		cout << "这是一个人" << endl;
		cout << "是学生,名字是:" << name << endl;
	}
};

int main() 
{
	student s;
	s.printperson();
	return 0;
}
//运行结果：
//这是一个人
//是学生, 名字是:zzh

¶（六）继承：

¶1. 概念：

继承关系又名泛化关系，是面向对象的三大特征之一，是对象之间耦合度最大的一种关系，表示一般与特殊的关系，是is-a关系。

继承表达的是一种上下级关系。

更多内容详见c++类——继承关系。

¶2. 体现：

通过面向对象的继承机制实现继承关系。

¶3. 代码：

#include<iostream>
using namespace std;
class person {};
class student :public person {};

¶（七）不同类之间关系的强弱比较：

继承=实现>组合>聚合>关联>依赖