CODEWITHSUNDEEP
c++templatesc++17ctad
user11589013
user11589013

Reputation: 47

Template argument deduction fails when using braced initializer list

I'm trying to use template argument deduction in the 'perpendicular()' function:

#include <iostream>

template <typename component = double>
struct offset {
  component x;
  component y;
};

template <typename component>
offset(component x, component y) -> offset<component>;

template <typename component>
offset<component> perpendicular(offset<component> const &o) {
  return offset{o.y, -o.x};
}

template <typename component>
std::ostream &operator<<(std::ostream &s, offset<component> const &o) {
  return s << '(' << o.x << ", " << o.y << ')';
}

int main() {
  std::cout << perpendicular({3.1, 1.2}) << '\n';
  return 0;
}

This however doesn't compile; Clang (with -std='c++17') says: candidate template ignored: couldn't infer template argument 'component' offset<component> perpendicular(offset<component> const &o) {.

Should I resign to writing perpendicular(offset{1.0, 2.0}) or is there a way to give the compiler a hint?

Upvotes: 3

Views: 943

Answers (3)

super
super

Reputation: 12928

One option is to add an overload to perpendicular that takes two values.

template <typename component>
offset<component> perpendicular(component v1, component v2) {
    return {v2, -v1};
}

This could also be made more generic with parameter packs, possibly combined with std::common_type.

Upvotes: 0

sweenish
sweenish

Reputation: 5192

Jarod42's answer gives you the syntax you want, but I subjectively think it's not ideal. You originally wanted to pass in an offset, but now you are passing an array and turning it into an offset. It's a weird relationship of types.

Instead of a struct and separate functions, just put it all into an Offset class. It's not really any extra work, and makes for better C++. What you have is more akin to object-oriented C. 

#include <iostream>

// Create a self-contained class
template <typename Component = double>
class Offset {
 public:
  Offset(Component x, Component y) : x(x), y(y) {}

  // No longer requires function parameters
  Offset const perpendicular() const { return Offset(y, -x); }

  // I appreciate your use of east const
  friend std::ostream& operator<<(std::ostream& sout,
                                  Offset<Component> const& o) {
    return sout << '(' << o.x << ", " << o.y << ')';
  }

 private:
  Component x;
  Component y;
};

int main() {
  // Subjectively much cleaner to read and understand
  std::cout << Offset{3.1, 1.2}.perpendicular() << '\n';
  return 0;
}

For future reference, can use decltype(auto) as your return type and forego the trailing return type syntax altogether as of C++14.

Upvotes: 0

Jarod42
Jarod42

Reputation: 217065

Issue with {/*..*/} is that it has no type, and can mostly only be deduced as std::initializer_list<T> or T[N].

So following would allow desired syntax:

template <typename component>
offset<component> perpendicular(component const (&o)[2]) {
    return offset{o[1], -o[0]};
    // return perpendicular(offset{o[0], o[1]});
}

Demo

Upvotes: 3

Related Questions