I've got following container:

std::vector<boost::shared_ptr<std::string> > strings;
strings.push_back( boost::shared_ptr<std::string> ( new
std::string("AAA") ) );
strings.push_back( boost::shared_ptr<std::string> ( new
std::string("BBB") ) );
strings.push_back( boost::shared_ptr<std::string> ( new
std::string("BBB") ) );

std::for_each( strings.begin(), strings.end(),
std::mem_fun( &std::length ) );

Now I want a 0-parameter method from std::string to be called on every
element from the sequence. I tried to use std::mem_fun (as above), but
it claims as follows:

I don't know how you can solve the problem,
but at a first glance I'm afraid that a
smart pointer (boost::shared_ptr in your case)
cannot be used where a "real" pointer is needed
(but I'm not sure).

The compiler tells that he expects an object of
type 'const std::string *' (std::string is just an alias
for std::basic_string<char>), he found an object
of type boost::shared_ptr<string>.

I feel that a smart pointer acts _logically_ as a pointer,
but _is not_ a pointer...

Maybe you've already tried, but I remark that your
code compiles fine if you substitute
boost::shared_ptr<std::string> with string*, i.e.

#include<string>
#include<vector>
#include<functional>
#include<algorithm>

int main() {
std::vector<std::string* > strings;
strings.push_back( (new std::string("AAA") ) );
strings.push_back( (new std::string("BBB") ) );
strings.push_back( (new std::string("BBB") ) );

std::for_each( strings.begin(), strings.end(),
std::mem_fun( &std::string::length ) );

 std::for_each( strings.begin(), strings.end(),
    boost::mem_fn(&std::string::length));

Or

 std::for_each( strings.begin(), strings.end(),
    std::tr1::mem_fn(&std::string::length));

Or

 std::for_each( strings.begin(), strings.end(),
    boost::bind(&std::string::length, _1));

Or

 std::for_each( strings.begin(), strings.end(),
    std::tr1::bind(&std::string::length, std::tr1::placeholders::_1));

Sure, but one of the great things about shared_ptr (and some other
smart pointers) is that it allows easy use of pointers in STL
containers. Switching to raw pointers eliminates automatic cleanup
(especially important in the face of exceptions), shared ownership,
etc., which the OP may need. Using RAII techniques, like that
implemented by shared_ptr, is one of the best ways to eliminate memory
(and other resource) leaks. See Sutter and Alexandrescu, _C++ Coding
Standards_, Item 13.

Cheers! --M

I haven't considered boost::mem_fun_ref. It works. In terms of
string*, it was an example, I actually use more havy classes in my
containers but for simplicity provided an example with
shared_ptr<string>.

Anyway thanks.

On Aug 20, 5:20 pm, mlimber <mlim...@gmail.com> wrote: