具有“包含"关系的循环依存关系.和“在...中" [英] Circular dependency with the relationships "contains" and "is in"
问题描述
我想就以下问题征求您的意见.
I would like to gather opinion from you about the following problem.
我们有一个名为房间"的课程.每个房间可能包含零个或多个"Person"类的实例,因此该Room存储了Person(例如vector)的集合.它拥有.但是,有一些与在各个房间之间移动人物相关的耗时逻辑,因此该人物还包含了他们所在的当前房间.它只是一个没有所有权的指针.此信息在理论上是多余的,因为可以从房间中的人"集合中获取信息,但是如果假设房间数量>>人数众多,则此操作将很慢...
We have a class called "Room". Each room may contain zero or more instances of a class "Person", so the Room stores a collection of Persons (e.g. vector). It owns them. However, there is some time-consuming logic related to moving Persons between Rooms, so the Person also contains current Room they are in. It is just a pointer without ownership. This information is theoretically redundant, because one could derive it from the collections of Persons in rooms, but assuming large number of rooms >> number of people, such an operation would be slow...
class Room {
std::vector<Person> peopleInside;
};
class Person {
Room* currentRoom; //could be shared_ptr to avoid raw pointers
};
自然地,它更复杂(类不止于此),但我已尽可能地简化了它.
Naturally, it is more complex (classes have more than this) but I have simplified it as much as possible.
我的问题是:
1)在这种情况下,这本身就是循环依赖吗?
1) In this situation, is this a circular dependency per se?
2)这个解决方案对您来说是肮脏的吗?
2) Is this solution dirty/inelegant for you?
3)是否值得更改为其他内容?
3) Is it worth changing to something else?
推荐答案
这个问题确实需要根据上下文进行研究.如果Person
仅存在于Room
的上下文中,则后向指针是安全的.当Room
被销毁时,Person
也会被销毁(轰!),所以什么都不会出错.
This question needs really to be studied in context. If Person
s only exist in the context of a Room
then the back-pointer is safe. When a Room
is destroyed then the Person
s are destroyed too (boom!) so nothing can go wrong.
但是我怀疑这太简单了. Room
的声明更有可能是这样的:
But I suspect that's too simplistic. The declaration of Room
is more likely to be something like:
class Room {
std::vector<std::shared_ptr<Person>> peopleInside;
};
现在我们有一个可能的悬空指针"问题,您不能使用Person
中的std::shared_pointer<Room>
来解决,因为这时您 do 具有循环依赖项,而shared_ptr
都没有将会能够删除它正在管理的对象(因为Room
拥有对Person
的引用,反之亦然,因此是死锁).
And now we have a possible 'dangling pointer' problem, which you can't solve with a std::shared_pointer<Room>
in Person
because then you do have a circular dependency and neither shared_ptr
will ever be able to delete the object it is managing (because Room
holds a reference to Person
and vice versa, so, deadlock).
因此,改为这样声明Person
:
class Person {
std::weak_ptr<Room> currentRoom;
};
然后从Room
存在时保持可用的某些shared_ptr<Room>
中初始化currentRoom
.这打破了循环依赖.
And initialise currentRoom
from some shared_ptr<Room>
that you keep available while that Room
exist. This breaks the circular dependency.
要取消引用currentRoom
,您可以执行以下操作:
To dereference currentRoom
, you can then do:
if (auto room_I_am_currently_in = currentRoom.lock())
{
room_I_am_currently_in->OpenDoor ();
}
如果原始的shared_ptr<Room>
已被销毁,则lock
将失败.当room_I_am_currently_in
超出范围(实际上是shared_ptr<Room>
)时,该锁将被释放.
And if the original shared_ptr<Room>
has been destroed then lock
will fail. The lock will be released when room_I_am_currently_in
goes out of scope (it's actually a shared_ptr<Room>
).
要将人转移到另一个房间,只需重新分配currentRoom
.
And to move a person to another room, just reassign currentRoom
.
有关std::weak_ptr
的更多信息,请访问 cppreference .
More about std::weak_ptr
at cppreference.
这篇关于具有“包含"关系的循环依存关系.和“在...中"的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持IT屋!