Problems with tr1::bind and reference to abstract class

This is a workable example of what I am trying to do in the real
situation that reproduces the error. I could not tryitout on Comeau
which does not seem to recognise tr1, at least not in the standard
headers.

I am trying to compile it on VC2008 and am including the relevant
headers for it.

-------------

#include <memory>
#include <algorithm>
#include <functional>
#include <vector>
#include <iostream>
#include <sstream>

class Abstract1
{
public:
    virtual ~Abstract1()
    {
    }

    virtual std::string gimme() const = 0;
};

class Derived1 : public Abstract1
{
    std::string gimme() const
    {
        return "Take It\n";
    }
};

class Abstract2
{
public:
    virtual ~Abstract2()
    {
    }

    virtual void getme( const Abstract1 & abs1, std::ostream & ostr ) =
0;
};

class Derived2 : public Abstract2
{
public:
    void getme( const Abstract1 & abs1, std::ostream & ostr )
    {
         ostr << abs1.gimme();
    }
};

using std::tr1::shared_ptr;
using std::tr1::bind;
using std::tr1::placeholders::_1;
using std::tr1::ref;
using std::tr1::cref;

int main()
{
    shared_ptr< Abstract1 > ptr1( new Derived1 );

    typedef shared_ptr< Abstract2 > Ptr2;

    std::vector< Ptr2 > ptr2Vec;

    ptr2Vec.push_back( Ptr2( new Derived2 ) );
    std::ostringstream oss;

    std::for_each( ptr2Vec.begin(), ptr2Vec.end(),
        bind( &Abstract2::getme, _1, cref( *ptr1 ), ref( oss ) ) );

    std::cout << oss.str();
}

---------

The error I am getting is that Abstract1 is abstract, no problem it
would seem with Abstract2, but because I am passing with the cref
modifier that should get around the problem and pass it as a const
reference (as the function getme requires).

I get the same error if I dereference ptr1 first and put cref around
the const reference, and also I get the error even if I use a non-
const reference.

In my real code I did the simple workaround of a functor (which took a
few seconds to write) but I'd rather be able to use bind than have to
write functors.