Re: ostream_iterator and a collection of pointers

In article <c3bfe697-6e6e-4b8d-9b16-2460796b3480
@a39g2000pre.googlegroups.com>, sjackman@gmail.com says...


Exactly as stated, I don't think it's possible. If you're willing to
use a proxy class for the pointers, it becomes pretty trivial:

// warning: code only minimally tested.
#include <iostream>

template <class T>
class Proxy {
    T ptr;
public:
    Proxy(T p) : ptr(p) {}
    operator T() { return ptr; }
};

// For this to work 'T' must be a pointer(like) object -- one
// for which unary '*' is supported.
template <class T>
std::ostream &operator<<(std::ostream &os, Proxy<T> p) {
    return os << *p;
}

and a quick demo to show it can do the job:

#ifdef TEST
#include <vector>

int main() {
    std::vector<Proxy<int *> > ints;

    int a = 0, b=1, c=2;

    ints.push_back(&a);
    ints.push_back(&b);
    ints.push_back(&c);

    std::copy(ints.begin(),
        ints.end(),
        std::ostream_iterator<Proxy<int *> >(std::cout, "\n"));
    return 0;
}

#endif

I'll leave it to you to decide whether this is really a good idea or
not. It does what you've asked with essentially no overhead, but I'm
still not sure I'd use it in production code. At the very least, I'd
probably rename the Proxy class to something indicating that it's
intended as a proxy for pointers. With support for concepts, we could
include (in real code) some assurance that T is dereferencable, but
as it stands right now, we only have comments to assure that (along
with the fact that otherwise code using it won't compile, but the
error messages may be a bit ugly.

--
    Later,
    Jerry.