«

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:stream & ostr ) =
0;
};

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

using std::tr1::shared_ptr;
using std::tr1::bind;
using std::tr1:laceholders::_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:stringstream 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.