C++ 中的“扩展”结构

Question

I say "extend" because after a google search I'm not sure that is the proper name for what I'm trying to accomplish.

Basically what I'm trying to do is create a struct (just for fun, let's also include classes in this question) with some blank variables in it, then make another struct or class that carries on where the parent left off, filling in those variables.

So something like this:

struct parent{

    int foo;
    int bar;
};

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

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

    int foobar;
};

and later on, I might need to branch out this tree further:

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

What would be the correct way to go about this?

EDIT:

@Everyone: So, I can explain what I'm trying to do, and you can counter it with better ways, and who knows, maybe those ways are much better. However, first, right off the bat, I'm just curious if what I'm asking is possible...

And something I left out:

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

I think you may want to use constructors to initialize values like that. Something like this:

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

(btw I know the 'public' keyword isn't necessary, I included it only because I like to keep my intent explicit; otherwise I always wonder later if I just forgot to specify it)

Answer 2

Your parent and daughter are essentially the same type besides their initial class values. The same goes for grandson and son .

Why not use a constructor for that task?

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

• use a struct for inheritance: use a class instead. This undermines the protection level in the inheritance hierarchy because the default privacy level of members of a struct is . C programmers reading C++ code will assume the structs aren't inherited, have methods, ETC.
• Make all members private (if not modified by an inherited class) or protected (if modified by an inherited class) to prevent accidental modifications by the instantiators of the class.
• Make the constructors public in order for the classes to be instantiated, if the classes are supposed to be instantiable by any other code.

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

In C++, structs are treated as classes where all members are public by default.

So you can get the behaviour you are wanting.

However, you need to use a constructor to initialize the variables, you can't do it directly like you have written.

So this:

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

Needs to be written as

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

But in this case, a son and a parent are actually an instantiation of the same struct. Which is rather silly. Are you going to be adding more fields to son because that's what inheritance is about. In your case your father and son are identical but just hold different state. On the other hand if son needs to hold other data then it needs to inherit.

Also, if you're going to start treating structs as classes by adding methods then why not just make them classes.

Answer 5

I don't see a necessity for inheritance in this case. If you just want to get instances of parent with specific values, then a simple function may be all that you need:

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 introduces a new member so inheritance is appropriate.

Answer 6

I think languages like java and C# may have some wage definitions of local object initialization. But, according to me C++ has got the 'best' way of explain member variable (not static) initialization. Just do them inside of constructors. Very clear, intuitive and less error-prone.