fork download

copy

#include <iostream>
#include <type_traits>
 
namespace tmpl
{
 
namespace detail
{
 
template<template<typename...> class C, typename... T>
struct is_valid_instantiation_impl
{
  // Default constructor
  template<template<typename...> class D>
  static std::true_type test(decltype(D<T...>{ })*, int);
  // Copy constructor
  template<template<typename...> class D>
  static std::true_type test(decltype(D<T...>{ std::declval<const D<T...>&>() })*, long);
  // Move constructor
  template<template<typename...> class D>
  static std::true_type test(decltype(D<T...>{ std::declval<D<T...>&&>() })*, int*);
 
  template<template<typename...> class D>
  static std::false_type test(...);
 
  using type =  decltype(test<C>(nullptr, 0));
  //                                      ^ this one
};
 
} // namespace detail
 
template<template<typename...> class C, typename... T>
struct is_valid_instantiation : detail::is_valid_instantiation_impl<C, T...>::type { };
 
} // namespace tmpl
 
template<typename>
struct tester
{
  tester(const tester&) = delete;
  tester(tester&&) = delete;
 
private:
  tester();
};
 
template<>
struct tester<char>;
 
template<>
struct tester<int>
{
  tester(int);
};
 
int main(int argc, char** argv)
{
  std::cout << "instantiable<char>: " << tmpl::is_valid_instantiation<tester, char>::value << std::endl;
  std::cout << "instantiable<int>: " << tmpl::is_valid_instantiation<tester, int>::value << std::endl;
  std::cout << "instantiable<float>: " << tmpl::is_valid_instantiation<tester, float>::value << std::endl;
}
 

prog.cpp: In instantiation of 'struct tmpl::detail::is_valid_instantiation_impl<tester, int>':
prog.cpp:33:8:   required from 'struct tmpl::is_valid_instantiation<tester, int>'
prog.cpp:59:82:   required from here
prog.cpp:26:30: error: call of overloaded 'test(std::nullptr_t, int)' is ambiguous
   using type =  decltype(test<C>(nullptr, 0));
                              ^
prog.cpp:26:30: note: candidates are:
prog.cpp:18:25: note: static std::true_type tmpl::detail::is_valid_instantiation_impl<C, T>::test(decltype (D<T ...>{declval<const D<T ...>&>()})*, long int) [with D = tester; C = tester; T = {int}; std::true_type = std::integral_constant<bool, true>; decltype (D<T ...>{declval<const D<T ...>&>()}) = tester<int>]
   static std::true_type test(decltype(D<T...>{ std::declval<const D<T...>&>() })*, long);
                         ^
prog.cpp:21:25: note: static std::true_type tmpl::detail::is_valid_instantiation_impl<C, T>::test(decltype (D<T ...>{declval<D<T ...>&&>()})*, int*) [with D = tester; C = tester; T = {int}; std::true_type = std::integral_constant<bool, true>; decltype (D<T ...>{declval<D<T ...>&&>()}) = tester<int>]
   static std::true_type test(decltype(D<T...>{ std::declval<D<T...>&&>() })*, int*);
                         ^
prog.cpp:24:26: note: static std::false_type tmpl::detail::is_valid_instantiation_impl<C, T>::test(...) [with D = tester; C = tester; T = {int}; std::false_type = std::integral_constant<bool, false>]
   static std::false_type test(...);
                          ^
prog.cpp: In function 'int main(int, char**)':
prog.cpp:59:41: error: 'value' is not a member of 'tmpl::is_valid_instantiation<tester, int>'
   std::cout << "instantiable<int>: " << tmpl::is_valid_instantiation<tester, int>::value << std::endl;
                                         ^

Standard output is empty