Успокойтесь, если у 2 классов есть поле, указывающее друг другу?

Question

Поэтому у меня есть классы User и Job:

class User { 
string user_name; 
Job* job; 
}; 

class Job { 
string job_type; 
int salary; 
User* user; 
}; 

Существуют ли какие-либо проблемы с этим видом дизайна? У меня большое количество Job s и User s, и я хочу получить быстрый доступ к заданию пользователя или к пользователю, у которого есть работа. Это нормально, что у этих классов есть поля, которые друг к другу подходят друг другу?

Answer 1

Все в порядке. Вы должны быть осторожны, чтобы управлять указателями осторожно, чтобы избежать утечек, например. Но это вполне разумно.

Answer 2

Обычная ситуация в мире oop. Например, типичная архитектура графического интерфейса использует такой подход аналогичным образом:

1. Виджет знает о своем родителе. Он сохраняет указатель на родительский.

2. Соединение виджет знает о его г заказанных детей (виджет)

Я понимаю, что такой пример далеко от вашего поста. Он просто показывает случай.

Я не знаю точной архитектуры вашего приложения. Но, может быть, класс Job не должен знать о пользователе? Это снижает дополнительные отношения и упрощает управление памяти (вместо использования для лучшего управления совместно и слабых указатели)

Answer 3

Пока User не владеет Job и Job не владеют User, то это прекрасно.

Например, возможно, вы создаете коллекции Job с и User сек авансовые и затем хотите создать ассоциации между ними:

#include <string> 
#include <vector> 

class Job; 

class User { 
    std::string user_name; 
    Job* job; 
    public: 
    explicit User(const std::string& user_name) : user_name(user_name) {} 
    void setJob(Job& job) { this->job = &job; } 
}; 

class Job { 
    std::string job_type; 
    int salary; 
    User* user; 
    public: 
    Job(const std::string& job_type, int salary) : job_type(job_type), salary(salary) {} 
    void setUser(User& user) { this->user = &user; } 
}; 

void recruit(User& user, Job& job) { 
    user.setJob(job); 
    job.setUser(user); 
} 

int main() { 
    auto jobs = std::vector<Job>{ {"Tinker", 10'000}, {"Tailor", 20'000}}; 
    auto users = std::vector<User> {User{"George"}, User{"Percy"}}; 
    recruit(users[0], jobs[1]); 
    recruit(users[1], jobs[0]); 
} 

Пока коллекции User с и Job с разрушаются при в то же время нет опасности оборванных указателей. Может быть предпочтительнее, если указатели были указателями const.

Но если ваше намерение - это своего рода собственность, то предпочтительным будет умный указатель.

Answer 4

Я немного удивлен, что в большинстве ответов утверждается, что этот дизайн в порядке.

Я считаю это неприемлемым, если нет очень веских причин (например, требований к производительности), чтобы сделать это таким образом.

Это круговая зависимость, которая ухудшает читаемость и проверяемость кода. Но моя главная проблема заключается в том, что будет очень сложно поддерживать соответствие этих ссылок.

В качестве альтернативы, я бы предоставил только одну ссылку, скажем, у пользователя есть указатель на Job. Теперь, если у вас есть задание и вы хотите найти соответствующих Пользователей, вы все равно можете выполнить поиск по всем пользователям и найти те, у которых есть указатель на это задание. Конечно, это менее эффективно, чем прямой указатель, но во многих случаях это не имеет значения. Что может быть более важным, так это то, что несоответствия не могут возникнуть.