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++ 已经获得了解释成员变量（非静态）初始化的“最佳”方式。 只需在构造函数中执行它们。 非常清晰、直观且不易出错。