Question

Is it possible to automatically determine if a class is an abstract base class at compile time?

I have an object factory that, via other generic code, sometimes gets instantiated with an Abstract Base Class type. The code doesn’t compile because it calls new T() on the ABC. I end up having to specialize the object factory create code for each ABC to instead assert(0) in this case. If it were possible to automatically determine if a type is an ABC at compile-time this specialization could be automated.

A simplified example follows:

// this program code compiles w/ gcc 4.4
#include <iostream>
#include <typeinfo>

// How to automatically specialize this class at compile-time?
template<typename T>
struct isAbstractBaseClass
{
  enum { VALUE = 0 };
};

// Factory to create T, lives in a struct to allow default template parameters
template<typename T, int ABSTRACT = isAbstractBaseClass<T>::VALUE >
struct Create
{
  static T* create()
  {
    return new T();
  }
};

// specialize Create for abstract base classes
template<typename T>
struct Create<T, 1>
{
  static T* create()
  {
    std::cout << "Cannot create and Abstract Base Class!\n";
    std::cout << "Create failed on type_info::name() = " << typeid(T).name() << "\n";
    return 0;
  }
};

struct Foo
{
  Foo() { std::cout << "Foo created\n"; }
};

struct Baz
{
  virtual void bar() = 0; // make this an Abstract Base Class
};

// template specialize on Baz to mark it as an Abstract Base Class
// My Question: is it possible to automatically determine this at compile-time?
template<> class isAbstractBaseClass<Baz> { enum { VALUE = 1 }; };


int main()
{
  std::cout << "Attempting to create a Foo class.\n";
  delete Create<Foo>::create();

  std::cout << "Attempting to create a Baz class.\n";
  delete Create<Baz>::create();

  return 0;
}

the output:

> c++ abstract.cpp && ./a.out
Attempting to create a Foo class.
Foo created
Attempting to create a Baz class.
Cannot create and Abstract Base Class!
Create failed on type_info::name() = 3Baz

edit 1 @jwismar pointed me towards Boost’s is_abstract implementation. Honestly, looking at the code and trying to deduce what boost is doing is very painful. Can someone boil down what trick they’re using? (edit 2 actually, I was looking at the wrong bit of code, and I figured it down below in edit 2)

@raj Yes, there is a constraint that the class must have a default public constructor. Its not entirely generic, but it provides functionality for 99% of the types I care about. Adding a create() method is not an option because I don’t control some of the classes being wrapped (3rd party code).

@DennisZickefoose The code does compile — with template specializations to handle ABCs. Yes, the design could be improved to ensure the code that instantiates the create() method with an ABC doesn’t do so, but that code is also performing other duties which make sense on ABCs and non-ABCs alike. At this point it would be a major re-write and I’m looking for a more short term solution.

Both @raj and @DennisZickefoose make good points about the design of the example and the underlying code base, but I’m really only interested in the topic’s question of how to determine ABC-ness of a type at compile time. Preferably without Boost. My rationale for such a need is orthogonal to the question at hand.

edit 2 Since I can’t answer my own question with out 100 reputation, I’ll post my answer here:

I was able to understand the Boost is_abstract code enough to create a version of isAbstractBaseClass that works for my needs. It uses SFINAE to fallback to the check_sig(…) version in the case of an ABC type.

template<class T>
struct isAbstractBaseClass
{
  // Inspired by boost/type_traits/is_abstract.hpp
  // Deduction fails if T is void, function type, 
  // reference type (14.8.2/2)or an abstract class type 
  // according to review status issue #337
  template<class U>
  static char check_sig(U (*)[1]);
  template<class U>
  static short check_sig(...);
  //
  enum { VALUE = sizeof(isAbstractBaseClass<T>::template check_sig<T>(0)) - 1 };
};

Answer 1

The Boost Type Traits library has an is_abstract functor. You could either use that directly, or take a look at the implementation and see how they handled it.