boost::format and custom printing a std containers

Question

I have a function in my namespace ns that helps me print STL containers. For example:

template <typename T>
std::ostream& operator<<(std::ostream& stream, const std::set<T>& set)
{
    stream << "{";
    bool first = true;
    for (const T& item : set)
    {
        if (!first)
            stream << ", ";
        else
            first = false;
        stream << item;
    }
    stream << "}";
    return stream;
}

This works great for printing with operator << directly:

std::set<std::string> x = { "1", "2", "3", "4" };
std::cout << x << std::endl;

However, using boost::format is impossible:

std::set<std::string> x = { "1", "2", "3", "4" };
boost::format("%1%") % x;

The problem is fairly obvious: Boost has no idea that I would like it to use my custom operator << to print types which have nothing to do with my namespace. Outside of adding a using declaration into boost/format/feed_args.hpp, is there a convenient way to make boost::format look for my operator <<?

I strongly suggest you take a look at [this question](http://stackoverflow.com/q/4850473/500104), since it basically answers your needs. I won't vote to close as a duplicate, though, since your actual question is different (about the `operator<<`). — Xeo, May 30 '12 at 00:41
@Xeo: My actual code uses a very similar approach to printing any container. Anyway, the issue isn't how to print a container with `operator <<`, it is how to make that same overload work for things where Koenig does not do what I want. — Travis Gockel, May 30 '12 at 04:51

score 5 · Answer 1 · answered Oct 03 '12 at 13:57

The solution I actually went with is quite similar to Answeror's, but it works for anything:

namespace ns
{

template <typename T>
class FormatWrapper
{
public:
    explicit FormatWrapper(const T& x) :
            ref(x)
    { }

    friend std::ostream& operator<<(std::ostream& stream,
                                    const FormatWrapper<T>& self
                                   )
    {
        // The key is that operator<< is name lookup occurs inside of `ns`:
        return stream << self.ref;
    }
private:
    const T& ref;
};

template <typename T>
FormatWrapper<T> Formatable(const T& x)
{
    return FormatWrapper<T>(x);
}

}

So usage is:

boost::format("%1%") % Formatable(x);

score 4 · Accepted Answer · answered Oct 03 '12 at 09:14

I think the most clean way is to provide a thin wrapper in your own namespace for each of the operators you want to override. For your case, it can be:

namespace ns
{
    namespace wrappers
    {
        template<class T>
        struct out
        {
            const std::set<T> &set;

            out(const std::set<T> &set) : set(set) {}

            friend std::ostream& operator<<(std::ostream& stream, const out &o)
            {
                stream << "{";
                bool first = true;
                for (const T& item : o.set)
                {
                    if (!first)
                        stream << ", ";
                    else
                        first = false;
                    stream << item;
                }
                stream << "}";
                return stream;
            }
        };
    }

    template<class T>
    wrappers::out<T> out(const std::set<T> &set)
    {
        return wrappers::out<T>(set);
    }
}

Then use it like this:

std::cout << boost::format("%1%") % ns::out(x);

This is very similar to the solution I actually used. I have posted my solution as well. — Travis Gockel, Oct 03 '12 at 13:59

yuyoyuppe · Answer 3 · 2012-08-19T09:45:54.610

1

You can try something like this:

namespace boost // or __gnu_cxx
{
    using np::operator<<;
}
#include <boost/format/feed_args.hpp>

edited Aug 19 '12 at 09:45

answered Aug 18 '12 at 23:35

yuyoyuppe

1,582
2
20
33

score 0 · Answer 4 · answered Aug 23 '12 at 15:37

The problem as already noted is because of ADL (argument dependent lookup - often attributed to Andrew Koenig, but I believe he shouldn't get all the blame).

Even in your local context it wouldn't work in a template function where you intend to use your operator<<.

One cheating trick is to put the operator<< you define into namespace std. That is verboten, but it might work in your case, but only if it is put before its usage and that might be the problem.

There might be further options, such as defining your own Set template. I experimented with

    template<typename T> using Set=std::set<T>;

but couldn't get a solution that worked without the

    using np::operator<<;

yuyoyuppe provided.

boost::format and custom printing a std containers

4 Answers4

Linked