Printable View
Hello,
say I have a base class that has a virtual function called Fun(). What do I have to do in my base class to make sure that all the Fun() functions in the derived classes are automatically called? I tried playing around with the 'this' pointer, but it goes into infinite loop. Any suggestions?
Make it a virtual function. That's all there is to it.
Remember that the derived ones also need Fun functions and that you must call the function via a pointer or reference.
What do you mean by "all the Fun() functions in the derived classes are automatically called"? The Fun() override in the derived classes will be called if the object is actually of that derived class, and if the member function is invoked via a pointer or reference.
It is virtual.
So, you have a Derived2 which is based on Derived1 which is based on Base, and each has a "Fun" function in it? To call all levels of Fun, you'd have to implement the call back to the previous one inside the current one, e.g.
You don't have to repeat all levels in Derived2, since Base::Fun is automatically called in Derived2.Code:class Base
{
...
public:
...
virtual void Fun() { ... do stuff ... };
...
};
class Derived1
{
...
public:
...
virtual void Fun() { Base::Fun(); ... do stuff ... };
...
};
class Derived2
{
...
public:
...
virtual void Fun() { Derived1::Fun(); ... do stuff ... };
...
};
--
Mats
You also need to call the function via a pointer or reference to the base class.Quote:
Originally Posted by Arlenik
Okay, I hope that code shows what I want to do. Fun() is called somewhere in the Base class, and it also calls all the Fun() in the derived classes. Fun() doesn't get called in the Derived class.Code:class Base{
protected:
virtual void Fun();
/* Base::Fun() gets called somewhere. There is also code to make sure all the Fun() in derived classes are called too. */
};
class Derived : public Base{
protected:
void Fun();
};
int main(){
Derived A1; // Base::Fun() is called then Derived::Fun() is called.
return 0;
}
Did you look at what I posted?
--
Mats
Let's use a more concrete example:
Suppose that the functions are implemented as you want them to be. What is the expected output?Code:#include <iostream>
class Base{
public:
void Foo()
{
Fun();
// ...
}
protected:
virtual void Fun()
{
std::cout << "Base::Fun()" << std::endl;
// ...
}
};
class Derived : public Base
{
protected:
virtual void Fun()
{
std::cout << "Derived::Fun()" << std::endl;
// ...
}
};
class FurtherDerived : public Derived
{
protected:
virtual void Fun()
{
std::cout << "FurtherDerived::Fun()" << std::endl;
// ...
}
};
int main()
{
FurtherDerived x;
x.Foo();
}
Yes, I did, but I guess you didn't read my post. Base::Fun() or Derived::Fun() never get called in the Derived class. So, you're example is the opposite of what I want to do.Quote:
Originally Posted by matsp
That's sort of what I expect you'd say. But I must confess that now I do not know what you are asking for. Please post a piece of realistic code, and explain where you are calling some Fun() function, and what you want to have happen.
--
mats
To elaborate on what I am getting at:
If your expected output is:
then you do not need to do anything since the code is correct as-is.Code:FurtherDerived::Fun()
If your expected output is:
then you should apply matsp's solution. If you cannot apply matsp's solution, then you should relook your design, since it would then require the base class to know about all possible derived classes, thus violating the open-closed principle.Code:Base::Fun()
Derived::Fun()
FurtherDerived::Fun()
If your expected output is:
then you should pull out the Base::Fun() implementation to Base::Foo(), then call Fun() in Base::Foo().Code:Base::Fun()
FurtherDerived::Fun()
I'm going to ignore 'x.Foo();' cause there is no need for it. The expected output of your could would be:Quote:
Originally Posted by laserlight
The Base class is implemented in a way that the function Fun() in the future derived classes are automatically called without having to call them.Code:Base::Fun()
Derived::Fun()
FurtherDerived::Fun()
Then as I have noted, your requirements make this impossible, or rather possible but horribly broken. For example: how many derived classes, both direct and indirect, will Base ever have, and what are their names?Quote:
The Base class is implemented in a way that the function Fun() in the future derived classes are automatically called without having to call them.
Here is a real-world example of how this is done, and I need to understand how it's done. If you have used Qt before then this code should make sense.
If you are on linux with Qt you can compile it with this:Code:#include <QApplication>
#include <QPushButton>
#include <QPainter>
#include <QPaintEvent>
class mBut : public QPushButton{
public:
void paintEvent(QPaintEvent *event){
QPainter painter(this);
painter.drawEllipse(2,2,100,25);
};
};
int main(int argc, char *argv[]){
QApplication app(argc, argv);
mBut *p = new mBut();
p->show();
return app.exec();
}
mBut is my derived class. It inherits QPushButton and implements it's own version of paintEvent(). When my widget is shown, mBut:: paintEvent() is automatically called. mBut is derived from QPushButton, which is derived from QAbstractButton, which is derived from QWidget. paintEvent() is a protected virtual function in QWidget.Code:g++ -o main main.cpp `pkg-config --cflags --libs QtGui`
If you want the parent QPushButton object to paint itself, I would try calling QPushButton::paintEvent(event) first, then draw your ellipse.
gg
That's to be expected. The real question is: are both QPushButton::paintEvent() and QWidget::paintEvent() also automatically called? Suppose you derive from mBut. Are mBut::paintEvent(), QPushButton::paintEvent() and QWidget::paintEvent() all also automatically called for this new class?Quote:
When my widget is shown, mBut:: paintEvent() is automatically called.
I do not use Qt, but I note that as a last resort you could always read the Qt source and find out.Quote:
Here is a real-world example of how this is done, and I need to understand how it's done. If you have used Qt before then this code should make sense.
what are you talking about? we are trying to figure out how painEvent() in the derived class gets called automatically.Quote:
Originally Posted by Codeplug
That's what the virtual call mechanism is for. In fact, that's the entire point of the virtual call mechanism - to have the most derived version of a function called automatically.
No, we are not. We are trying to find out how paintEvent() in the base classes get called when the derived class' paintEvent() is invoked polymorphically, and yet the derived class' paintEvent() does not call the base classes' paintEvent()s by itself.Quote:
we are trying to figure out how painEvent() in the derived class gets called automatically.
I hear you, but to me it doesn't matter if paintEvent() in QPushButton and QWidget also get called. I just want to know how my painEvent() gets called. This to me is more of a C++ question than anything else.Quote:
Originally Posted by laserlight
It makes all the difference. Refer to my post #9 and #12 in this thread. If your answer was:Quote:
I hear you, but to me it doesn't matter if paintEvent() in QPushButton and QWidget also get called. I just want to know how my painEvent() gets called. This to me is more of a C++ question than anything else.
then everything is easy. It is as we have explained: when you invoke a virtual function from a base class pointer or reference, the actual function called belongs to the derived class, not the base class (unless there is no derived class override of that virtual function). This is normal polymorphic behaviour.Code:FurtherDerived::Fun()
If paintEvent() in the base classes are also called, then it implies that the most natural reason is that the derived class override of the virtual function calls them: but you confused us by claiming that it did not and yet your answer was:
Code:Base::Fun()
Derived::Fun()
FurtherDerived::Fun()
I guess you could say it like that too, but would you not agree that MY paintEven() in mBut gets called without me having to call it? All I've done is re reimplement the paintEvent() in my derived class.Quote:
Originally Posted by laserlight
You did not call it directly, but it was invoked (possibly multiple times) by other code somewhere between and including p->show() and app.exec(). They could do this without knowing that they were dealing with an mBut object because they only needed to know that they were dealing with a pointer to an object of some class derived from QWidget, which has paintEvent().Quote:
I guess you could say it like that too, but would you not agree that MY paintEven() in mBut gets called without me having to call it? All I've done is re reimplement the paintEvent() in my derived class.
One you thing you have to keep in mind is that when a class marks a function virtual, it's always virtual in all the derived classes as well. Even if you don't put "virtual" on your painEvent() method - it still is. The base Qt code is calling paintEvent() somewhere in its implementation - this calls your paintEvent() since it's the most derived implementation of the virtual method.
Assuming Qt simply calls paintEvent() through a base class pointer, yours is the first to be called. So in this case, you can explicitly call QPushButton::paintEvent() to have the button do its painting. None of the base virtuals are called for you.
(Found an example via Google - http://www.dpi.inpe.br/terralib/html...37.html#l00145)
gg
Ahhh, finally, I get it. Somewhere (my guess is show() ) in the base class there is a call to paintEvent() in the form of 'this->paintEvent()'.
To my original example, it would look something like this:
I guess many of you were saying just that, it's juts I was confused. I'm still learning.Code:include <iostream>
using namespace std;
class Base{
protected:
virtual void Fun(){ cout << " V Void Fun() in Base " << endl;};
public:
void Call(){this->Fun();};
};
class Derived : public Base{
protected:
void Fun(){ cout << " Fun() in Derived " << endl;};
};
int main(){
Derived A1;
A1.Call(); //Derived::Fun() is called.
return 0;
}
Thanks again for the quick replies.
Not quite. Qt calls into the native window system (X, Win32 or whatever MacOS X uses) to create a window. In this call it must supply one or more callback functions, which are called in response to various events. One of those is "needs to be redrawn" (WM_PAINT in Win32). When the callback recognizes this event, it then calls QWindow's paintEvent(), which is resolved to your own paintEvent().Quote:
Somewhere (my guess is show() )
Aren't you glad Qt hides this stuff from you?
By the way, I made an omission in my original example which you appear to have repeated: I forgot to declare the base class virtual. For more information why, read When should my destructor be virtual?