Specializations of forwarding template functions

Funny how sometimes just after having studied a subject one finds cases that let themselves treat with it, but maybe it’s just me being a man with a hammer. Anyway, in my previous post I wrote about rules that give c++ the perfect forwarding mechanism and today I would like to look at a particular dark corner, namely, I will try to specialize forwarding function templates.

Suppose that you wanted to have a function template whose signature is a perfectly forwarding one:

class probe;

    template<class T>
struct wrapper;

    template<class T>
auto produce_wrapped(T&& t) -> wrapper<T>;

Let me start by fixing the obvious straight away. In case T is inferred as l-value reference, the result is not going to be what you likely want. Similarly with cv-qualification, you’d probably want wrapped<probe> rather than wrapped<const probe> or wrapped<const probe&>. So you need to remove the reference and remove the cv-qualification. You can do that either by applying to T both the remove_cv and remove_reference traits, or, in future C++20, by applying remove_cvref, or, if you agree to not look the way of pointers and arrays, by applying decay. So we really start with

class probe;

    template<class T>
struct wrapper;

    template<class T>
auto produce_wrapped(T&& t) -> wrapper<std::decay_t<T>>;

Now, let’s think at how we could specialize produce_wrapped. Why specialize and not overload, use specialized traits from the template or whatever else? Well, chiefly because it’s interesting on its own, and by way of extenuation I can cite a case where there are many probe classes, in the hundreds, that have befriended the produce_wrapped template which, in turn, now needs to peek into the bowels of the object before forwarding it. And there’s no talk of touching hundreds of files at once.

  template<class T>
struct wrapper;

  template<class T>
auto produce_wrapped(T&& t) -> wrapper<std::decay_t<T>>;

class probe
  {
    std::string s_;
  public:
    probe(std::string s) : s_(std::move(s)) {}
    template<class T> friend auto produce_wrapped(T&&) -> wrapper<std::decay_t<T>>;
  };

class guinnea_pig
  {
    int x_;
  public:
    guinnea_pig(int x) : x_(x) {}
    template<class T> friend auto produce_wrapped(T&&) -> wrapper<std::decay_t<T>>;
  };


    template<class T>
struct wrapper
  {
  T t_;
  bool good_ = false;
  };

So now let’s say that good probe objects have strings shorter than 100, good guinnea_pig objects have odd ints, and let’s log what’s inside. Since the logic is different, we won’t do that in the principal template but in specializations. We also cannot delegate the work to some traits, as it is only this particular function template that can access the necessary data.

But how do we actually write that (necessarily full) specialization? There’s no template parameter T to be used on the parameters’ list or in the std::forward call. That should not come as a surprise, as the compiler will first produce a candidate function by using the principal template definition, make all the type substitutions, and only then look if there is a specialization. We have to start with empty template<> and then write everything by hand. We know all the necessary rules from the previous post, but I think it will be instructive to go slow now, and study an example call:

auto foo(const probe& p) -> void
  {
  produce_wrapped(p);
  }

What will be the compiler’s reasoning here? p is an l-value reference to const of type probe, so, according to the special rule for the r-value reference pattern in template function argument, substitution in the principal template will infer T as const probe& and the reference collapsing rule will turn T&& into the same const probe&. And that’s what we need to give to the specialization:

    template<>
auto produce_wrapped(const probe& t) -> wrapper<probe>
  {
  return {t, t.s_.size() < 100};
  }

No need to decay your const probe& if you can just write what is needed. Apparently, there’s enough information here for the compiler to figure out that this is a specialization for T equal to const probe&, but if you want to be verbose, you can say

    template<>
auto produce_wrapped<const probe&>(const probe& t) -> wrapper<probe>
  {
  std::cerr << t.s_ << "\n";
  return {t, t.s_.size() < 100};
  }

But l-value references to const are boring, and it’s not what forwarding is about, we want r-values, you’ll say. So, let’s do r-values.

auto foo(const probe& p) -> void
  {
  produce_wrapped(p);
  }
auto main(void) -> int
  {
  probe p("regular probe");
  foo(p);
  produce_wrapped(probe("rvalue probe"));
  return 0;
  }

When the compiler sees this code, it will infer T to be probe and T&& to be probe&&. But there is no such specialization, so there’s a linker error on missing symbol definition. Ah then, we have to write that specialization separately.

    template<>
auto produce_wrapped(probe&& t) -> wrapper<probe>
  {
  std::cerr << t.s_ << "\n";
  return {std::move(t), t.s_.size() < 100};
  }

Again, if you want to be verbose, you can put produce_wrapped<probe> explicitly. So we are done, you might think. Until you try the next call

auto foo(const probe& p) -> void
  {
  produce_wrapped(p);
  }
auto main(void) -> int
  {
  probe p("regular probe");
  foo(p);
  produce_wrapped(probe("rvalue probe"));
  produce_wrapped(p);                     // doesn't link
  return 0;
  }

