【c++】对象与对象之间的关系

依赖（使用一个，不具有整体与部分的关系）

依赖关系：
如学生，电脑，书。学生学习依赖与电脑和书 （耦合度最低，学生学习可以靠电脑，也可以靠书，也可以靠其它的）

class Student
{
public:
	void Study(Book book){}
	void Study(DeskTopComputer deskTopComputer){}
	void Study(NoteBookComputer noteBookComputer){}
};
class Book
{
};
class DeskTopComputer
{
};
class NoteBookComputer
{
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

关联（使用一个，不具有整体与部分的关系）

关联关系：老师与课程的关系 （老师固定教某个课程）

class Course
{
};
class ChineseCourse : public Course
{
};
class EnglishCourse : public Course
{
};
class MathCourse : public Course
{
};
class Teacher
{
private:
	Course* course_;
	Course& course_;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

关联关系一般用指针和引用

因为课程的生存期不应该与老师有关，就比如这个老师去世了，难道这个课程就在这个世界上消亡了吗

而指针和引用的区别
指针的关联就比较弱.
就比如说，今天这个老师可以带这门课，明天可以带其它的课，当把这个指针置为空时，还可以表示这个老师不带课了
而对于引用，这个老师带这个课之后就不能换

使用引用时要注意的问题

class Teacher
{
public:
	Teacher(Course course):course_(course){}
private:
	Course& course_;
};
1
2
3
4
5
6
7

这样可以实现功能吗？

不能，因为它引用的是这个构造函数中的临时对象，当构造函数执行完之后，它的生存期就结束了，所有它引用的是一个已死亡的对象

我们应该使用引用

class Teacher
{
public:
	Teacher(Course &course):course_(course){}
private:
	Course& course_;
};
int main()
{
	MathCourse mc;
	Teacher t(mc);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

我们可以引用一个外部的对象，但是我们一定要保证外部对象的生产期要比老师长

聚合（有一个，有整体与部分之间的关系）

与组合关系不同，整体和部分不是强依赖。即使整体不在了，部分仍然存在。
如部门与员工，部门不在了，但是员工还在

使用指针类型设计，不使用引用，因为引用一旦与对象关联，就不能更改了，但是对于部门来说，他也可以把你开了然后雇佣其它人。

```cpp
class Department
{
private:
	Employee* employee_;

};
class  Employee
{
};
1
2
3
4
5
6
7
8
9
10
11

组合（有一个，有整体与部分之间的关系）

组合关系：是强依赖。 如人是由身体和灵魂组成的，部分与整体之间有生存期的关系，比如，人死了，那么他的身体和灵魂就消亡了。

class Body
{
};
class Soul
{
};
class Person
{
private:
	Body body_;
	Soul soul_;

};
1
2
3
4
5
6
7
8
9
10
11
12
13

继承（是一个）

泛化关系： 像继承关系 如学生与人的关系 耦合度更高，主要表达的是 ”是一个的含义“，如下面，学生是一个人

class Person
{
};
class Student :public Person
{
};
1
2
3
4
5
6

模板

为了重用代码，代码就必须是通用的，通用的代码就必须不受返回类型的限制，那么我们就可以把数据类型改为一个设计参数，这种类型的程序设计称为参数化程序设计。

template<class T>
//或者template
template<t>
class Test
{
};
1
2
3
4
5
6