一个棘手的 OOP 问题，我一直没有搞清楚

Question

假设我有两个 .cpp 文件：oranges.cpp 和 basket.cpp。它们分别具有类 orange 和 basket。我的main程序生成了许多篮子，这些篮子又生成了许多橙子。所以基本上，main 将有许多 Baskets 对象；和篮子将有许多Oranges对象。如果我有一个 orange 函数需要知道我的篮子的颜色，我将如何找到篮子的颜色？

orangle.cpp

class oranges
{
    void whichColorBasket()
    {
        // get the color of the basket the orange is in...?
    }
}

basket.cpp

class basket
{
    int color;

    void basket()
    {
        for(int i = 0; i < 10; i++)              
            oranges *o = new oranges;
    }
}

我知道我的语法可能并不完美，但是我如何从 中的函数访问 basket 的数据成员>orange（orange是由basket创建的对象）。

发送颜色参数不是一个选项，因为有太多橙色，并且篮子的颜色可能会在运行时发生变化。

我在某处读到静态函数可以解决这个问题，但它们只有在同一个 .cpp 文件中才有效。

那么，我该怎么办？

Answer 1

静态函数几乎肯定不是这里的答案。

您可能需要将对“父”Basket 的引用传递给 Oranges 对象，然后它可以询问该对象以查找颜色。

例如：

class Basket
{
public:
    void Basket() {
        Oranges *o = new Oranges(*this);
    }

    color getColor() const { ... }
};


class Oranges
{
private:
    const Basket &myBasket;

public:
    Oranges(const Basket &b) : myBasket(b) {} // Store reference

    color getColor() const { return myBasket.getColor(); }  // Interrogate my basket

};

您使用指针还是引用将取决于Oranges是否可以在Basket之间移动。

Answer 2

你需要一个橙色的引用，指向橙色所在的篮子，

class oranges{
    basket* b;
    int whichColorBasket() {
        return b->color;
    }
}


class basket{
     int color;

     void basket(){
         for(int i=0;i<10;i++){         
              oranges *o=new oranges;
              o->b = &this;
         }
     } 
}

我在这里忽略内存泄漏

Answer 3

您需要以某种方式将橙子绑定到它们所属的篮子 - 例如，通过将指针传递到篮子。如何做到这一点取决于橙子在其生命周期内是否可以改变其与背衬的结合，以及背衬是否可以在其中的所有橙子被破坏之前被破坏。

假设橙子永远不会比篮子寿命长并且永远不会更换篮子，你可以这样做：

class oranges{
public:
  oranges( backet* object ) { belongsTo = object; }
  void whichColorBasket() {
      here get belongsTo->color;
  }         
private:
  backet* belongsTo;
 };

 class basket{
     int color;
     void basket(){
         for(int i=0;i<10;i++)              
            oranges *o=new oranges( this ); //pass "current object"
     }
 };

Answer 4

您的 oranges 对象应该有一个实例变量 basket 代表它所在的篮子。添加一个方法 putInBasket ，该方法接受一个篮子并将变量设置为然后橙色查看 whichColorBasket 方法中的变量。如果basket为NULL，则它不在篮子中。

但这不是最好的设计，因为它可能会导致不一致。一个篮子可能认为它有一个橙子，但橙子的basket指针可能指向另一个篮子。 橙子真的应该知道它所在的篮子的颜色吗？有什么用例？如果您只处理篮子，并且有一个橙子，那么篮子可能应该有一个 isOrangeHere 方法，它可以告诉您给定的橙子是否存在。你在所有的篮子上调用它，然后选择返回 true 的颜色。

Answer 5

简单的答案是你不知道。如果你必须的话，有
你的设计中的某个问题：什么样的橙色会
知道它在哪个篮子里吗？如果橙子不在里面怎么办
一个篮子？

如果您需要以某种方式支持这一点，“正确的”解决方案
类似于观察者模式；你的
水果将成为其容器的观察者；当你把
水果放入容器中，容器将向
水果，当你把水果拿出来时，容器就会
注销。然后客户可以向水果询问他们当前的情况
容器，并询问他们想要的任何内容。

Answer 6

向 Oranges 添加一个属性，其中包含对父篮子的引用。在将橙子添加到篮子的方法中，也将父级设置为篮子。

class oranges{
    basket* basket;

    void oranged(basket* bask)
    {
       basket = bask;
    }
    int whichColorBasket() {
       return basket->color;
    }
}

class basket{
     int color;

     void basket(){
         for(int i=0;i<10;i++)              
              oranges *o=new oranges(&this);
     }         
}

这种语法可能是错误的，但这是通常的做法。

Answer 7

由于您使用的是 C++，因此请在橙色中使用指针。 int *basket_color; 然后将其分配给篮子颜色的地址 basket_color = &color

Answer 8

避免耦合的方法是询问每个篮子中是否包含特定的橙子。如果是，请检查其颜色。

为什么橙子要关心篮子的颜色？另一个篮子里的苹果呢？他们也有兴趣吗？

Answer 9

您的“oranges”类可以有一个“basket”成员变量，该变量引用包含它的篮子。然后，当一个 Oranges 对象想要知道其包含的篮子的颜色时，它只需调用 get myBasket.color 的值即可。

oranges 构造函数必须初始化此成员变量，因此它需要一个 basket 参数。

Answer 10

编辑：完全重新设计了这个解决方案，因为我错过了一个关键约束。

另一种可能的方法是向 orange 类添加一个成员变量，如下所示：

class oranges
{
    private:
    int m_nBasketID;

    public:
    oranges(int nID = 0)
    {
       m_nBasketID = nID;
    }

    void whichColorBasket() 
    {
        return gBasketList[m_nBasketID].color;
    }
}

并在 basket 中创建 oranges 时设置该值类，如下所示：

class basket
{
   static unsigned int nBasketID;
 public:
 int color;
 void basket()
 {
     //First basket will have ID = 1 because
     //0 is reserved for unknown/uninitialized state.
     nBasketID++;

     for(int i=0;i<10;i++)              
          oranges *o=new oranges(nBasketID);

     gBasketList.push_back(*this);
 }

其他修改如下：

unsigned int basket::nBasketID = 0;
std::vector<basket> gBasketList;

我在这里做了几个假设：

1. 有一个已知值（例如零）可用于表示未知/未初始化的颜色状态。该值可以在oranges 的构造函数中使用默认值。
2. 橙子在创建后不会切换篮子。如果需要解决此用例，那么您可以从原始篮子中删除orange，然后将一个新的orange添加到目标basekt或提供一个成员函数来处理这种情况等。