Re: pass address of data member to base class ctor?

* Alexey Stepanyan <alexeystepanyan@yahoo.com>
| 1) Perhaps you meant
| class foo : public bar {

Yes.

| 2)I think that passing &x_ to bar contructor is dangerous because x_
| is not yet constructed when the constructor for bar is called. So if
| some member function of base is called from inside bar constructor
| we will get undefined behaviour.

The pointer will not get used in the CTOR, just stored for later
usage. Daniel's message in this thread seems to indicate that it is
possible to take the address of a member object once the foo CTOR has
started.

| 3) x_ should be made protected in bar and then explicitly assigned a
| proper value
| in the foo's constructor.

As I have it now, it is private in bar and set via an protected
accessor in foo's CTOR. I just have to remember to call the accessor
in every foo_base-derived class.

| As I understand you want to use Strategy pattern ( base, derived ) -
| the bar class will perform the main logic and the derived classes
| (foo) provide the proper strategy.

I will have to dig out my GOF-book and look that up again, but it
sounds like it.

Note that 4 classes are involved here:

   // regular base/derived with a virtual func
   class bar_base {
   public:
     virtual void method() = 0;
   };
   class bar {
   public:
     void method() {}
   };

   // foo has a bar member, and every foo will call bar.method() in
   // do_call(). Avoid virtual here by storing a bar_base* in the
   // foo_base, and call method() via the pointer:
   class foo_base {
   public:
     foo_base(bar_base *p) : pbar_(p) {}
     void do_call() { pbar_->method();}
   private:
     bar_base *pbar_;
   };
   class foo : public foo_base {
   public:
      foo() : foo_base(&b_) {}
   private:
      bar b_;
   };

The 'usual' way would be:

   class foo_base() {
   public:
     virtual void do_call() = 0;
   };
   class foo : public foo_base {
   public:
     void do_call() { b_.method(); }
   private:
      bar b_;
   };

So I would have to duplicate that
    void do_call() { b_.method(); }
in every foo_base-derived class.

As I think of it, even with the duplicated code, this is probably the
better way (since this is what virtuals are made for, no?)...

R'

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]