S
slocum
Is it possible to create static virtual method in a class ???
J
Jim Langston
slocum said:
No.
A
AnonMail2005
No, but what are you trying to do? I'm sure folks can suggest
ways to accomplish it.
C
Christian Hackl
slocum said:
How could that possibly make sense? Consider this:
class Base
{
public:
virtual void func() = 0;
};
class Derived1 : public Base
{
public:
virtual void func() {}
};
class Derived2 : public Base
{
public:
virtual void func() {}
};
At runtime, which version of func() is called depends on which *object*
is hidden behind a pointer or reference to the base class:
Base *ptr1 = new Derived1;
Base *ptr2 = new Derived2;
ptr1->func(); // Derived1::func() called because ptr1 points to a
// Derived1 object
ptr2->func(); // Derived2::func() called because ptr1 points to a
// Derived2 object
A static method, however, is not called on a particular object. It does
not even need an object of the class to be instantiated. You would have
to specify the class explicitly, for example:
Derived1::staticFunc();
Derived2::staticFunc();
Base::staticFunc(); // does not make sense -- how should the compiler
// know which derived version you mean?
Therefore, the function's virtualness would be completely senseless.
Static and virtual are incompartible concepts.
C
Christian Hackl
Christian said:
I meant to say "because ptr2 points to a Derived2 object", of course.
And I also meant to say "incompatible" instead of "incompartible"
C
Christian Hackl
Victor said:
Could you be a bit more specific? I'd like to learn more about this, but
a search for "static virtual group:comp.lang.c++" in Google Groups
yields 8.310 results, and I cannot really find anything that's contrary
to what I said.
In fact, the fourth hit [1] is a thread in which it's you who says:
"Access to a virtual function is resolved through an instance of the
class. That's the essence of virtuality of member functions. How, I am
asking, is the compiler going to resolve the access if the instance is
NOT to be used? It seems rather a contradiction to me..."
[1]
http://groups.google.com/group/comp.lang.c++/browse_thread/thread/4a550c5b62d0a988/974bf6c3e04013f1
F
Fei Liu
Christian said:
Typically one models this behavior (static virtual) through a static
method that calls a virtual method with argument that contains a
polymorphic object. This is sometimes called a 'Strategy' design pattern.
Think of it this way, the compiler cannot delegate a static method but
there is nothing to stop a developer adding delegation in a static method.
Fei
C
Christian Hackl
Fei said:
Is that a polymorphic object of the same class hierarchy the class
containing the static method belongs to?
In other words, something along the lines of:
class Base
{
//...
virtual void func() = 0;
static Base *strategy_;
static void staticFunc()
{
strategy_->func();
}
};
class Derived : public Base
{
//...
virtual void func();
};
Base *ptr = new Derived;
Base::strategy_ = ptr;
Base::staticFunc(); // "virtual" static function call
F
Fei Liu
Not really, in pseudo code:Christian said:
A::static_method(poly_object * obj){
do1();
obj->some_method();
do2();
}
Of course, this also nicely uses the 'template method' pattern, your
static_method defines a template method that all callers will follow,
then some_method can implement polymorphic behavior on demand.
Fei
S
slocum
I understand that implementing virtual static method is "technicaly"
impossible, but I not asked about c++ standart but how to create class
method that will be behave like virutal static.
I've found the resolve using templates.
class A
{
public:
static X();
};
class B
{
public:
static X();
};
template <class T>
class C
{
public:
void func (void) {T::X();}
}
So I have static X() method and I can switch the C::func() behaving.
Of course there is no polymorphic mechanism and can't use it in the
runtime, but this is what I was looking for.
impossible, but I not asked about c++ standart but how to create class
method that will be behave like virutal static.
I've found the resolve using templates.
class A
{
public:
static X();
};
class B
{
public:
static X();
};
template <class T>
class C
{
public:
void func (void) {T::X();}
}
So I have static X() method and I can switch the C::func() behaving.
Of course there is no polymorphic mechanism and can't use it in the
runtime, but this is what I was looking for.
C
Christian Hackl
Fei said:
Should this perhaps be
A::static_method(A *obj)
?
Otherwise, it certainly looks like an interesting technique, though I am
not sure I can think of a situation in which it would be very useful.