Why doesn’t it link? When you overload functions and you have a version for const type& (but no version for type&), you can call it with non-const objects as the reference to const can bind to the non-const object, and the overload resolution will select it. In our case, however, overload resolution works on the principal template level instantiated with probe& for both T and T&&. And there is no code for such a specialization, we have to provide yet another one.

    template<>
auto produce_wrapped(probe& t) -> wrapper<probe>
  {
  std::cerr << t.s_ << "\n";
  return {t, t.s_.size() < 100};
  }

So we’re done, you may think, three verbose specializations for a perfect forwarding in this setup. And if you’re doing moderately reasonable things, you may be right, but I am after perfect forwarding, and this is the place things go zonkers. Remember the expression `cv-qualified’? Well, there’s four of these and they combine with two distinct reference types, l-value and r-value, which leaves us with eight necessary boilerplate specializations to cover all the cases. And keep in mind that the cv-qualified references come with a lovely diamond-shaped reference-will-bind-to dependence diagram (and, you know, in c++ diamonds are forever), and to complete the tangle, special rules for binding const (but not volatile) l-value references. Even the standard ends up by going bananas about it. Let me write one of the specializations:

    template<>
auto produce_wrapped(const volatile probe& t) -> wrapper<probe>
  {
  const std::string& psr = const_cast<const probe&>(t).s_;
  std::cerr << psr << "\n";
  return {t, psr.size() < 100};
  }

String has no operations that would work on volatile objects so one has to cast even for the simplest things. And for that to even compile, you’d have to complete probe with copy constructors that would unambiguously cover all the calls, and the dependencies do not make it all that easy, for instance if you have probe(const probe&) and probe(const volatile probe&), then they will compete for a call with probe&, you need another one (but they will not compete for a probe&& call, const probe& will be selected, go figure). To You probably don’t care about the vileatile qualification or about const r-value references, but I’m just trying to be perfect, that is, provide a forwarding mechanism regardless of other considerations, and probe‘s constructor is out of immediate scope.

And there’s another shortfall with probe, in that it befriends the entire produce_wrapped template, even for unrelated types, that is, for instance produce_wrapped<guinnea_pig> is friend to probe. If we tried to be well behaved and do as the common advice says, we would have to make friend the particular specializations, and yes, all the eight separately. It’s a rule-of-eight that emerges here, eight specializations, eight friends, eight constructors, lots, lots of code.

But what are the alternatives, if, after all, we were allowed to change the friend declaration in the many probe classes to suit our design? Putting that in different terms, what are the ways to perfectly forward values of a single type, as opposed to writing a greedy template? I can offer two designs that seem to work. One would be to actually overload produce_wrapped_overload, but since for forwarding we need the argument to be a template, we would need to SFINAE-enable every overload for just the type it was designed for:

class probe
  {
    std::string s_;
  public:
    probe(std::string s) : s_(std::move(s)) {}
    template<class T> friend auto produce_wrapped_overload(T&&)
    -> std::enable_if_t
         <
         std::is_same<std::decay_t<T>, probe>::value, 
         wrapper<std::decay_t<T>>
         >;
  };
  
class guinnea_pig
  {
    int x_;
  public:
    guinnea_pig(int x) : x_(x) {}
    template<class T> friend auto produce_wrapped_overload(T&&)
    -> std::enable_if_t
         <
         std::is_same<std::decay_t<T>, guinnea_pig>::value, 
         wrapper<std::decay_t<T>>
         >;
  };
  
    template<class T> 
auto produce_wrapped_overload(T&& t)
    -> std::enable_if_t
         <
         std::is_same<std::decay_t<T>, probe>::value, 
         wrapper<std::decay_t<T>>
         >
  {
  using underlying = std::remove_volatile_t<std::remove_reference_t<T>>;
  using workable = std::conditional_t<std::is_lvalue_reference<T>::value,
                                      std::add_lvalue_reference_t<underlying>,
                                      std::add_rvalue_reference_t<underlying>
                                     >;
  workable tr = const_cast<workable>(t);
  const auto& psr = tr.s_;
  std::cerr << psr << "\n";
  return {std::forward<T>(t), psr.size() < 100};
  }

    template<class T> 
auto produce_wrapped_overload(T&& t)
    -> std::enable_if_t
         <
         std::is_same<std::decay_t<T>, guinnea_pig>::value, 
         wrapper<std::decay_t<T>>
         >
  {
  using underlying = std::remove_volatile_t<std::remove_reference_t<T>>;
  using workable = std::conditional_t<std::is_lvalue_reference<T>::value,
                                      std::add_lvalue_reference_t<underlying>,
                                      std::add_rvalue_reference_t<underlying>
                                     >;
  workable tr = const_cast<workable>(t);
  const auto& psr = tr.x_;
  std::cerr << psr << "\n";
  return {std::forward<T>(t), bool(psr % 2)};
  }

There’s the additional hops to make it work for the most general case when T is cv-qualified in any possible sense, and it is not as straightforward since the standard trait remove_volatile only removes it from an actual type and not from a reference to said type. Your compile times are going to take a hit, though, since at every call every overload will have to be tried and only one will survive. Another approach would be to use a traits class:

    template<class T>
struct forwarding_trait;

class probe
  {
    std::string s_;
  public:
    probe(std::string s) : s_(std::move(s)) {}
    friend class forwarding_trait<probe>;
  };
  
class guinnea_pig
  {
    int x_;
  public:
    guinnea_pig(int x) : x_(x) {}
    friend class forwarding_trait<guinnea_pig>;  
  };

    template<class T>
using non_vola_ref = std::conditional_t
  <
  std::is_lvalue_reference<T>::value,
  std::add_lvalue_reference_t<std::remove_volatile_t<std::remove_reference_t<T>>>,
  std::add_rvalue_reference_t<std::remove_volatile_t<std::remove_reference_t<T>>>
  >;

    template<>
struct forwarding_trait<probe>
  {
      template
        <
        class T, 
        class = std::enable_if_t<std::is_same<probe, std::decay_t<T>>::value>
        >
  static auto process(T&& t) -> wrapper<probe>
    {
    const auto& tr = const_cast<non_vola_ref<T>>(t);
    const auto& psr = tr.s_;
    std::cerr << psr << "\n";
    return {std::forward<T>(t), psr.size() < 100};
    }
  };

    template<>
struct forwarding_trait<guinnea_pig>
  {
      template
        <
        class T, 
        class = std::enable_if_t<std::is_same<guinnea_pig, std::decay_t<T>>::value>
        >
  static auto process(T&& t) -> wrapper<guinnea_pig>
    {
    const auto& tr = const_cast<non_vola_ref<T>>(t);
    const auto& psr = tr.x_;
    std::cerr << psr << "\n";
    return {std::forward<T>(t), bool(psr % 2)};
    }
  };

    template<class T>
auto produce_wrapped_trait(T&& t) -> wrapper<std::decay_t<T>>
  {
  return forwarding_trait<std::decay_t<T>>::process(std::forward<T>(t));
  }

There’s also enable_if inside, but it is just a safety measure, to prevent you from calling forwarding_trait<T>::process with objects of unrelated class U. Otherwise, the compiler will know precisely where to look for your specialization. Wonder if there is other, do you happen to know or can comment on it otherwise?

PS. WordPress now has an editor that plays tricks with angle brackets, so I write my posts in a plain text editor. The c++ brackets then need to be converted to html entities, but brackets on known html tags must not. If you ever need to do the same, here’s my sed, just complete the list of allowed html tags (here a, em, code) if you need:

sed 's/<\(\/\)\?\(a\|em\|code\)\([^<>]*\)>/\x02\1\2\3\x03/g;s/\&/\&amp;/g;s/</\&lt;/g;s/>/\&gt;/g;s/\x02/</g;s/\x03/>/g'

An expressive language they are, regexes, should recall next time I moan about the intricacies of c++.

Advertisements

6 Responses to Specializations of forwarding template functions

  1. Adam Badura says:

    Just a minor thing – in the “const volatile probe& t” overload example the argument name (“t”) doesn’t match other overloads (which use “p”) while the implementation still uses “p” variable.

    • ljwo says:

      Thanks, corrected that, also added bool() to the guinnea_pig aggregate construction calls. WordPress ate my sed in the process, had to rework all the html entities for it to display, hey, it got to a point where it is nearly useless as a programming blog environment.

  2. Adam Badura says:

    I don’t quite follow on the linking problems. Why missing specialization would lead to linker issues? Shouldn’t base template version be picked up instead? Or is it with an assumption that now there is no “default” base template version?

    • ljwo says:

      That’s right, there is only a declaration and no definition for the principal template. What would you put in the definition anyway? My compilers think there might be a specialization somewhere else and let the linker protest. I don’t have a citation from the standard ready to support that, except maybe for this: “When writing a specialization, be careful about its location; or to make it compile will be such a trial as to kindle its self-immolation.”

  3. 박재영 says:

    I think we could simplify more this problem. What we want to specialize is to determine the value is good or not for certain types. This operation doesn’t need ownership of the value so we can only consider const reference. That fact leads us to only 2 overloaded functions for each case.

    bool is_good(const volatile probe& v) {
    const std::string& psr = const_cast<const probe&>(v).s_;
    return psr.size() > 100;
    }

    bool is_good(const probe& v) {
    return v.s_.size() > 100;
    }

    template<class T>
    auto produce_wrapped(T&& t) -> wrapper<std::decay_t<T>> {
    auto good = is_good(t);
    return { std::forward<T>(t), good };
    }

    I wonder your opinion on this approach.

    • ljwo says:

      Yes, that would work for the task that I described, provided that you can befriend both of your is_good overloads in every probe class that you need, and that you want to make them public, even though they might be seen as implementation details. But still, I think that to consider what would be the consequences of wanting to fully support forwarding, but make the implementation type by type was an interesting topic for a post. (Had to correct your comment, wordpress ate your angle brackets too, hope it’s what you meant. It’s getting closer and closer to and end, me and wordpress.)

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

This site uses Akismet to reduce spam. Learn how your comment data is processed.

%d bloggers like this: