All geek questions in one place

C ++ Template Specialization - Avoid Overriding

I want to have a generic function (or method) that takes arguments of different types. If the provided type has a "one" method, the function should use it. If it has two methods, the function should use it instead.

Here is the wrong code:

#include <iostream>

template<typename Type> void func(Type t)
{
    t.one();
}

template<typename Type> void func(Type t) // redefinition!
{
    t.two();
}

class One
{
    void one(void) const
    {
        std::cout << "one" << std::endl;
    }
};

class Two
{
    void two(void) const
    {
        std::cout << "two" << std::endl;
    }
};

int main(int argc, char* argv[])
{
    func(One()); // should print "one"
    func(Two()); // should print "two"
    return 0;
}

Can i use SFINAE? Is it possible to achieve using type_traits?

Clarification:

I would be happier if it were possible using SFINAE. In the best case: use the first template if it does not use the second.

Verifying the existence of a method is just an example. I really want to check compatibility with other classes.

The task can be rephrased:

  • If the class supports the first interface, use it.
  • , .
  • , .
+4
3

, . ++ 11 .

#include <iostream>
#include <type_traits>

template<class, typename = void>
struct func_dispatch_tag :
  std::integral_constant<int, 0> {};

template<class C>
struct func_dispatch_tag<C, 
  std::enable_if_t<std::is_same<decltype(&C::one), void (C::*)() const>::value>
  > : std::integral_constant<int, 1> {};

template<class C>
struct func_dispatch_tag<C,
  std::enable_if_t<std::is_same<decltype(&C::two), void (C::*)() const>::value>
  > : std::integral_constant<int, 2> {};

template<class C>
void func(C const&, std::integral_constant<int, 0>) {
    std::cout << "fallback!\n";
}

template<class C>
void func(C const &c, std::integral_constant<int, 1>) {
    c.one();
}

template<class C>
void func(C const &c, std::integral_constant<int, 2>) {
    c.two();
}

template<class C>
void func(C const &c) {
    func(c, func_dispatch_tag<C>{});
}

struct One
{
    void one(void) const
    {
        std::cout << "one\n";
    }
};

struct Two
{
    void two(void) const
    {
        std::cout << "two\n";
    }
};

struct Three {};

int main(int argc, char* argv[])
{
    func(One()); // should print "one"
    func(Two()); // should print "two"
    func(Three());
    return 0;
}

:

  • SFINAE func_dispatch_tag. , <C, void>. " ", SF (.. std::enable_if_t void), .

  • , . , ( ).

  • (, ) static_assert. , , int, - func_dispatch_tag.

  • SF . , , , . .

+4

. , func() , " " .

.

- ++ 11. ++ 14 17 .

#include <iostream>
#include <type_traits>
#include <tuple>

// boilerplate required prior to c++17
namespace notstd {
  using namespace std;
  template<typename... Ts> struct make_void { typedef void type;};
  template<typename... Ts> using void_t = typename make_void<Ts...>::type;
}

// test for having member function one()
template<class T, class Enable = notstd::void_t<>> struct has_one : std::false_type {}; 
template<class T> struct has_one<T, notstd::void_t<decltype(std::declval<T>().one())>> : std::true_type {};

//test for having member function two()
template<class T, class Enable = notstd::void_t<>> struct has_two : std::false_type {}; 
template<class T> struct has_two<T, notstd::void_t<decltype(std::declval<T>().two())>> : std::true_type {};

// a type collection of tests that pass
template<template <class...> class...Tests> struct passes_tests {
};

// meta-function to append a type
template<class Existing, template <class...> class Additional> struct append_pass;

template< template <class...> class...Tests, template <class...> class Additional>
struct append_pass<passes_tests<Tests...>, Additional> {
  using type = passes_tests<Tests..., Additional>;
};


//
// meta-functions to compute a list of types of test that pass 
//
namespace detail
{
  template<class Previous, class T, template<class...> class Test, template<class...> class...Rest>
  struct which_tests_pass_impl
  {
    using on_pass = typename append_pass<Previous, Test>::type;
    using on_fail = Previous;

    using this_term = typename std::conditional< Test<T>::value, on_pass, on_fail >::type;
    using type = typename which_tests_pass_impl<this_term, T, Rest...>::type;
  };

  template<class Previous, class T, template<class...> class Test>
  struct which_tests_pass_impl<Previous, T, Test>
  {
    using on_pass = typename append_pass<Previous, Test>::type;
    using on_fail = Previous;

    using this_term = typename std::conditional< Test<T>::value, on_pass, on_fail >::type;
    using type = this_term;
  };

}

template<class Type, template<class...> class...Tests> struct which_tests_pass
{
  using type = typename detail::which_tests_pass_impl<passes_tests<>, Type, Tests...>::type;
};


//
// various implementations of func()
//
namespace detail
{
  template<class T>
  void func(T t, passes_tests<has_one>)
  {
    t.one();
  }

  template<class T>
  void func(T t, passes_tests<has_one, has_two>)
  {
    t.one();
  }

  template<class T>
  void func(T t, passes_tests<has_two>)
  {
    t.two();
  }

