C++ boost shared array swapping pointers (simple question)

I'm new to boost shared arrays.

There is existing code that declares two arrays:

boost::shared_array<unsigned char> src; 
boost::shared_array<unsigned char>开发者_如何学C dest; 

All I want to do is swap what each array is pointing to (src becomes dest, and dest becomes src). As I understand it, the shared_array.get() method returns a pointer to one of its elements (can be of any type).

So my added declaration is:

boost::shared_array<unsigned char> temp;

And my added code is:

temp.get() = src.get();
src.get() = dest.get();
dest.get() = temp.get();

Each of these lines fail; compile error is C2016: '=' : left operand must be l-value.

I am a C++ newbie, so I googled the error and see that that error message means that the left hand operand is not assignable. Yet the left hand sides are all pointers and pointers can be assigned to other pointers.

So I'm not sure what I'm doing wrong. Can someone please help me out?

Thanks in advance.

jbu

---

The correct way to swap two shared_arrays (or most other Boost shared pointer types) is to use the swap member function:

src.swap(dest);

This swaps the pointers and reference counts used by each of the shared_arrays:

void swap(shared_array<T> & other)
{
    std::swap(px, other.px);
    pn.swap(other.pn);
}

---

For your original problem: just use the swap() method of boost::shared_array. (Don't be afraid, that will not memcpy anything.)

The pointer returned by get() is not an l-value in your case, because you want to change value of the pointer itself, not the data it is pointing to. So you'd need a reference to the pointer here.

---

swap(src,dest) should do the trick.

As for what you're doing wrong: src.get() gives you a copy of the pointer from the shared_array object, so even if you could assign to it, it wouldn't change the shared_array itself. You could assign one array to another, like this:

boost::shared_array<unsigned char> temp = src;
src = dest;
dest = temp;

but swap is more efficient, and guaranteed not to throw an exception.