一個棘手的問題OOP我從來沒有得到我的頭周圍

Question

說我有兩個的.cpp文件：oranges.cpp和basket.cpp。他們分別有orange和basket。我的main程序生成許多baskets，而這又產生了許多oranges。所以基本上，main會有很多對象Baskets;和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創建的對象）。

發送顏色參數不是一個選項，因爲太多的orange s和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 

}; 

無論您使用指針或引用，將取決於是否能OrangesBasket S之間不斷移動。

Answer 2

您需要以某種方式將桔子綁定到它們所屬的籃子上 - 例如，將指針傳遞給籃子。你怎麼做取決於橙子是否可以改變他們在一生中的束縛，以及是否可以在橙子被破壞之前銷燬橙子。

假設橘子從來沒有活得比籃下和永遠不變的籃子，你做這種方式：

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 3

你需要到籃下橙色是

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 4

你oranges對象應該有一個實例變量basket代表籃它的英寸添加一個方法putInBasket它需要一個籃子，並將變量設置爲它所在的籃子。然後橙色看着whichColorBasket方法中的變量。如果basket是NULL它不在籃子裏。

儘管如此，這不是最好的設計，因爲它提供了不一致的可能性。籃子可能會認爲它有橙色，但橘子的指針可能會指向另一個籃子。 orange真的應該知道籃子的顏色嗎？什麼是用例？如果你只是處理籃子，而你有一個橙子，也許籃子應該有一個isOrangeHere方法，它告訴你一個給定的桔子是否在那裏。你把它放在所有的籃子上，然後你拿出一個返回true的顏色。

Answer 5

由於您使用的是C++，因此在您的桔子中使用了一個指針。 int *basket_color;然後就分配給它的籃子的地址顏色basket_color = &color

Answer 6

一個屬性添加到包含父籃參考橘子。在將橙子加入籃子的方法中，也將父母設置爲籃子。

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

你的oranges類可能有一個basket成員變量引用包含它的籃子。然後，當oranges對象想要知道其包含的籃子的顏色時，它只會調用myBasket.color的值。

構造函數oranges將不得不初始化這個成員變量，所以它需要一個basket參數。

Answer 8

編輯：完全重複這個解決方案，因爲我錯過了一個關鍵的約束。

另一種可能的方法是將一個成員變量添加到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. oranges創建後不切換籃子。如果用例需要解決的問題，然後可能你可以刪除從原來的basket的orange，並添加一個新的目的地basekt或提供一個成員函數來處理這種情況等

Answer 9

避免方式該聯結是要詢問每個籃子是否包含特定的橙子。如果有，請檢查它的顏色。

橘子爲什麼要關心籃子的顏色？另一個籃子裏的蘋果呢？他們也有興趣嗎？

Answer 10

簡單的答案是，你沒有。如果你需要的話，在你的設計中有一個問題 ： 什麼樣的桔子會知道它在哪個籃子裏？如果桔子不在 籃子裏怎麼辦？

如果您需要以某種方式支持此功能，則「正確」解決方案 將沿着觀察者模式行;你的果實將成爲其容器的觀察者;當您將 水果放入一個容器中時，容器將註冊爲 水果，當您取出水果時，容器將取消註冊 。然後，客戶可以向他們的水果詢問他們當前的容器，然後問任何他們想要的東西。