How to decide if a template specialization exist

Question

I would like to check if a certain template specialization exist or not, where the general case is not defined.

Given:

template <typename T> struct A; // general definition not defined
template <> struct A<int> {};   // specialization defined for int

I would like to define a struct like this:

template <typename T>
struct IsDefined
{
    static const bool value = ???; // true if A<T> exist, false if it does not
};

Is there a way to do that (ideally without C++11)?

Thanks

@HSchmale, The full problem is described here: https://stackoverflow.com/questions/44237528/how-to-write-template-overload-functions-with-fallback-triggered-if-template-arg — Fabio, May 29 '17 at 14:07

Quentin · Accepted Answer · 2017-05-28T17:05:37.757

25

Using the fact that you can't apply sizeof to an incomplete type:

template <class T, std::size_t = sizeof(T)>
std::true_type is_complete_impl(T *);

std::false_type is_complete_impl(...);

template <class T>
using is_complete = decltype(is_complete_impl(std::declval<T*>()));

See it live on Coliru

Here is a slightly clunky, but working C++03 solution:

template <class T>
char is_complete_impl(char (*)[sizeof(T)]);

template <class>
char (&is_complete_impl(...))[2];

template <class T>
struct is_complete {
    enum { value = sizeof(is_complete_impl<T>(0)) == sizeof(char) };
};

See it live on Coliru

edited May 28 '17 at 17:05

answered May 28 '17 at 16:49

Quentin

62,093
7
131
191

Thanks. Is there a way to do it without C++11? – Fabio May 28 '17 at 16:58
@Fabio there you go. – Quentin May 28 '17 at 17:05
Thanks! Is template in the second definition of is_complete_impl needed in the C++03 solution? – Fabio May 28 '17 at 17:20
@Fabio just because I elected to pass the type explicitly rather than deduce it from a parameter :) – Quentin May 28 '17 at 17:20
By the way, the second definition can be simplified a little bit as: `template long is_complete_impl(...);` – Fabio May 29 '17 at 14:00

score 2 · Answer 2 · answered Oct 28 '17 at 17:15

This is an alternative implementation always using the same trick @Quentin used

C++11 version

template<class First, std::size_t>
using first_t = First;

template<class T>
struct is_complete_type: std::false_type {};

template<class T>
struct is_complete_type<first_t<T, sizeof(T)>> : std::true_type {};

Example on wandbox

Tentative C++03 version which does not work

template<typename First, std::size_t>
struct first { typedef First type; };

template<typename T>
struct is_complete_type { static const bool value = false; };

template<typename T>
struct is_complete_type< typename first<T, sizeof(T)>::type > { static const bool value = true; };

The error in this case is

prog.cc:11:8: error: template parameters not deducible in partial specialization: struct is_complete_type< typename first::type > { static const bool value = true; }; ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

prog.cc:11:8: note: 'T'

That `assert` statement in the example make code inside disappear in release build. — Senyai, Jul 18 '19 at 17:33

How to decide if a template specialization exist

2 Answers2

Linked