fork(1) download

copy

#include <iostream>
#include <type_traits>
 
// template funcName should exist 
#define HAS_TEMPLATED_FUNC(traitsName, funcName, Prototype)                          \
    template<typename T>                                                             \
    class traitsName                                                                 \
        typedef char yes[1];                                                         \
        typedef struct {char dummy[2];} no ;                                         \
        template <typename U, U> struct type_check;                                  \
        template <typename U = T> static yes &chk(type_check<Prototype, &funcName<U>>*); \
        template <typename > static no  &chk(...);                                   \
    public:                                                                          \
        static bool const value = sizeof(chk<T>(0)) == sizeof(yes);                  \
    }
 
//A sequence container type
class Array_T{};
 
//A type trait for that particular sequence container
template <typename T> struct Is_Array           { static const bool value = false; };
template <>           struct Is_Array<Array_T>  { static const bool value = true;  };
 
//A type trait to identify all of the sequence containers
template <typename T> struct Is_A_Sequence_Container { static const bool value = Is_Array<T>::value
/* would probably "or" together more sequence types, but we only have Array_T in this example */;};
 
//A type trait to identify all of the data structures
template <typename T> struct Is_A_Data_Structure { static const bool value = Is_A_Sequence_Container<T>::value
/* would probably "or" together more data structure types, but we only have sequence containers in this example */;};
 
 
 
//NOTE: This function MAY OR MAY NOT actually appear in the source code
//This function handles all sequence types
template<class T, typename std::enable_if<Is_A_Sequence_Container<T>::value,int>::type=0>
void function(T t) {
    std::cout << "sequence container" << std::endl;
    return;
}
 
 
// this assumes that any template 'function' exists
// (Do you have version for `data structure` ?)
// or else create a dummy struct and then
// template <T>
// typename std::enable_if<std::is_same<T, dummy>::value>::type function(dummy) {}
HAS_TEMPLATED_FUNC(isFunctionExist_Specialized, function, void (*)(T));
 
//This function handles all data structures; assuming a more specific function does not exist(*cough* the one above it)
template<class T, typename std::enable_if<Is_A_Data_Structure<T>::value, int>::type = 0,
                  typename std::enable_if<!isFunctionExist_Specialized<T>::value, int>::type = 0>>
void function(T t) {
    std::cout << "data structure" << std::endl;
    return;
}
 
int main(){
 
    function(Array_T{});
}

prog.cpp:7:5: error: template declaration of ‘typedef’
     class traitsName                                                                 \
     ^
prog.cpp:48:1: note: in expansion of macro ‘HAS_TEMPLATED_FUNC’
 HAS_TEMPLATED_FUNC(isFunctionExist_Specialized, function, void (*)(T));
 ^
prog.cpp:11:32: error: expected type-specifier before ‘T’
         template <typename U = T> static yes &chk(type_check<Prototype, &funcName<U>>*); \
                                ^
prog.cpp:48:1: note: in expansion of macro ‘HAS_TEMPLATED_FUNC’
 HAS_TEMPLATED_FUNC(isFunctionExist_Specialized, function, void (*)(T));
 ^
prog.cpp:11:32: error: expected ‘>’ before ‘T’
         template <typename U = T> static yes &chk(type_check<Prototype, &funcName<U>>*); \
                                ^
prog.cpp:48:1: note: in expansion of macro ‘HAS_TEMPLATED_FUNC’
 HAS_TEMPLATED_FUNC(isFunctionExist_Specialized, function, void (*)(T));
 ^
prog.cpp:11:42: error: ‘yes’ does not name a type
         template <typename U = T> static yes &chk(type_check<Prototype, &funcName<U>>*); \
                                          ^
prog.cpp:48:1: note: in expansion of macro ‘HAS_TEMPLATED_FUNC’
 HAS_TEMPLATED_FUNC(isFunctionExist_Specialized, function, void (*)(T));
 ^
prog.cpp:13:5: error: expected unqualified-id before ‘public’
     public:                                                                          \
     ^
prog.cpp:48:1: note: in expansion of macro ‘HAS_TEMPLATED_FUNC’
 HAS_TEMPLATED_FUNC(isFunctionExist_Specialized, function, void (*)(T));
 ^
prog.cpp:15:5: error: expected declaration before ‘}’ token
     }
     ^
prog.cpp:48:1: note: in expansion of macro ‘HAS_TEMPLATED_FUNC’
 HAS_TEMPLATED_FUNC(isFunctionExist_Specialized, function, void (*)(T));
 ^

Standard output is empty