C ++模板参数默认功能实现

Question

I have a set of classes that are used as parameters to templates. They all conform to some informal interface ( aka a concept )

template <typename T>
int func( T& t ) { return t.a() + t.b() + t.c(); }

In this example, le'ts say I instantiate templates with Foo or Bar as parameters, so they must implement methods a b and c .

struct Foo { int a(); int b(); int c(); };
struct Bar { int a(); int b(); int c(); };

Now, I have a lot of these classes, and I would like to have a default implementation of one of the functions in terms of the others.

For example, I want c to return the difference between a() and b() by default. So I wish that it would be enough that I define a() and b() and c() would automatically implemented as int c() { return a()- b();} without having to copy this code for all classes.

I used to achieve this result with polymorphism ( by defining a() and b() as pure virtual functions in a base class with a default (virtual) implementation of c() ), but I moved away from this mechanism for performance reasons.

I would like to know if there is a recommended solution to attain this kind of result (ie write the default implementation once) with my template parameter classes.

Answer 1

I would be tempted to steal a page from std::begin .

CRTP is great, but it requires every structure modify itself to handle your requirement of having a c. And really, the code for c is your problem, not the problem of the data you are being fed.

Naturally you'll want zero-overhead, which both CRTP and this approach pulls off.

So instead, we conditionally call .c() or we call .a()+.b() depending on its existence. Here are two approaches:

Create a free function c :

template<class T, class...Ignored>
decltype(auto) c(T& t, Ignored&&...)

It dispatches to two implementations:

{
  auto which = has_c_method<T>;
  return details::c(which{}, t);
}

Where has_c_method is a traits bool type that detects if the type passed has a .c() method. (I write one below).

In namespace details:

namespace details{
  template<class T>
  auto c(std::false_type, T&){
    return t.a()-t.b();
  }
  template<class T>
  auto c(std::true_type, T&){
    return t.c();
  }
}

and we are good. Also note that if there is a free non-variadic function c(t) in t s namespace, it will be preferred (that is what Ignored does).

You do have to write that traits class, but many SO answers cover that.

A better name than c is advised. ;)

This design has the advantage of not forcing people writing your target types to get in on the action. You simply access either tc() or ta()+tb() depending on if tc() is defined.

---

Now we could approach this from an even more generic direction. We don't create a c function that dispatches for us, instead...

We write a compile-time branch:

namespace details {
  template<bool>
  struct branch {
    template<class T, class F_true, class F_false>
    std::result_of_t<F_true(T)> operator()( T&&t, F_true&&f, F_false&&){
      return decltype(f)(f)(decltype(t)(t));
    }
  };
  template<>
  struct branch<false> {
    template<class T, class F_true, class F_false>
    std::result_of_t<F_false(T)> branch( T&& t, F_true&&, F_false&&f){
      return decltype(f)(f)(decltype(t)(t));
    }
  };
}
template<template<class...>class Z, class T, class F_true, class F_false>
auto branch( T&& t, F_true&& f_true, F_false&& f_false )
-> decltype( details::branch<Z<T>{}>{}(std::declval<T>(), std::declval<F_true>(), std::declval<F_false>() )
{
  return details::branch<Z<T>{}>{}(decltype(t)(t), decltype(f_true)(f_true), decltype(f_false)(f_false) );
}

no false case:

template<template<class...>class Z, class T, class F_true>
void branch( T&& t, F_true&& f_true )
{
  branch( std::forward<T>(t), std::forward<F_true>(f_true), [](auto&&){} );
}

use:

int c = branch<has_c_method>(
  t,
  [&](auto& t){ return t.c(); },
  [&](auto& t){ return t.a()-t.b(); }
);

which lets you do this a bit more ad-hoc.

branch<template>( arg, if_true, if_false ) evaluates template on the type (including r/l value qualification of) arg . If an instance of the type resulting returns true within a constexpr context, if_true is run. If it returns false within a constexpr contest, if_false is run.

In both cases, the arg is passed to the selected lambda.

Together with auto lambda support from C++14, this lets you write code that is conditionally compiled with relative brevity.

The unrun lambda is just an uninstantiated template. The run lambda is instantiated with an instance of arg. So the unrun lambda need not contain valid code for the case where it isn't selected.

The type of the branch is actually statically selected between the two options; they can actually return different types. No conversion is done.

The if_false-less overload of branch returns void , as I am lazy and I don't see much use.

---

Here is a sketch of has_c_method written with mostly generic code.

namespace details {
  template<template<class...>class Z, class, class...Ts>
  struct can_apply_helper:
    std::false_type
  {};
  template<template<class...>class Z, class...Ts>
  struct can_apply_helper<Z, std::void_t<Z<Ts...>>, Ts...>:
    std::true_type
  {};
}
// is true_type iff Z<Ts...> is valid:
template<template<class...>class Z, class...Ts>
using can_apply = typename details::can_apply_helper<Z, void, Ts...>::type;

// return type of t.c(args...).  Easy to write
// and with the above, makes has_c_method a one-liner:
template<class T, class...Args>
using c_method_result = decltype(std::declval<T>().c(std::declval<Args>()...));

template<class T, class...Args>
using has_c_method = can_apply<c_method_result, T, Args...>;

there is a proposal to add something very much like can_apply to std .

---

Note my non-idiomatic use of decltype(x)(x) above. This is equivalent to std::forward<X>(x) in a context where X is a forwarding reference, and also works within auto&& parameter lambdas. It means "cast x to the type it was declared with". Note that if x is a value (non-reference) type, it will duplicate it (which is a reason to prefer forward, which never does that): this, however, is not the case in any of my above decltype(x)(x) uses.

Answer 2

What about using CRTP to provide the default implementation to classes that inherit from it:

template <typename Child>
class DefaultC
{
public:
    int c() { Child& this_obj = static_cast<Child&>(*this); return this_obj.a()- this_obj.b();}
};

Then:

struct Foo : public DefaultC<Foo> { int a(); int b(); };

(and as a note if your functions are non-mutating please mark them const)

Answer 3

I would first try CRTP:

template < typename Derived >
struct subtract
{
    int c() const
    {
        auto this_ = static_cast<Derived const*>(this);
        return this_->a() - this_->b();
    }
};

struct whatnot : subtract<whatnot>
{
    int a() const { return 42; }
    int b() const { return 666; }
};

Answer 4

A version, inspired by Kerrek's one on comments, but using std::true_type and std::false_type

#include <iostream>
#include <type_traits>

struct Foo {
    int a() { return 10; }
    int b() { return 20; }
    int c() { return 30; }
};

struct Bar {
    int a() { return 8; }
    int b() { return 3; }
};

template<typename T, typename = void>
struct has_c : std::false_type {
    static int call(T t) { return t.a() - t.b(); }
};

template<typename T>
struct has_c<T, decltype(std::declval<T>().c(), void())> : std::true_type {
    static int call(T t) { return t.c(); }    
};

template <typename T>
int f(T&& t) {
    return has_c<T>::call(std::forward<T>(t));
}

int main()
{
    Foo foo;
    Bar bar;

    std::cout << f(foo) << "\n";
    std::cout << f(bar) << "\n";

    return 0;
}

Live on Coliru