ostream and operator std::basic_string, std::allocator>?

Question

from the answer, I learned std::string is just typedef of std::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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.

Now I substitute std::basic_string, std::allocator> for std::string:

class Rectangle
{
public:
    Rectangle(double x, double y) : _x(x), _y(y) {}
    operator std::basic_string<char, std::char_traits<char>, std::allocator<char>> () {
        return std::basic_string<char, std::char_traits<char>, std::allocator<char>>(to_string(_x) + " " + to_string(_y));
    }
    //operator double() {
    //  return _x;
    //}
private:
    double _x, _y;
    double getArea() { return _x * _y; }
};

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

It still fails. Why?

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);

you can define `std::ostream& operator<< (std::ostream& stream, const Rectangle& rectangle)` or use `cout << (string)r` — apple apple, Nov 09 '17 at 11:51

score 3 · Accepted Answer · answered Nov 09 '17 at 11:43

3

Now I substitute std::basic_string, std::allocator> for std::string:
It still fails. Why?

You misunderstood the original problem. It wasn't because you used std::string instead of the direct std::basic_string<char, std::char_traits<char>, std::allocator<char>>. A typedef is just another name for an existing type. Your two conversion operators are exactly the same. You can verify that by trying to place them both in the class definition, it will cause a redefinition error.

Both aren't taken into account when resolving the overloads for operator<<, because conversions aren't applied to template function ordering.

answered Nov 09 '17 at 11:43

StoryTeller - Unslander Monica

165,132
21
377
458

Is there corresponding text in the standard? I tried to parse through overload resolution and templates, but couldn't find any. – Incomputable Nov 09 '17 at 11:53
1

@Incomputable - It's a combo of [\[temp.over\]/1](https://timsong-cpp.github.io/cppwp/n4659/temp.over#1) and something in [\[temp.deduct\]](https://timsong-cpp.github.io/cppwp/n4659/temp.deduct), which I'm having difficulty pinpointing at the moment. – StoryTeller - Unslander Monica Nov 09 '17 at 12:00
@Incomputable - [Aha, it's paragraph 4](https://timsong-cpp.github.io/cppwp/n4659/temp.deduct#call-4). – StoryTeller - Unslander Monica Nov 09 '17 at 12:01
It's still completely non-obvious though :) – Incomputable Nov 09 '17 at 12:02
@Incomputable - Wouldn't be the C++ we know and love if it was obvious, would it? :) – StoryTeller - Unslander Monica Nov 09 '17 at 12:03
Yeah, that's probably the gist of C++. Thanks for finding the right part of the standard, perhaps I need to read it every evening. – Incomputable Nov 09 '17 at 12:05

score 2 · Answer 2 · answered Nov 09 '17 at 11:54

Overload resolution first finds a set of possible functions to call. In this phase template deduction is performed to see if a template is a possible candidate.

Then, if more than one function is found, conversion functions are considered when trying to find the closest match among the candidates.

In your case, the operator taking a std::string is never considered as the compiler cannot deduce CharTetc from Rectangle.

A solution is to skip the conversion operator and instead add an operator<< for Rectangle. Inside that you can just call os << to_string(... etc.

ostream and operator std::basic_string, std::allocator>?

2 Answers2