前两课介绍了对象组合的两种类型:组合和聚合。 对象组合用于描述由一个或多个简单对象(部分)构成复杂对象的关系。
本课介绍一种较弱的关系:关联。它存在于两个本来互不相关的对象之间。 与对象组合不同,关联并不暗示整体与部分的关系。
关联
要称为关联,一个对象与另一个对象必须具有以下关系:
- 关联对象(成员)与对象(类)没有其他关系
- 关联对象(成员)可以同时属于多个对象(类)
- 关联对象(成员)的生命周期不由该对象(类)管理
- 关联对象(成员)可能知道,也可能不知道对象(类)的存在
组合或聚合中,部分属于整体对象;而在关联中,关联对象与该对象没有其他关系。 与聚合一样,关联对象可以同时属于多个对象,并且不由这些对象管理。 但与始终单向的聚合不同,关联可以是单向的,也可以是双向的(两个对象彼此知晓)。
医生与患者之间的关系是关联的典型例子。 医生显然与患者存在关系,但从概念上说,这不是整体/部分(对象组合)关系。 医生一天可以接诊许多患者,患者也可以看诊多位医生(例如希望听取第二意见,或需要就诊不同专科的医生)。 两个对象的生命周期都不依赖于另一个对象。
可以说,关联描述“使用”关系。 医生“使用”患者(以获得收入)。 患者“使用”医生(出于自身的健康需求)。
实现关联
关联是一种宽泛的关系类型,因此可以用许多不同方式实现。 不过,关联最常通过指针实现,即一个对象指向关联对象。
在这个示例中,我们实现双向的 Doctor/Patient 关系,因为让医生知道自己的患者、让患者知道自己的医生都很合理。
#include <functional> // reference_wrapper
#include <iostream>
#include <string>
#include <string_view>
#include <vector>
// 由于 Doctor 和 Patient 存在循环依赖,我们先前置声明 Patient
class Patient;
class Doctor
{
private:
std::string m_name{};
std::vector<std::reference_wrapper<const Patient>> m_patient{};
public:
Doctor(std::string_view name) :
m_name{ name }
{
}
void addPatient(Patient& patient);
// 我们会在 Patient 定义之后实现此函数,因为那时必须已经定义 Patient
friend std::ostream& operator<<(std::ostream& out, const Doctor& doctor);
const std::string& getName() const { return m_name; }
};
class Patient
{
private:
std::string m_name{};
std::vector<std::reference_wrapper<const Doctor>> m_doctor{}; // 这样就可以在这里使用它
// 我们将 addDoctor 设为 private,因为不希望公共代码使用它。
// 公共代码应改用公开的 Doctor::addPatient()
void addDoctor(const Doctor& doctor)
{
m_doctor.push_back(doctor);
}
public:
Patient(std::string_view name)
: m_name{ name }
{
}
// 我们将在下面实现此函数,使其与 operator<<(std::ostream&, const Doctor&) 对应
friend std::ostream& operator<<(std::ostream& out, const Patient& patient);
const std::string& getName() const { return m_name; }
// 将 Doctor::addPatient() 声明为友元,使其能够访问私有函数 Patient::addDoctor()
friend void Doctor::addPatient(Patient& patient);
};
void Doctor::addPatient(Patient& patient)
{
// 医生会添加这名患者
m_patient.push_back(patient);
// 患者也会添加这名医生
patient.addDoctor(*this);
}
std::ostream& operator<<(std::ostream& out, const Doctor& doctor)
{
if (doctor.m_patient.empty())
{
out << doctor.m_name << " has no patients right now";
return out;
}
out << doctor.m_name << " is seeing patients: ";
for (const auto& patient : doctor.m_patient)
out << patient.get().getName() << ' ';
return out;
}
std::ostream& operator<<(std::ostream& out, const Patient& patient)
{
if (patient.m_doctor.empty())
{
out << patient.getName() << " has no doctors right now";
return out;
}
out << patient.m_name << " is seeing doctors: ";
for (const auto& doctor : patient.m_doctor)
out << doctor.get().getName() << ' ';
return out;
}
int main()
{
// 在 Doctor 的作用域外创建 Patient
Patient dave{ "Dave" };
Patient frank{ "Frank" };
Patient betsy{ "Betsy" };
Doctor james{ "James" };
Doctor scott{ "Scott" };
james.addPatient(dave);
scott.addPatient(dave);
scott.addPatient(betsy);
std::cout << james << '\n';
std::cout << scott << '\n';
std::cout << dave << '\n';
std::cout << frank << '\n';
std::cout << betsy << '\n';
return 0;
}
输出结果:
James is seeing patients: Dave
Scott is seeing patients: Dave Betsy
Dave is seeing doctors: James Scott
Frank has no doctors right now
Betsy is seeing doctors: Scott
通常,如果单向关联已经足够,就应避免双向关联,因为双向关联会增加复杂度,也更容易写错。
自反关联
有时对象可能与同类型的其他对象建立关系,这称为自反关联。 自反关联的一个好例子是大学课程与先修课程之间的关系(先修课程同样是大学课程)。
考虑 Course 只能有一门先修课的简化情况,可以这样实现:
#include <string>
#include <string_view>
class Course
{
private:
std::string m_name{};
const Course* m_prerequisite{};
public:
Course(std::string_view name, const Course* prerequisite = nullptr):
m_name{ name }, m_prerequisite{ prerequisite }
{
}
};
这会形成关联链(课程有先修课,而先修课还有先修课,依此类推)。
关联可以是间接的
在前面的所有情况中,我们都使用指针或引用直接连接对象。不过,关联并不强制要求这样做。任何能够连接两个对象的数据都可以。 下面的示例展示了 Driver 类如何在不包含 Car 指针或引用成员的情况下,与 Car 建立单向关联:
#include <iostream>
#include <string>
#include <string_view>
class Car
{
private:
std::string m_name{};
int m_id{};
public:
Car(std::string_view name, int id)
: m_name{ name }, m_id{ id }
{
}
const std::string& getName() const { return m_name; }
int getId() const { return m_id; }
};
// CarLot 本质上只是一个静态 Cars 数组和一个用于查找车辆的函数。
// 因为它是静态的,所以无需创建 CarLot 对象即可使用它
namespace CarLot
{
Car carLot[4] { { "Prius", 4 }, { "Corolla", 17 }, { "Accord", 84 }, { "Matrix", 62 } };
Car* getCar(int id)
{
for (auto& car : carLot)
{
if (car.getId() == id)
{
return &car;
}
}
return nullptr;
}
};
class Driver
{
private:
std::string m_name{};
int m_carId{}; // 我们通过 ID 而不是指针与 Car 关联
public:
Driver(std::string_view name, int carId)
: m_name{ name }, m_carId{ carId }
{
}
const std::string& getName() const { return m_name; }
int getCarId() const { return m_carId; }
};
int main()
{
Driver d{ "Franz", 17 }; // Franz 正在驾驶 ID 为 17 的车辆
Car* car{ CarLot::getCar(d.getCarId()) }; // 从停车场获取这辆车
if (car)
std::cout << d.getName() << " is driving a " << car->getName() << '\n';
else
std::cout << d.getName() << " couldn't find his car\n";
return 0;
}
在上面的例子中,CarLot 保存着我们的汽车。需要汽车的 Driver 没有指向 Car 的指针,而是 而是保存汽车的 ID,需要时可以用它从 CarLot 获取 Car。
在这个例子中,这样做有些多余,因为从 CarLot 取出 Car 需要低效查找(连接二者的指针快得多)。不过,使用唯一 ID 而不是指针也有优势。例如,可以引用当前不在内存中的对象(它们可能在文件或数据库中,需要时再加载)。此外,指针可能占用 4 或 8 字节;如果空间非常有限且唯一对象数量较少,使用 8 位或 16 位整数引用对象可以节省大量内存。
组合、聚合与关联总结
下面的总结表可以帮助你记住组合、聚合和关联之间的区别:
| 属性 | 组合 | 聚合 | 关联 |
|---|---|---|---|
| 关系类型 | 整体/部分 | 整体/部分 | 其他关系 |
| 成员可以属于多个类 | 否 | 是 | 是 |
| 成员的存在由类管理 | 是 | 否 | 否 |
| 方向性 | 单向 | 单向 | 单向或双向 |
| 关系动词 | 部分属于 | 拥有 | 使用 |