用C ++“扩展”Struct

时间:2014-07-01 23:49:50

标签: c++ inheritance struct extend

我说"延伸"因为谷歌搜索后我不确定这是我想要完成的正确名称。

基本上我要做的就是创建一个结构(只是为了好玩,让我们也包含这个问题中的类),其中包含一些空白变量,然后创建另一个继承的结构或类父母离开的地方,填写这些变量。

这样的事情:

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);

6 个答案:

答案 0 :(得分:6)

我认为您可能希望使用构造函数来初始化这样的值。像这样:

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

(顺便说一下,我知道'public'关键字不是必需的,我之所以包含它只是因为我喜欢保持我的意图明确;否则我总是想知道我以后是否忘了指定它)

答案 1 :(得分:2)

除了初始的类值之外,您的parentdaughter基本上是相同的类型。 grandsonson也是如此。

为什么不为该任务使用构造函数?

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);
}

答案 2 :(得分:0)

  • 不要使用struct进行继承:请改用class。这会破坏继承层次结构中的保护级别,因为结构成员的默认隐私级别为 public 。读C ++代码的C程序员将假设结构不是继承的,有方法,ETC。
  • 使所有成员成为私有(如果未被继承的类修改)或受保护(如果由继承的类修改),以防止类的实例化器进行意外修改。
  • 创建构造函数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;
    }
};

答案 3 :(得分:0)

在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;
  }
};

但在这种情况下,子和父实际上是同一结构的实例化。这是相当愚蠢的。您是否会向儿子添加更多字段,因为这是继承的内容。在你的情况下,你的父亲和儿子是相同的,但只是保持不同的状态。另一方面,如果儿子需要保留其他数据,那么它需要继承。

此外,如果您要通过添加方法开始将结构体作为类处理,那么为什么不只是让它们成为类。

答案 4 :(得分:0)

在这种情况下,我没有看到继承的必要性。如果您只想获取具有特定值的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引入了一个新成员,因此继承是合适的。

答案 5 :(得分:0)

我认为像java和C#这样的语言可能有一些本地对象初始化的工资定义。但是,根据我的说法,C ++已经获得了解释成员变量(非静态)初始化的“最佳”方式。只需在构造函数中执行它们。非常清晰,直观且不易出错。