Question

I’ve trying to achieve something like this:

class Base {   public:    Base(string S)    {   ...   }; }  class Derived: Base { public:   int foo;   string bar()   {     return stringof(foo); // actually, something more complex   };    Derived(int f) : foo(f), Base(bar())    {   }; } 

Now, this doesn’t work as I want, because bar() is called in the Derived constructor before foo is initialized.

I considered adding a static function similar to bar() which takes foo as a parameter – and using that in the initialization list, but thought I’d ask if there were any other techniques that could be used to dig myself out of this one…

Edit: Thanks for feedback – here’s how I was going to handle the static function. Not sure if the overload between a static and non-static function is too clever, but…

class Derived: Base { public:   int foo;    static string bar(int f)   {     return stringof(f); // actually, something more complex   }    string bar()   {     return bar(foo);    };    Derived(int f) :  Base(bar(f)) , foo(f)   {   }; } 

Answer 1

Yes, using a function (static class method or regular function) that takes foo as a parameter and returns a string is a good solution. You can call this same function from Derived::bar to prevent code duplication. So, your constructor would look like this:

Derived(int f) : Base(stringof(f)), foo(f) {} 

I place the call to the Base constructor first in the list to emphasize the order in which the initializations occur. The ordering of the initializer list has no effect as all class members are initialized in the order that they are declared in the class body.

This is a very clean, functional approach to the problem. However, if you still would like to weigh alternatives then consider using composition instead of inheritance for the relationship between the Derived and Base classes:

class Base { public:     Base(string S) {  ...  }     void bat() { ... } };  class Derived {     Base *base;     int foo;  public:     Derived(int f) : base(NULL), foo(f) {         base = new Base(bar());     }     ~Derived() {         delete base;     }      string bar() {         return stringof(foo); // actually, something more complex     }      void bat() {         base->bat();     } }; 

You will need to consider the pros and cons for your specific situation. With Derived holding a reference to Base you gain greater control over the initialization order.