Alternative to virtual static functions in c++? - c++

Question

In the header file .hpp:
class Base{
public:
static /*Some Return Type*/ func(/*Some Datatype*/);
}
class Derived1 public Base{
public:
Derived1();
~Derived1();
}
class Derived1 public Base{
public:
Derived2();
~Derived2();
}
In the cpp file .cpp:
/*Some Return Type*/ Derived1::func(/*Some Datatype*/){
}
/*Some Return Type*/ Derived2::func(/*Some Datatype*/){
}
This obviously fails because there is no way to override a static method in a subclass. But how to obtain the above functionality?
It is mandatory for me to call something like this:
/*Some Return Type*/ result = Derived1::func(/*Some Datatype*/)
/*Some Return Type*/ result = Derived2::func(/*Some Datatype*/)
I know, that abstract method can be defined in the base class like below and then define them in Derived class:
In the header file .hpp:
class Base{
public:
virtual /*Some Return Type*/ func(/*Some Datatype*/) const = 0;
}
But the problem is that virtual methods require object instantiation, which is not I want. I want to call the method without creating an object. If virtual static methods were allowed, they would have served the purpose.
The only alternative that I can think of is to declare the function func() in all the Derived classes in the header file and remove it from the Base class. Is there any alternative method to do it? So that the declaration is only once in the Base class and all the Derived classes only have to define them, not redeclare?

Answer 1

Calling a virtual function without an object is a contrasense,
since the resolution depends on the type of the object.
are cases where you might need to call the same function
dependant on the type of an object, or specifying the class
explicitly, without an object. This is easily handled by using
two functions, one static, and one virtual. (Typically, the
virtual one will just forward to the static.)
EDIT:
A simple example (from actual code):
#define DECLARE_CLASS_NAME(className) \
static char className() { return STRINGIZE(className); } \
virtual char* getClassName() { return className(); }
class Base
{
public:
DECLARE_CLASS_NAME(Base);
// ...
};
class Derived : public Base
{
public:
DECLARE_CLASS_NAME(Derived);
// ...
};
and so on, in all of the derived classes. This was used to
obtain the type names for serialization, for example:
std::string typeName = pObj->getClassName();
and also as a primitive RTTI (this was about 20 years ago):
if ( pObj->getClassName() == Derived::className() ) ...
(We had established the rule that the only way you could obtain
the name of a class was by using one of these functions. That
effectively internalized the names of the classes, and allowed
simple pointer comparisons to work. On the systems we were
working on then, this was important.)

Answer 2

You can do that a bit hacky =)
//header file
template<class T>
struct base_t
{
static void do_smth();
};
struct derived1_t : base_t<derived1_t>
{
};
struct derived2_t : base_t<derived2_t>
{
};
//cpp file
void base_t<derived1_t>::do_smth() // `note base_t<derived1_t>::` instead of `derived1_t::`
{
std::cout << "aaa" << std::endl;
}
PS: very strange that you do not want to declare this function in derived classes, because when you use virtual functions you should declare them in derived class

Answer 3

One possibility is to only define them in the derived classes:
struct Base
{
// nothing
};
struct Derived1 : public Base
{
static void func() { /*...*/ }
};
struct Derived2 : public Base
{
static void func() { /*...*/ }
};
This allows you to call:
Derived1::foo();
Derived2::foo();
Calling it for the base type and expecting the compiler to figure out which subtype you mean cannot work:
// How will the compiler know to choose
// between Derived1:: func or Derived2:: func ?
Base::func();
You might want to look at CRTP or type-traits for alternative approaches.