How can i force my derivers to call a base function

[ManicQin]

Hi lets say I have the next situation
class base
{
pubic: ;)
base() {}
virtual ~base(){}
virtual init()
{//do init }
};

now i want that every deriver will call MY init function before he
init his class...
for some reasons I cannot put those calls in the cTor...

one thing that I thought of is
class base
{
public:
init()
{
//do base's init
secondPhaseInit();
}
protected:
virtual secondPahseInit() = 0;
}

and then the deriver can only override secondPhaseInit and he needs to
go through my init .
But it's still not an idiot proof method... is there a way?

[Rahul]

On Dec 19, 12:41 pm, ManicQin <[e-mail]:

Hi lets say I have the next situation
class base
{
pubic: ;)
base() {}
virtual ~base(){}
virtual init()
{//do init }

};

now i want that every deriver will call MY init function before he
init his class...
for some reasons I cannot put those calls in the cTor...

Could you specify the details of the reason?
Derived class constructor can invoke any of the visible base class
member functions, which is one of the reason for the base class
constructor to be invoked before that of derived class constructor...

[ManicQin]

On Dec 19, 10:12 am, Rahul <[e-mail]:

Could you specify the details of the reason?
Derived class constructor can invoke any of the visible base class
member functions, which is one of the reason for the base class
constructor to be invoked before that of derived class constructor...

Thank you rahul on that great introduction to c++ inheritence.
And thank you Alf.

I probably misled you both because i called my function init.
The question is not about cTor or initialization in particularly.

take the next snip

class base
{
public:

foo()
{ /do something - any thing!
goo();
}
protected:
virtual goo() = 0;
}

class derive : public base
{
protected:
goo()
{
//do something else...
}

}

int main()
{
derive a;

a.foo(); //first base.foo() will execute and then derive.goo()
return 0;
}

the problem is that this pattern (I think they call it Template
Method) is not IDIOT PROOF.
tomorrow a coder would come and change my code so he would'nt call my
base function. (infact it happened today in spite of all the comments
i left!) I'm just looking for a different way to implement this.

thank you

[James Kanze]

On Dec 19, 10:28 am, ManicQin <[e-mail]:

On Dec 19, 10:12 am, Rahul <[e-mail]:

I probably misled you both because i called my function init.
The question is not about cTor or initialization in
particularly.

class base
{
public:
foo()
{ /do something - any thing!
goo();
}
protected:

Why protected, and not private?

virtual goo() = 0;
}

class derive : public base
{
protected:
goo()
{
//do something else...
}
}

int main()
{
derive a;

a.foo(); //first base.foo() will execute and then derive.goo()
return 0;
}

the problem is that this pattern (I think they call it Template
Method) is not IDIOT PROOF.
tomorrow a coder would come and change my code so he would'nt
call my base function. (infact it happened today in spite of
all the comments i left!) I'm just looking for a different way
to implement this.

I'm not sure I understand. Which code are you talking about?
If client code doesn't call some particular function, there's
not much you can do about it. For that matter, he may not even
create an instance of your class. And the author of the derived
class shouldn't call your base class function; that would result
in endless recursion. Could you please give an exact example of
the type of error you're trying to avoid.

--
James Kanze (GABI Software) email:ja*********@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[Stuart Redmann]

ManicQin wrote:

class base
{
public:

foo()
{ /do something - any thing!
goo();
}
protected:
virtual goo() = 0;
}

class derive : public base
{
protected:
goo()
{
//do something else...
}

}

int main()
{
derive a;

a.foo(); //first base.foo() will execute and then derive.goo()
return 0;
}

the problem is that this pattern (I think they call it Template
Method) is not IDIOT PROOF.
tomorrow a coder would come and change my code so he would'nt call my
base function. (infact it happened today in spite of all the comments
i left!) I'm just looking for a different way to implement this.

This is still too little information for us, we cannot assess whether the
overall design is flawed. Why is it necessary that the user calls your base
class method? Maybe your class derive should not even be derived from base if
you have such strange dependencies in your code.

Regards,
Stuart

[ManicQin]

James Kanze:

Why protected, and not private?

That was a typo, sorry.
Stuart Redmann :

This is still too little information for us, we cannot assess whether the
overall design is flawed. Why is it necessary that the user calls your base
class method? Maybe your class derive should not even be derived from base if
you have such strange dependencies in your code.

My question was'nt about the design.
I think that if after 4 threads I didnt manage to explain my question,
then maybe it is better to just leave it be.

thank you for your help.

[Pete Becker]

On 2007-12-19 07:25:01 -0500, ManicQin <Ma******@gmail.comsaid:

>
My question was'nt about the design.

The question wasn't, but the answer may well be. Awkward coding
problems often can be resolved by changing the design. Especially when
the immediate answer to the awkward coding problem is, as here, "you
can't do that."

--
Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com) Author of "The
Standard C++ Library Extensions: a Tutorial and Reference
(www.petebecker.com/tr1book)

[red floyd]

ManicQin wrote:

Hi lets say I have the next situation
class base
{
pubic:

Yeah, I know it's a typo, but you have to admit, this is a *GREAT* way
to define your private parts :)

base() {}
virtual ~base(){}
virtual init()
{//do init }
};

[Andre Kostur]

ManicQin <Ma******@gmail.comwrote in news:d4346905-60c3-4237-bb06-
3a**********@c4g2000hsg.googlegroups.com:

On Dec 19, 10:12 am, Rahul <[e-mail]:

> Could you specify the details of the reason?
Derived class constructor can invoke any of the visible base class
member functions, which is one of the reason for the base class
constructor to be invoked before that of derived class constructor...

Thank you rahul on that great introduction to c++ inheritence.
And thank you Alf.

I probably misled you both because i called my function init.
The question is not about cTor or initialization in particularly.

take the next snip

class base
{
public:

foo()
{ /do something - any thing!
goo();
}
protected:
virtual goo() = 0;
}

class derive : public base
{
protected:
goo()
{
//do something else...
}

}

int main()
{
derive a;

a.foo(); //first base.foo() will execute and then derive.goo()
return 0;
}

the problem is that this pattern (I think they call it Template
Method) is not IDIOT PROOF.
tomorrow a coder would come and change my code so he would'nt call my
base function. (infact it happened today in spite of all the comments
i left!) I'm just looking for a different way to implement this.

You cannot prevent malice. Severly discipline the other developer for
breaking the design without consulting the appropriate stakeholders.