学习 C++ / 第 23.4 课

关联

12 分钟阅读

前两课介绍了对象组合的两种类型:组合和聚合。 对象组合用于描述由一个或多个简单对象(部分)构成复杂对象的关系。

本课介绍一种较弱的关系:关联。它存在于两个本来互不相关的对象之间。 与对象组合不同,关联并不暗示整体与部分的关系。

关联

要称为关联,一个对象与另一个对象必须具有以下关系:

  • 关联对象(成员)与对象(类)没有其他关系
  • 关联对象(成员)可以同时属于多个对象(类)
  • 关联对象(成员)的生命周期不由该对象(类)管理
  • 关联对象(成员)可能知道,也可能不知道对象(类)的存在

组合或聚合中,部分属于整体对象;而在关联中,关联对象与该对象没有其他关系。 与聚合一样,关联对象可以同时属于多个对象,并且不由这些对象管理。 但与始终单向的聚合不同,关联可以是单向的,也可以是双向的(两个对象彼此知晓)。

医生与患者之间的关系是关联的典型例子。 医生显然与患者存在关系,但从概念上说,这不是整体/部分(对象组合)关系。 医生一天可以接诊许多患者,患者也可以看诊多位医生(例如希望听取第二意见,或需要就诊不同专科的医生)。 两个对象的生命周期都不依赖于另一个对象。

可以说,关联描述“使用”关系。 医生“使用”患者(以获得收入)。 患者“使用”医生(出于自身的健康需求)。

实现关联

关联是一种宽泛的关系类型,因此可以用许多不同方式实现。 不过,关联最常通过指针实现,即一个对象指向关联对象。

在这个示例中,我们实现双向的 Doctor/Patient 关系,因为让医生知道自己的患者、让患者知道自己的医生都很合理。

C++
#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 只能有一门先修课的简化情况,可以这样实现:

C++
#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 建立单向关联:

C++
#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 位整数引用对象可以节省大量内存。

组合、聚合与关联总结

下面的总结表可以帮助你记住组合、聚合和关联之间的区别:

属性组合聚合关联
关系类型整体/部分整体/部分其他关系
成员可以属于多个类否是是
成员的存在由类管理是否否
方向性单向单向单向或双向
关系动词部分属于拥有使用

最后更新