Why have virtual static members not been added as a feature of C++?

Question

I just read (for the k'th time)

C++ static virtual members?

Which is a question about simulating virtual static members. My question is - what made the C++ standards committe (or Bjarne Stroustrup before that) not add this feature to C? Are they known to break anything? Or impede the performance of anything (even when not used)?

To better illustrate what I'm taking about over the feature definition itself, here is some code:

// This does not compile!
class Base {
    // A pure virtual member - perhaps need to indicate that somehow
    virtual static const string ToWhom; 
    void sayHello() {
        cout << "Hello, " << ToWhom << "!" << endl;
    }
};
class World : public Base {
    static virtual const string ToWhom = "the entire world"s; // C++14 literal
};
class Everybody : public Base {
    static virtual const string ToWhom = "everybody around"s;
};

Note: I'm not asking about your opinion or whether adding these is a good idea, I'm asking about the history and the official considerations.

Answer 1

First, let's look at an invalid example of how static virtuals could look:

// WARNING: This does not compile !!!
class Base {
    static virtual string toWhom() {
        return "unknown";
    }
    static void sayHello() {
        cout << "Hello, " << toWhom() << "!" << endl;
    }
};
class World : public Base {
    static virtual string toWhom() {
        return "world";
    }
};
class Everybody : public Base {
    static virtual string toWhom() {
        return "everybody";
    }
};

This would let you do this:

// WARNING: This does not work !!!
Everybody::sayHello(); // Prints "Hello, everybody!"
World::sayHello(); // Prints "Hello, world!"

The problem, however, is that a dispatch like this would not be easy to implement without changing the way static functions are called in C++.

Recall that non-static member functions get this parameter implicitly. It is this parameter that carries information about virtual functions with it. When you call a static function, however, nothing is passed that would identify the current class (i.e. Hello vs. Everybody in the example above). There are no implicit arguments, hence no access to virtual functions.

Going back to the example above, consider what would happen when Base::sayHello calls toWhom(). It needs to have some context to make a decision on which of the three function should be called - i.e. Base::toWhom, World::toWhom, or Everybody::toWhom. Not only is this information missing, but there is also no existing mechanism in the language on which we could "piggyback" this functionality in a way similar to how a pointer to virtual functions is added to the data for the class.

Although it is true that this invocation mechanism could be changed, the authors of the language did not see compelling reasons for doing this.

Answer 2

A virtual method would require a virtual table, a virtual table would require an instance with a vtable pointer, static member methods are not called through an instance, therefore it is simply not possible.

From the "problem" described in you question, it would appear that you'd expect polymorphic behavior from usage in this format:

Everybody::sayHello();
World::sayHello(); 

But that doesn't really mandate polymorphism, because you point the kind of functionality you want invoked - it is clear that Everybody::sayHello() invokes the functionality for Everybody. There is no "polymorphic ambiguity" - there is no unknown type whose functionality needs to be looked up to produce the expected polymorphic behavior.

Therefore you don't really need dynamic dispatch to solve this problem, you can simply use shadowing - even though you cannot overload static methods as virtual methods, you can still overload by shadowing them, and it is OK, because you specify the type therefore you will get the correct version.

You can either shadow the static methods manually:

struct Base {
  static string toWhom() { return ""; }
  static void sayHi() { cout << "Hello " + toWhom(); }
};

struct World : Base {
  static string toWhom() { return "World"; }
  static void sayHi() { cout << "Hello " + toWhom(); }
};

struct Everyone : Base {
  static string toWhom() { return "Everyone"; }
  static void sayHi() { cout << "Hello " + toWhom(); }
};

Or use a class template to have it done for you, so you only have to shadow the "virtual static method", the template will make sure the correct type to invoke the static method for:

template <typename T>
struct Base {
  static string toWhom() { return ""; }
  static void sayHi() { cout << "Hello " + T::toWhom(); }
};

struct World : Base<World> {
  static string toWhom() { return "World"; }
};

struct Everyone : Base<Everyone> {
  static string toWhom() { return "Everyone"; }
};

Then

Everybody::sayHello();
World::sayHello(); 

both solutions will produce the expected result. There is simply no need for any polymorphism to accomplish this goal. Note that it would certainly be possible to implement exactly what you want, but that would just give you the possibility to create a less efficient solution - because polymorphism has both memory and CPU time overhead, and C++ is a language whose primary concern is performance and efficiency. Therefore it doesn't support a feature that is unneeded, since it is already possible to do what you ask for, and it will be blazing fast, because such simple functions will not even be called - they will be inlined. There is a tremendous performance difference between a function that is inlined and the invoking of a virtual method (like 20x for such trivial functions), and adding another level of indirection for the sake of implementing static virtual members will only make it worse.

I hope now I've given compelling answers to why is this not possible in C++, why it is not needed, and why it makes no sense making it possible in that particular language whatsoever. You basically want to use polymorphism in a scenario that doesn't call for it, for the sake of making the language "easier" - well, you can't have it both ways, C++ is hard because it is fast, just like easier languages are all slower than C++.

Lastly - if you feel like this is such an important language feature to have - you can always request the feature from the standard committee ;)

Answer 3

You can implement polymorphic behaviour statically using the CRTP. For example,

#include <iostream>
using namespace std;

template <typename Derived>
struct Base {
    static void sayHello() {
        cout << "Hello, " << Derived::toWhom() << "!" << endl;
    }
};

struct World : public Base<World> {
    static string toWhom() {
        return "world";
    }
};

struct Everybody : public Base<Everybody> {
    static string toWhom() {
        return "everybody";
    }
};

int main() {
    World::sayHello();
    Everybody::sayHello();
    return 0;
}

There are lots of detailed questions and answers on SO about CRTP if you want more information on the topic.

Answer 4

A static member function does not act on any particular object.

A virtual member function is the means of specifying that behaviour (the version of the function called) depends on the type of object being acted on (e.g. the code executed by object->foo() depends on the actual type of object).

That is how the two concepts of virtual and static are specified in C++ (at least, in this context). The two concepts are mutually exclusive.

It is not possible to have runtime behaviour that doesn't act on any object depend on the type of object it acts on. It is a logical fallacy.

Answer 5

Since you are comparing with Objective-C: In Objective-C, classes are themselves objects. In C++, classes are a compile-time construct; they don't exist at runtime. C++ static class methods are just plain old extern functions with some interesting syntax. Because there are no class objects unlike in Objective-C, virtual static functions don't make any sense.