In Effective STL item 8, it said 'Never create cointainers of
auto_ptrs'.

But in the Boost shared_ptr_example.cpp example, it creates a stl
vector of smart pointer.
Why it is okay in this case?

Here is part the code:
struct Foo
{
Foo( int _x ) : x(_x) {}
~Foo() { std::cout << "Destructing a Foo with x=" << x << "\n"; }
int x;
/* ... */
};

typedef boost::shared_ptr<Foo> FooPtr;

struct FooPtrOps
{
bool operator()( const FooPtr & a, const FooPtr & b )
{ return a->x > b->x; }
void operator()( const FooPtr & a )
{ std::cout << a->x << "\n"; }
};

int main()
{
std::vector<FooPtr> foo_vector;
std::set<FooPtr,FooPtrOps> foo_set; // NOT multiset!

.... // omit
}

<yinglcs@gmail.com> wrote in message
news:1137000350.810610.59540@z14g2000cwz.googlegro ups.com...[color=blue]
> In Effective STL item 8, it said 'Never create cointainers of
> auto_ptrs'.
>
> But in the Boost shared_ptr_example.cpp example, it creates a stl
> vector of smart pointer.[/color]

'auto_ptr' is one kind of 'smart pointer'. However, not
all 'smart pointers' are 'auto_ptr's,
[color=blue]
> Why it is okay in this case?[/color]

Find out why it's *not* OK with 'auto_ptr', and
I think you'll have your answer.

-Mike

yinglcs@gmail.com wrote:[color=blue]
> In Effective STL item 8, it said 'Never create cointainers of
> auto_ptrs'.
>
> But in the Boost shared_ptr_example.cpp example, it creates a stl
> vector of smart pointer.
> Why it is okay in this case?
> [..][/color]

Because 'std::auto_ptr' does not satisfy the requirement imposed on
the type of the contained items.

V

yinglcs@gmail.com wrote:[color=blue]
> In Effective STL item 8, it said 'Never create cointainers of
> auto_ptrs'.
>
> But in the Boost shared_ptr_example.cpp example, it creates a stl
> vector of smart pointer.
> Why it is okay in this case?
>
> Here is part the code:
> struct Foo
> {
> Foo( int _x ) : x(_x) {}
> ~Foo() { std::cout << "Destructing a Foo with x=" << x << "\n"; }
> int x;
> /* ... */
> };
>
> typedef boost::shared_ptr<Foo> FooPtr;
>
> struct FooPtrOps
> {
> bool operator()( const FooPtr & a, const FooPtr & b )
> { return a->x > b->x; }
> void operator()( const FooPtr & a )
> { std::cout << a->x << "\n"; }
> };
>
> int main()
> {
> std::vector<FooPtr> foo_vector;
> std::set<FooPtr,FooPtrOps> foo_set; // NOT multiset![/color]


You could avoid having to create a FooPtrOps type class, by using a
smart pointer like copy_ptr:
http://code.axter.com/copy_ptr.h

The above smart pointer uses value semantics for the comparison
operators.
std::set<copy_ptr<Foo> > foo_set;

You can also use a cow_ptr
http://code.axter.com/cow_ptr.h

Both the copy_ptr and the cow_ptr can clone the pointee when needed.