C++ 对象之间的多对多关系

这是密码 In Movie.hpp

#ifndef MOVIE_H
#define  MOVIE_H

class Movie
{
  private:
    std::string title;
  public:
    std::string getTitle() const {return this->title;}  // const added 
    void setTitle(std::string newTitle){this->title = newTitle;}
};


#endif

在Actor.hpp中

#ifndef ACTOR_H
#define  ACTOR_H

#include "Person.hpp"
#include "Movie.hpp"

class Actor: public Person
{
  private:
    std::vector<Movie> movieList;
  public:
    void addMovie(Movie newMovie){this->movieList.push_back(newMovie);}
    void printMovies()
    {
      for(Movie movie: this->movieList)
      {
        std::cout << movie.getTitle() << '\n';
      }
    }
};

#endif

我被告知，我不会遵循多对多关系。换句话说，如果actor1和actor2与同一部电影有连接，它们应该共享同一个“电影”对象。 在我的例子中，它们有不同的电影对象。 正确的方法是在Actor内部存储指向电影的指针：

std::vector<Movie*> movieList;

并将这些对象的集合存储在电影和演员中，这里的值（不是指针）是可以的

std:：vector movieList//内部演员
std：：向量actorList//内部电影

---

我知道如何解决上述问题，但在使用指针时无法对上述代码进行更改。有人能帮我弄清楚当我使用指针时会有什么变化吗？

你可以使用向量和智能指针。我不知道你使用的是哪种版本的C++，但是你可以使用<代码> STD::SyrdYPPTR < /C>和<代码> STD:：SyrdyPtR。每个电影和演员都有自己的共享指针向量。

---

这样的智能指针可以从C++ 11中获得。因此，如果使用C++之前的C++版本，可以使用<代码> Boost 库，其中包括这些智能指针：<代码> Boo:：SyddypTr> /Cord>和 Booo:：SyrdYPPTR < /C> < /P> < P> >我建议您将有一个电影和演员的主列表，每个存储为./P>向量。 然后在

Actor

和

Movie

对象中，您还可以拥有彼此的

std:：shared_ptr

向量

因此，首先，主列表：

std::vector<std::shared_ptr<Movie>> master_movies;
std::vector<std::shared_ptr<Actor>> master_actors;

std:：vector master_电影；
std：：向量主控因子；

课程包括：

// Forward declaration
class Movie;

class Actor
{
    // ...

public:
    void addMovie(std::shared_ptr<Movie> movie)
    {
        movies.emplace_back(movie);
    }

private:
    // Movies that the actor has been in
    std::vector<std::shared_ptr<Movie>> movies;
};

class Movie
{
    // ...

public:
    void addActor(std::shared_ptr<Actor> actor)
    {
        actors.emplace_back(actor);
    }

private:
    // Actors in this movie
    std::vector<std::shared_ptr<Actor>> actors;
};

//转发声明
班级电影；
班级演员
{
// ...
公众：
void addMovie（标准：：共享电影）
{
电影。安置你回来（电影）；
}
私人：
//该演员曾出演过的电影
矢量电影；
};
班级电影
{
// ...
公众：
void addActor（std:：shared\u ptr actor）
{
演员。安置（演员）；
}
私人：
//这部电影中的演员
std：：向量因子；
};

始终在主列表中创建演员和电影，从电影主列表向演员添加电影，从演员主列表向电影添加演员：

auto fear = std::make_shared<Movie>();
fear->setTitle("Fear and loathing in Las Vegas");
master_movies.emplace_back(fear);

auto depp = std::make_shared<Actor>();
depp->setName("Johnny Depp");
master_actors.emplace_back(depp);

depp->addMovie(fear);
fear->addActor(depp);

auto fear=std:：make_shared（）；
恐惧->片名（“拉斯维加斯的恐惧与厌恶”）；
掌握电影。安置你回来（恐惧）；
auto depp=std:：make_shared（）；
depp->setName（“约翰尼·德普”）；
演员大师。后置（德普）；
depp->addMovie（恐惧）；
恐惧->添加者（depp）；

std:：vector

将创建

电影

对象副本的向量。向量中的每个元素都是其他

电影

对象的副本。不同的

电影

对象将真正不同，因此对一个对象的修改不会传播到其他副本。解决这个问题的简单方法是使用指针。就像你看起来在做的那样？因此，请你的问题详细说明你的问题。听起来你已经有了解决这个问题的计划。你在执行

角色

想法时是否面临任何具体问题？@NathanPierson是的，我得到了解决问题的指示，但我无法实施。你能帮我弄清楚如果我使用指针会有什么变化吗？@Someprogrammerdude我知道如何解决这个问题，但我在如何实现这个问题上遇到了问题。如果我改用指针，你能告诉我需要做哪些改变吗？java？java 11。。。我很困惑…对不起，java现在在我的屏幕上。当然，我是指C++版本。Boost是一个允许在早期版本的C++语言中使用的工具，这些工具在C++的后期版本中是可用的（比如C++ 11或C++ 20）。所以我的文章的总体思路是使用指针向量。第二件事：如果你想避免内存泄漏，你需要管理你分配的电影和演员对象。要么手动操作，要么使用智能指针。

std::vector<Role> movieList; //inside Actor

std::vector<Role> actorList; //inside Movie

std::vector<std::shared_ptr<Movie>> master_movies;
std::vector<std::shared_ptr<Actor>> master_actors;

// Forward declaration
class Movie;

class Actor
{
    // ...

public:
    void addMovie(std::shared_ptr<Movie> movie)
    {
        movies.emplace_back(movie);
    }

private:
    // Movies that the actor has been in
    std::vector<std::shared_ptr<Movie>> movies;
};

class Movie
{
    // ...

public:
    void addActor(std::shared_ptr<Actor> actor)
    {
        actors.emplace_back(actor);
    }

private:
    // Actors in this movie
    std::vector<std::shared_ptr<Actor>> actors;
};

auto fear = std::make_shared<Movie>();
fear->setTitle("Fear and loathing in Las Vegas");
master_movies.emplace_back(fear);

auto depp = std::make_shared<Actor>();
depp->setName("Johnny Depp");
master_actors.emplace_back(depp);

depp->addMovie(fear);
fear->addActor(depp);