C++ 中的“擴展”結構

Question

我說“擴展”是因為在谷歌搜索之后我不確定這是我想要完成的事情的正確名稱。

基本上我想要做的是創建一個結構體（只是為了好玩，讓我們也包括這個問題中的類），其中包含一些空白變量，然后創建另一個結構體或類，在父級停止的地方繼續，填充那些變量。

所以像這樣：

struct parent{

    int foo;
    int bar;
};

struct daughter : parent{
    foo=1;
    bar=3;
};

struct son : parent {
    foo=10;
    bar=20;

    int foobar;
};

稍后，我可能需要進一步擴展這棵樹：

struct grandson : son {
    foo=50;
    bar=900;
    foobar=10000;
};

解決這個問題的正確方法是什么？

編輯：

@Everyone：所以，我可以解釋我想要做什么，你可以用更好的方法來反擊它，誰知道呢，也許這些方法要好得多。 然而，首先，馬上，我只是好奇我問的是不是可能......

我遺漏了一些東西：

struct parent{
    int foo;
    int bar;
    int foobar;

    int add(int x, int y){
        return x+y;
    };

struct son : parent {
    foo=12;
    bar=13;
    foobar=add(foo,bar);
}

Answer 1

我認為您可能想使用構造函數來初始化這樣的值。 像這樣的東西：

struct daughter : public parent {
   daughter() {
      foo=1;
      bar=3;
   }
};

（順便說一句，我知道“public”關鍵字不是必需的，我包含它只是因為我喜歡保持明確的意圖；否則我以后總是想知道我是否只是忘記指定它）

Answer 2

除了它們的初始類值之外，您的parent和daughter本質上是相同的類型。 grandson和son 。

為什么不為該任務使用構造函數？

struct parent
{
    parent () : foo(), bar() {}
    parent (int the_foo, int the_bar) 
      : foo(the_foo), bar(the_bar) {}
    int foo;
    int bar;
};

struct son : public parent
{
    son () : parent(10,20), foobar(foo+bar) {}
    son (int the_foobar) 
      : parent(10,20), foobar(the_foobar) {}
    int foobar;
}

int main ()
{
  parent p;
  parent daughter(1,3);
  son s;
  son grandson(10000);
}

Answer 3

• 不要使用struct進行繼承：改用class 。 這破壞了繼承層次結構中的保護級別，因為結構成員的默認隱私級別是public 。 閱讀 C++ 代碼的 C 程序員將假定結構不是繼承的，有方法等。
• 將所有成員設為私有（如果未被繼承類修改）或受保護（如果被繼承類修改）以防止類的實例化器意外修改。
• 如果類應該可以由任何其他代碼實例化，則將構造函數設為public以便實例化類。

class parent{

protected:
    int foo;
    int bar;
public:
    parent() {
        foo = 0;
        bar = 0;
    }
};

class daughter : parent{
private:
public:
    daughter() {
        foo=1;
        bar=3; 
    }
};

class son : parent {
private:
    int foobar;
public:
    son () {
        foo=10;
        bar=20;
        foobar = 0;
    }
};

Answer 4

在 C++ 中，結構被視為類，默認情況下所有成員都是公共的。

所以你可以得到你想要的行為。

但是，您需要使用構造函數來初始化變量，不能像您寫的那樣直接進行。

所以這：

struct parent{
int foo;
int bar;
int foobar;

int add(int x, int y){
    return x+y;
};

struct son : parent {
foo=12;
bar=13;
foobar=add(foo,bar);

需要寫成

struct parent
{
  int foo;
  int bar;
  int foobar;

  int add(int x, int y){
    return x+y;
  };
};

struct son : parent 
{
  son()
  {
    foo = 12;
    bar = 13;
    foobar = add(foo,bar);
    // or just: foobar = foo+bar;
  }
};

但在這種情況下，兒子和父母實際上是同一個結構的實例化。 這是相當愚蠢的。 您是否要為兒子添加更多字段，因為這就是繼承的含義。 在您的情況下，您的父親和兒子是相同的，但只是處於不同的狀態。 另一方面，如果兒子需要持有其他數據，那么它需要繼承。

此外，如果您打算通過添加方法開始將結構視為類，那么為什么不直接將它們設為類。

Answer 5

在這種情況下，我沒有看到繼承的必要性。 如果您只想獲取具有特定值的parent實例，那么您可能只需要一個簡單的函數：

parent get_daughter() {
    // note that this syntax requires c++11
    // in earlier standards you may want to add a constructor to the class
    return {1, 3};
};

son引入了一個新成員，因此繼承是合適的。

Answer 6

我認為像 java 和 C# 這樣的語言可能對本地對象初始化有一些工資定義。 但是，據我所知，C++ 已經獲得了解釋成員變量（非靜態）初始化的“最佳”方式。 只需在構造函數中執行它們。 非常清晰、直觀且不易出錯。