Unclear use of operator double()

Question

I have a Rectangle class with conversion operators to both double and std::string:

class Rectangle
{
public:
    Rectangle(double x, double y) : _x(x), _y(y) {}
    operator std::string ();
    operator double ();
private:
    double _x, _y;
    double getArea() {return _x * _y;}
};

int main()
{
    Rectangle r(3, 2.5);
    cout << r << endl;
    return 0;
}

I don’t understand why operator double() is invoked, rather than operator std::string(). As far as I know, according to C++ wikibook, operator double is used to convert Rectangle objects to double.

So what's going on here? Is it related to the fact that an int is passed to the constructor? If so, why?

@AlexGoft No, the other Alex meant “what does it mean *logically*?”. On the face of it, the operation seems meaningless. — Konrad Rudolph, Sep 16 '15 at 12:26
I suspect he intended it to mean the area, since there is no other reason to have included the ``getArea()`` function in the sample. — Zac Crites, Sep 16 '15 at 17:14

NathanOliver · Accepted Answer · 2015-09-16T13:12:15.910

13

You do not have an operator to output the rectangle to the stream. cout does have an overload that takes a double and your class can be implicitly converted to a double so that is chosen.

The reason the string overload is not selected and is not considered as an ambiguity is because operator << for a string is a member function and is not included in the member overload and non member overload set of cout. If we comment out the operator double we can see we get a compiler error.

If we want to have the operator string called then we would need to explicitly cast r into a string. Live Example

edited Sep 16 '15 at 13:12

answered Sep 16 '15 at 12:13

NathanOliver

171,901
28
288
402

3

Then why doesn't it pick the `string` conversion? – interjay Sep 16 '15 at 12:15
@interjay I was just looking into that. I didn't see that operator when I wrote the answer, – NathanOliver Sep 16 '15 at 12:16
6

Nice catch. If one wanted to explain why implementing `operator double()` on types that do not represent a number is a bad practice, he would be hard pressed to find a better illustration :-) – Sergey Kalinichenko Sep 16 '15 at 12:18
`std::ostream::operator<<(double)` is preferred over `std::basic_string::operator(basic_ostream&, const basic_string&)` – Simon Kraemer Sep 16 '15 at 12:22
@SimonKraemer It's not that one is preferred over the other, it's that the other is simply never considered. – Oktalist Sep 16 '15 at 14:00

Oktalist · Answer 2 · 2015-09-16T14:04:59.007

Since you did not provide an operator<< overload for Rectangle, the compiler considers other overloads for which the arguments can be converted to the parameter types.

If any of the overloads are templates, then template argument substitution happens to them before overload resolution. The compiler tries to deduce the template parameters from the types of the arguments supplied to the function.

The string overload is not considered because of a template argument substitution failure:

template <class CharT, class Traits, class Allocator>
std::basic_ostream<CharT, Traits>&
    operator<<(std::basic_ostream<CharT, Traits>& os,
               const std::basic_string<CharT, Traits, Allocator>& str);

Template argument substitution does not consider user-defined conversions, so the compiler can't deduce the types CharT, Traits, or Allocator from the type Rectangle, so this overload does not participate in overload resolution. (Recall that std::string is just a typedef of std::basic_string<char, std::char_traits<char>, std::allocator<char>>.)

Therefore there is one overload of operator<< which is a better match than any other, and that is the double overload. Not a template, but a member function of a class template.

basic_ostream<CharT, Traits>& basic_ostream<CharT, Traits>::operator<<(double);

Note that the last template is trivial; `std::cout` inherits from `std::basic_ostream>`. There's no need for template argument substitution. — MSalters, Sep 16 '15 at 14:27

score 0 · Answer 3 · edited Jan 16 '19 at 12:02

0

There is nothing special about double-overloading than other primitive types overloadings. In this case, it is the only primitive overload available. The compiler will behave the same for int, char, etc..

Notice that if we would have more than one primitive type overload the compiler will throw

error: ambiguous overload for 'operator<<' ...

edited Jan 16 '19 at 12:02

Prakash Pazhanisamy

997
1
15
25

answered Jan 16 '19 at 10:57

AmirArbel

41
3

Unclear use of operator double()

3 Answers3

Linked