How to convert anything to string implicitly?

Question

My goal is to design a String class that decorates std::string in order to provide some functionality my program needs. One functionality I want to add is the ability to convert anything to my String implicitly in order to save some typing.

In order to achieve the implicitly conversion I designed the following class:

std::ostream& operator<<(std::ostream& o, const String& s);

class String {
public:
    template<typename t_value>
    String::String(t_value value) {
       std::ostringstream oss;
       oss << value;
      _str = oss.str();
    }
private:
    std::string _str;
}

This works fine with any type that has the <<operator defined. The problem came up with any class that doesn't have the stream operator. A compiler error would be fine but what I got is an infinity recursion since C++ tries to use my global << operator to try to convert to my String type.

My primary objective is to code like this

class Foo {
    int _memberWithUnderscoreInName;
}

String s = Foo();

And get a compiler error instead of an infinite loop in the constructor.

Is there a simple solution for this?

This is not related to your question and I may be wrong, but aren't names starting with an underscore considered bad practice? — Adri C.S., Sep 02 '13 at 14:45
I take it this is is specifically to avoid having to type `to_` in `to_string()` of C++11? — Mats Petersson, Sep 02 '13 at 14:49
There's not wrong with std::stringstream, but again, I want a convenience way to convert anything to my string so I can save some typing when building log messages and GUI strings. — McLeary, Sep 02 '13 at 14:54
There seems to be a bit of discussion on the [underscore topic](http://stackoverflow.com/questions/228783/what-are-the-rules-about-using-an-underscore-in-a-c-identifier), but single leading underscores are at least not reserved as long as they are not followed by an uppercase letter. — Hulk, Sep 02 '13 at 14:54
@AdriC.S.: Such names are fine, as long as they're not in the global namespace, and there's only one underscore, not followed by an upper-case letter. The gory details are discussed [here](http://stackoverflow.com/questions/228783) if you're interested. — Mike Seymour, Sep 02 '13 at 14:57

Mike Seymour · Accepted Answer · 2013-09-02T16:01:48.990

Instead of declaring the output operator in the surrounding namespace, only declare it as a friend of the String class:

class String {
public:
    // This must be implemented inline here
    friend std::ostream& operator<<(std::ostream& o, const String& s) {
        return o << _str; // for example
    }

    template<typename t_value>
    String(t_value value) {
       std::ostringstream oss;
       oss << value;
      _str = oss.str();
    }
private:
    std::string _str;
};

Now it can only be found by argument-dependent lookup, and so will only be considered if the second argument really is of type String, not just convertible to it. Therefore, it won't be considered as a candidate for os << value in the constructor, giving a compile error rather than a run-time death spiral if there is no other candidate.

score 2 · Answer 2 · 2013-09-02T16:14:52.903

This or similar should fix it:

namespace HasFormattedOutput {

    namespace Detail
    {
        struct Failure{};
    }

    template<typename OutputStream, typename T>
    Detail::Failure operator << (OutputStream&, const T&);

    template<typename OutputStream, typename T>
    struct Result : std::integral_constant<
        bool,
        ! std::is_same<
            decltype((*(OutputStream*)0) << std::declval<T>()),
            Detail::Failure
        >::value
    > {};
} // namespace HasFormattedOutput

template <typename T, typename OutputStream = std::ostream>
struct has_formatted_output
:   HasFormattedOutput::Result<OutputStream, T>
{};

class X  {
    public:
    X() {}

    template <typename T>
    X(const T& t) {
        static_assert(
             has_formatted_output<T>::value, 
             "Not supported type.");
        std::ostringstream s;
        s << t;
        str = s.str();
    }

    private:
    std::string str;
};
std::ostream& operator << (std::ostream& stream, const X&) { return stream; }

struct Y  {
    Y() {}
};

int main() {
    Y y;
    X x(y);
    return 0;
}

Despite your solutions works and avoids the infinite loop, it doesn't raise a compiler error by default and it is quite complex compared with declaring the `operator <<` as `friend`. — McLeary, Sep 02 '13 at 15:53
@McLeary You might consider the static_assert as mentioned in the example. — , Sep 02 '13 at 15:59
I agree, but as I said, I prefer a default compiler error rather than force one. This example works fine (I tested), but I prefer the simpler one. — McLeary, Sep 02 '13 at 16:04

How to convert anything to string implicitly?

2 Answers2

Linked