How do use a std::auto_ptr in a class you have to copy construct?

Question

I have class `foo` that contains a std::auto_ptr member that I would like to copy construct but this does not appear to be allowed. There's a similar thing for the assignment. See the following example: ``` struct foo { private: int _a; std::string _b; std::auto_ptr< bar > _c; public: foo(const foo& rhs) : _a(rhs._a) , _b(rhs._b) , _c(rhs._c) // error: Cannot mutate rhs._c to give up ownership - D'Oh! { } foo& operator=(const foo& rhs) { _a = rhs._a; _b = rhs._b; _c = rhs._c; // error: Same problem again. } }; ``` I could just declare `_c` as `mutable` but I'm not sure this is correct. Does anyone have a better solution? EDIT OK, I'm not getting the kind of answer that I was expecting so I'll be a little more specific about the problem. - An object of type `foo` is created on the stack and passed by value into a container class (not stl) and then goes out of scope. I don't have any control over the container code. (It's actually an active queue implementation, with bugs.) - The `bar`…

Accepted Answer

You might want to try following code:

```
    foo(const foo& rhs)
        :   _a(rhs._a)
        ,   _b(rhs._b)
        ,   _c(_rhs._c.get() ? new bar(*_rhs._c.get()) : 0)
    {
    }
```

(Assignment operator is similar.)

However this will only work if `bar` is CopyConstructible and if this indeed does what you want. The thing is that both `foo` objects (`_rhs` and constructed one) will have different pointers in `_c`.

If you want them to share the pointer then you must not use `auto_ptr` as it does not support shared ownership. Consider in such case use of `shared_ptr` from Boost.SmartPtr for example (which will be included in new C++ standard). Or any other shared pointer implementation as this is such a common concept that lots of implementations are available.

How do use a std::auto_ptr in a class you have to copy construct?

Solution

Problem