擴展一個基類，並維護引用

Question

我想找出一種方法來獲取我的基類的副本，並創建一個引用與基類相同的地址空間的我的子類的實例。

因此，例如，我在基類Foo中有許多成員，並且在子類Bar中有幾個額外的成員。如何從我的Foo創建一個欄，以便更改xBar也更改xFoo。

前）

struct Foo{ 
    int x; 
    Foo(){ 
     x = 0; 
    } 
} 

struct Bar : Foo{ 
    int z; 
    //?? what to do here 
} 

int main(){ 
    Foo foo(); 
    Bar bar(foo); //?? 
    bar.x = 7; 
    assert(bar.x == foo.x); 
} 

我知道這是一個奇怪的問題，我還沒有措辭非常好。如果有人知道一個答案，或者如果我很荒謬，並且在stackoverflow上有一個答案，我無法找到這個答案，我會非常感激。感謝您的時間。

Answer 1

取決於你如何想/能接近這個，你有兩個選擇：

1）的間接

struct Bar 
{ 
private: 
    Bar() = delete; //eradicate the default constructor 
public: 
    //Foo member references 
    int &x; 

    //Bar members 
    int z; 

    Bar(Foo& f): x(f.x) { } //of course, you may initialize z as well 
}; 

用法：

Foo foo_obj; 

//new scope begins (can be a function call, for example) 
{ 
    Bar bar_obj(foo_obj); 

    //do stuff with bar_obj 
    //... 
    //work done 

} //scope ends; bar_obj is destroyed 

//magic! foo_obj has been updated with the correct values all this time 

2）多態性

struct Bar: public Foo 
{   
    //Bar members 
    int z; 

    Bar(): Foo() { } 
}; 

用法：

Foo foo_obj; 

//new scope begins (can be a function call, for example) 
{ 
    Bar bar_obj; 
    static_cast<Foo&>(bar_obj) = foo_obj; //we'll use Foo's default (or user-defined) assignment operator 
    //note that you need to cast to reference 

    //do stuff with bar_obj 
    //... 
    //work done 

    foo_obj = bar_obj; //you will need to copy your data back at this point 
    //also note foo_obj has not been updated during this time, which may not be desirable 
} //scope ends 

Answer 2

您當前的代碼，使您的Foo的新副本，當你初始化酒吧，這意味着它有它自己的一套存儲內它的結構不同的價值觀。爲了讓Foo和Bar共享一個值，您需要將其更改爲指針或引用。你還需要爲Bar指定一個構造函數，它將Foo作爲參數。

這裏有一種方法可以做到這一點，顯然不是理想的，因爲X的價值是作爲一個全球性存儲的，最終你需要某個地方來存儲它，並確切地取決於你的需求。

int x_storage; 

struct Foo{ 
    int& x; 
    Foo(): x(x_storage){ 
     x = 0; 
    } 
}; 

struct Bar : Foo{ 
    int z; 
    Bar(Foo& f) 
    { 
     x = f.x; 
    } 
}; 

int main(){ 
    Foo f = Foo(); 
    Bar b = Bar(f); //?? 
    b.x = 7; 
    assert(b.x == f.x); 
}; 

編輯：看你的意見，也許inheretence是不是你所追求的一切，你可能只是想用一個「有」關係來包裝一個富一個酒吧裏面，像這樣：

struct Foo{ 
    int x; 
    Foo(){ 
     x = 0; 
    } 
}; 

struct Bar{ 
    Foo& myFoo; 
    int z; 
    Bar(Foo& f): myFoo(f){ 
    } 
}; 

int main(){ 
    Foo f = Foo(); 
    Bar b = Bar(f); //?? 
    b.myFoo.x = 7; 
    assert(b.myFoo.x == f.x); 
}; 

Answer 3

右，所以我goiing假設你還必須創建objeccts的能力：

class Foo // Base class. 
{ 
    public: 
    int x; 
}; 


class Bar 
{ 
    public: 
    int z; 
} 

一些功能：

void frobb(Foo *fooPtr) 
{ 
    if(fooPtr->x != 7) 
    { 
     cout << "Bad value of x\n"; 
    } 
    ... 
} 

.... 

// some of your code (in a different file probably. 

Bar b; 
... do stuff with b. 
b.x = 7; 
frobb(&b); 

除非在API中確實有某些東西被破壞，否則你不應該需要從Foo或Bar中的Foo中創建一個Bar。這只是糟糕的設計。

編輯：

在註釋中所描述的情況：

一些代碼創建一個酒吧對象：

Bar b; 

extern void some_generic_api(Foo *fptr); 

... do stuff with b, including setting your own variables. 

b.x = 7; 
some_generic_api(&b); // WOrks like a "Foo" object without problem. 

... some other bit of code ... 

void frobb(Foo *fptr) 
{ 
    // Note: Don't do this unless you are SURE it's a Bar object you actually have! 
    Bar *bptr = reinterpret_cast<Bar*>(fptr); 

    .. do stuff that requires Bar object using bptr; 
    bptr->x = 19; 

    some_generic_api(bptr); // This will work fine. 
} 

Answer 4

只是另一種選擇，沒有人還沒有提到，但如果你想只有在內存中爲Foo的所有對象分配一個變量作爲基類，則可以使用靜態成員變量。

struct Foo{ 
    static int x; 
    Foo() { 
     x = 0; 
    } 
}; 

int Foo::x = 0; 

struct Bar : Foo { 
    int z; 
}; 

int main(){ 
    Foo foo(); 
    Bar bar(); 
    bar.x = 7; 
    assert(&bar.x == &foo.x); // now using the same memory address 
} 

而且，作爲一個說明，static關鍵字在C++語言很多含義，所以我會建議找他們了休息，如果你不熟悉（這裏是msdn page on the C++ static keyword一個MSDN頁面作爲首發），我不能說我用很多頻率（特別是函數範圍的靜態變量）來使用靜態關鍵字的所有含義，但是它們是工具箱中的便利工具，但是如果出現正確的情況。