I know that I can compare the type of objects at runtime by using typeid(). This provides a reference to an object representing the class of the object. What I want to know is, is their any way to call a static method off of the Type object?

Ultimately, what I would like is a polymorphic static function. That is, I have an abstract class which provides a couple of methods which really ought to be static. Yet, I would like the classes which inherit from this class to override these methods.

I would love it if I could do something like this:

But this doesn't compile.

According to some online documentation, there is an extension to IBM compilers that will let you do this with the 'typeof' operator, but I'd rather not be tied to a particular compiler.

Alternatively, I could just implement them as regular methods, but I'd hate to have all that unnecessary overhead. So, does anyone have an idea? Can it be done?

Okay, after revisiting the design of the program, I guess it does make more sense for these to be regular methods. But I guess if anyone knows the answer to the original question it might still be nice to know, just for curiosity/academic reasons.

I don't think this is possible in C++, and I'm not sure why writing is better than Seems like the first way is just more typing with no extra benefit. If you think it would somehow be more efficient, remember that you are still asking for a runtime dispatch so calling it a static method doesn't automagically reduce overhead.

I don't think that there is an easy way around your requirement, although I'm not certain what "unnecessary overhead" you are concerned about.

There is an approach that I can think about:
In each class you have two methods the static and the non-static method with the non-static method defined as virtual and it calls the classes static method. This means that you can call the static method directly if you know which class you want to fire the method, otherwise if you have an object you can use the non-static method to search the virtual tables to determine which method should be called.

Upon researching more, my idea of "unnecessary overhead" was due to my misunderstanding of how c++ implements objects. In my education, I had been told that we could think of their being a separate copy of a method existing for each object, and that only a single copy of a static method existed. I realize now that it only appears that way to the programmer, but object code is not actually being copied about - only one copy of method() exists, and c++ just sets up the this pointer. I realize now that instantiating an object does not involve copying the memory space of the methods.

I further realize my my desire to have polymorphic static methods was really just a product of a bad design - static methods just aren't meant to be polymorphic.

That is correct. There is only one copy of each function but member functions implicitly take an additional argument which is the this pointer. The compiler inserts this argument when compiling the function and passes its value to the function based on the left side of the . or -> (plus any conversions required to facilitate polymorphism.) It is still valid to call a static function as if it were a member function; it just eliminates inserting a this argument.
ta0kira