  template<class T>
  void func(T t, passes_tests<>)
  {
    // do nothing
  }
}

template<class T>
void func(T t)
{
  detail::func(t, typename which_tests_pass<T, has_one, has_two>::type());
}

//
// some types
//
struct One
{
    void one(void) const
    {
        std::cout << "one" << std::endl;
    }
};

struct Two
{
    void two(void) const
    {
        std::cout << "two" << std::endl;
    }
};

// test
int main(int argc, char* argv[])
{
    func(One()); // should print "one"
    func(Two()); // should print "two"
    return 0;
}
+2

  • -.

++ 14, . rvalue-, as_memfun.

- , , , .

#include <utility>
#include <functional>
namespace detail {
    template<typename T> struct _false : std::integral_constant<bool, false> { };
    template<typename T> struct HasNone {
        static_assert(_false<T>::value, "No valid method found");
    };

    template<typename T, typename R>
    constexpr auto as_memfun (R (T::* arg) ()) 
        -> R (T::*) () 
        { return arg; }
    template<typename T, typename R>
    constexpr auto as_memfun (R (T::* arg) () const)
        -> R (T::*) () const 
        { return arg; }
    template<typename T> constexpr auto check_has_two(int)
        -> decltype(as_memfun(&T::two)) 
        { return as_memfun(&T::two); }
    template<typename T> constexpr auto check_has_two(...)
        -> HasNone<T>;

    template<typename T> constexpr auto check_has_one(int)
        -> decltype(as_memfun(&T::one))
        { return as_memfun(&T::one); }
    template<typename T> constexpr auto check_has_one(...)
        -> decltype(check_has_two<T>(0))
        { return check_has_two<T>(0); }

    template<typename T>
    struct res { constexpr static auto detail = check_has_one<T>(0); };
}

template<typename T>
auto func(T t) -> decltype((t.*detail::res<T>::detail)()) {
    return (t.*detail::res<T>::detail)();
}

, , ,

struct One {
    void one();
};

struct Two {
    void two();
};

struct TestBoth {
    char one() const;
    void two();
};

struct TestWilderStuff {
    int one;
    void two() const;
};

int main() {
    func(One{});
    func(Two{});
    func(TestBoth{});
    static_assert(decltype(func(TestBoth{})){} == 0, "Failed function selection");
    func(TestWilderStuff{});
}

, , , -, . , , .

#include <utility>
#include <functional>
namespace detail {
    template<typename T> struct _false :
        std::integral_constant<bool, false> { };
    template<typename T> struct HasNone {
        static_assert(_false<T>::value, "No valid method found");
    };

    // Generic meta templates used below
    namespace Generics {
        template<typename Getter, typename Else>
        struct ChainGetter {
            template<typename T> constexpr static auto get_(int)
                -> decltype(Getter::template get<T>())
                { return Getter::template get<T>(); }
            template<typename T> constexpr static auto get_(...)
                -> decltype(Else::template get<T>())
                { return Else::template get<T>(); }
            template<typename T> constexpr static auto get()
                -> decltype(get_<T>(0))
                { return get_<T>(0); }
        };

        template<typename Getter, typename Test>
        struct TestGetter {
            template<typename T, typename R> using _type = R;
            template<typename T> constexpr static auto get_()
                -> decltype(Getter::template get<T>())
                { return Getter::template get<T>(); }
            template<typename T> constexpr static auto test()
                -> decltype(Test::template test<T>(get_<T>()));
            template<typename T> constexpr static auto get()
                -> _type<decltype(test<T>()), 
                        decltype(get_<T>())
                        >
                { return get_<T>(); }
        };

        template<template<typename> class F>
        struct FailGetter {
            template<typename T>
            constexpr static auto get() -> F<T>;
        };
    }

    // Test only exists for member function pointer arguments
    struct IsMemberFunctionTest {
        template<typename _, typename T, typename R>
        constexpr static void test (R (T::* arg) ());
        template<typename _, typename T, typename R>
        constexpr static void test (R (T::* arg) () const);
    };

    // Get member pointer to T::one
    struct GetOne {
        template<typename T>
        constexpr static auto get() -> decltype(&T::one) { return &T::one; }
    };

    // Get member pointer to T::two
    struct GetTwo {
        template<typename T>
        constexpr static auto get() -> decltype(&T::two) { return &T::two; }
    };

    using namespace Generics;
    using getter_fail = FailGetter<HasNone>;
    using get_two_tested = TestGetter<GetTwo, IsMemberFunctionTest>;
    using getter_two = ChainGetter<get_two_tested, getter_fail>;
    using get_one_tested = TestGetter<GetOne, IsMemberFunctionTest>;
    using getter_one = ChainGetter<get_one_tested, getter_two>;

    template<typename T>
    struct result { constexpr static auto value = getter_one::template get<T>(); };
}

template<typename T>
auto func(T t) -> decltype((t.*detail::result<T>::value)()) {
    return (t.*detail::result<T>::value)();
}
0

Source: https://habr.com/ru/post/1678150/

More articles:


All Articles