为具有对象或对象数组作为成员的类运行不同的代码

Question

I have a method that takes an object as parameter

void fun(const Obj& obj)

Obj can be defined in two different ways:

struct Obj
{
   Type x;
};

and

struct Obj
{
   Type x[42];
};

I cannot modify the definitions of Obj (ie I can't rename the classes). Also, I can't modify the signature of fun and I'd rather not use preprocessor directives inside of fun . Is there a way to use metaprogramming to make this compile and work regardless of which definition of Obj is included:

void fun(const Obj& obj)
{
   impl(obj); // executes some code if obj.x is an object
              // executes some other code if obj.x is an array 
}

? Is there a way to do it without C++11 features?

Answer 1

You could pick a specialization of a template based on decltype(obj.x) :

template<typename T>
void impl(const Obj&);

template<> 
void impl<Type>(const Obj&) {}

template<>
void imp<Type[42]>(const Obj&) {}


void fun(const Obj& obj)
{
   impl<decltype(obj.x)>(obj);
}

Possible C++03 way is a member detector trait class that checks for existence of Type Obj::x . This time, template parameter of impl would be bool so you can simply pass the result of the check:

template<typename C>
struct has_Type_x {
    template<typename U, U>
    struct Check;

    typedef char(&yes)[1];
    typedef char(&no)[2];

    template<typename> static no test(...);
    template<typename U> static yes test(Check<Type U::*, &U::x>*);

    static const bool value = sizeof(test<C>(0)) == sizeof(yes);
};

template<bool> void impl(const Obj&);

template<>
void impl<true>(const Obj&) {}

template<>
void impl<false>(const Obj&) {
    std::cout << "arr";
}

void fun(const Obj& obj)
{
   impl< has_int_x<Obj>::value >(obj);
}

Answer 2

This can be done by a second call to an implementation function fun_impl that also takes obj.x as an argument. This function specializes to scalars or arrays by two overloads, the latter accepting a reference to an array, so maintaining the array size as well:

template <typename Obj, typename T>
void fun_impl(const Obj& obj, const T& x) {}

template <typename Obj, typename T, size_t N>
void fun_impl(const Obj& obj, const T (&x)[N]) {}

template <typename Obj>
void fun(const Obj& obj)
{
   fun_impl(obj, obj.x);
}

This works in C++03 and does not require any traits features or SFINAE. See also live example , where the remaining parts use C++11 for convenience.

If obj only contains x , you can drop it as an argument from fun_impl . I left it here for the more general case where obj might have other members as well.

Note that fun itself is given as a template here; I guess this is what you need to do anyway since you are dealing with different definitions of Obj .

Answer 3

My suggestion is to use function overloading. You don't need metaprogramming/templates in your case:

void fun(const Obj& obj)
{
   impl(obj.x);
}

void impl(const Type& x){...}
void impl(Type x[]){...}

If Obj::x is declared as Type x then the first impl() version will be called. And similarly in another case the second impl() version will be called.