Waterlimon, since you plan never to actually instantiate classes of type Foo you are correct that you do not need virtual functions, and your method for run-time checking that methods have been implemented is fine, at least in debug mode.

But a better option for ensuring things work how you want them to work is to make the constructor of Foo protected rather than inheriting from it in a protected or private way—making the constructor protected ensures no future mistakes can occur when one day you accidentally forget and inherit from it in a public manner.

L. Spiro

#include <iostream>

/*
interface Foo {
	foo();
	bar();
}
*/

template <typename T>
struct ensure_implements_foo {
	decltype(&T::foo) foo;
	decltype(&T::bar) bar;
};

class A {
public:
	int foo() {return 0;}
	void bar() {}
};

class B {
public:
};

int main() {
	ensure_implements_foo<A> checkA; // compiles fine
	ensure_implements_foo<B> checkB; // fails compilation, because B does not implement Foo
}

There is a clever template trick to check the presence of members at runtime.

You know, it now strikes me that this is a completely pointless exercise.

All the template magic in the world, and it still doesn't tell you anything more than you would know if you tried to call the function in the first place.

Oh, but the obscure error message you would get with the method you posted is much more fun to track down.

You should rejoin the modern world, my friend, where template errors are no longer scary:

$ clang++ -std=c++11 -o foo foo.c++

foo.c++:12:18: error: no member named 'foo' in 'B'
    decltype(&T::foo) foo;
              ~~~^
foo.c++:28:30: note: in instantiation of template class 'ensure_implements_foo<B>' requested here
    ensure_implements_foo<B> checkB; // fails compilation, because B does not implement Foo
                             ^
foo.c++:13:18: error: no member named 'bar' in 'B'
    decltype(&T::bar) bar;
              ~~~^
2 errors generated.