Static polymorphism with virtual functions

Question

This is a followup question of Static polymorphism with final or templates?. So it seems that the best solution for static-only polymorphism is to use CRTP. If you want runtime polymorphism, virtual functions are a good solution.

I find that not very elegant because the problems are actually very similar (and maybe you want to change the behavior at some point) but the code is actually very different. The code would in my opinion be more expressive if the solutions would be very similar and only differ at a single spot.

So I would like to know if there is a way to get static-only polymorphism with virtual functions. That might be something like an attribute or some construction to not allow pointers to the abstract base class. Is there such a feature and if not, am I missing something why such a feature should not exist? Are static and runtime polymorphism actually more different than such a feature would suggest?

EDIT: To make the question and the usecase a bit clearer, here is some example, that I would like to write:

[[abstract]] class Base {
public:
  void bar() { /* do something using foo() */ }
private:
  virtual void foo() = 0;
};

class Derived1 : public Base {
public:
  Derived1();
private:
  void foo() override { /* do something */};
};

class Derived2 : pulic Base {
public:
  Derived2();
private:
  void foo() override { /* do something with data */ }
  int data;
};
  

where the non-existing attribute [[abstract]] means that there cannot exist an instance of the class Bass, even not by a pointer. This would clearly express static polymorphism and the compiler could optimize away virtual calls because they do not exist. Also a virtual destructor would not be necessary.

EDIT 2: The goal is to provide an abstract interface that can be slightly modified in further derived classes and has the same options for extending as an abstract class. So the main implementation is still in Base and the specific implementation of the virtual functions is in Derived.

Answer 1

You are more likely to get something the other way around, runtime polymorphism that looks like static polymorphism, or that looks like something completely different.

The metaclass proposals floated for post-reflection C++ (maybe c++26) look powerful enough to do stuff like:

Interface IBob {
  void foo();
};

and

Implementation<Dispatch::Static> BobImpl:IBob {
  void foo() {}
};
Implementation<Dispatch::Dynamic> BobImpl:IBob {
  void foo() {}
};

to do roughly what you are asking. (Syntax is ridiculously far from final in the metaclass proposal(s); the expressive power is clearly there to do the above, however).

The dynamic case would set up vtables and the like (possibly not the standard C++ vtables however), and in the static case BobImpl would be unrelated to the type bob.

Of course, at that point, I expect there to be so many new ways to express polymorphism in C++ that "I want my CRTP to be written like a virtual function table C++ object" to be a bit like seeing atomic power technology coming over the horizon, and being excited that it could replace the coal burner on your steam-train.

Answer 2

So it seems that the best solution for static-only polymorphism is to use CRTP. If you want runtime polymorphism, virtual functions are a good solution.

In your linked question, you used CRTP to enforce an interface:

template <typename TData>
struct Base {
   void foo() {
       static_cast<TData*>(this)->doFoo();
   }

This uses static polymorphism, but it's a very specific use. It does nothing at all but refuse to compile if your derived class doesn't have a suitable doFoo method. So I don't know how you reached your conclusion.

I find that not very elegant because the problems are actually very similar (and maybe you want to change the behavior at some point) but the code is actually very different. The code would in my opinion be more expressive if the solutions would be very similar and only differ at a single spot.

You lost me. Runtime polymorphism affects two things in C++:

1. declaration, since you must have a base class, the virtual keyword, and optionally override and final

2. use, when the call site uses virtual dispatch to find the correct method implementation

   (although, as discussed, this may be optimized out when the static type is known).

Note also that although polymorphism is often discussed as being about relationships between objects, in C++ we're really only talking about method dispatch.

Static polymorphism only affects the call site. The fact that your other question used CRTP doesn't mean that is the only way of using static polymorphism.

If I write a template function

template <typename T>
void foo_it(T&& t) { t.foo(); }

then that uses static polymorphism. It will work for any T with a suitable foo method, whether it derived from Base<T> or not. It will even work for a T which overrides a virtual foo() from some other base class. This is duck typing.

Since it's unclear what you hope your [[abstract]] Base to achieve, I can only advise you to just write

class Derived {
public:
  void foo();
};

and pass it around to function templates that expect some type implementing foo().

---

As a follow-up to your edit

So the main implementation is still in Base and the specific implementation of the virtual functions is in Derived

It's perfectly fine to do this using CRTP. That is an implementation detail which happens to use static polymorphism, not a virtual-like hierarchy.

For example

template <typename Derived>
struct Template {
  Derived* virt() { return static_cast<Derived*>(this); }

  int foo(int i) {
    return i + virt->detail(i) + virt->extra();
  }
};

struct A: public Template<A> {
  int detail(int i) { return i*i; }
  int extra() { return 17; }
};

struct B: public Template<B> {
  int detail(int i) { return i % 23; }
  int extra() { return -42; }
};

creates two independent types A and B, which provide the same interface int foo(int), and happen to share some code as an implementation detail.

It doesn't create a hierarchy. If you write a function template that takes some object of type T and calls the method int T::foo(int) on it, this will work. That is static polymorphism. It doesn't require a shared base class.

Answer 3

Assuming the question is how to enforce at compile time that derived classes

• implement a base "abstract interface"
• without polymorphism
• keeping the implementation non-public, yet accessible to base class members

the following could be one way to do it.

#include <type_traits>
#include <iostream>
using std::cout;
using std::endl;

template<class Impl> class Base {
protected:
  void foo() {
    Bridge::virtual_foo(static_cast<Impl&>(*this));
  }

  struct Bridge : public Impl {
    static void virtual_foo(Impl &that) {
      static constexpr void (Impl::*fn)() = &Bridge::foo;
      (that.*fn)();
    }
    static_assert(std::is_same<void (Impl::*)(), decltype(&Bridge::foo)>::value, "foo not implemented");
  };

public:
  void bar() {
    cout << "begin Base::bar" << endl;
    foo();
    cout << "end Base::bar" << endl << endl;
  }
};

class Good : public Base<Good> {
protected:
  void foo() {
    cout << "in Good::foo" << endl;
  }
};

class Bad : public Base<Bad> {
};

int main() {
  Good().bar();
// Bad().bar(); // static_assert: 'foo' not implemented
}

Output:

begin Base::bar
in Good::foo
end Base::bar