One way swap for vectors, is it possible? [closed] - c++

Question

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 6 years ago.
Improve this question
In C++98, this is what I want to do (this does not work as _M_start, etc are private members):
void vectormove(std::vector<int>& a, std::vector<int>& b)
{
a._M_impl._M_start = b._M_impl._M_start;
a._M_impl._M_finish = b._M_impl._M_finish;
a._M_impl._M_end_of_storage = b._M_impl._M_end_of_storage;
}
This is how I want to call
//vectors are predefined already
std::vector<int> a;
std::vector<int> b(10000000,20);
//in later part of code
//a=b; //expensive copy
//std::swap(a,b); //inexpensive swap
vectormove(a,b); //i need an inexpensive one way swap instead
I may have butchered terminology by using copy, move and swap loosely, but I dont have a better grasp on this subject. I hope I was able to convey my intent.

Answer 1

It looks like you just want a to refer to b's internals. The way to do that is just:
std::vector<int>& a = b;
if you want a to take over b's internals, that's:
std::vector<int> a = std::move(b);
which in C++03 could be implemented as a swap with an empty vector:
std::vector<int> a;
using std::swap;
swap(a, b);

Answer 2

If your question is how to write a compilable implementation of your vectormove(), it's like this:
// NOT USEFUL CODE
void vectormove(std::vector<int>& a, std::vector<int>& b)
{
memcpy(&b, &a, sizeof(std::vector<int>));
}
But this is not useful, because once you've done this you are on the path to undefined behavior. Perhaps double-free, perhaps use-after-free, etc.
It seems like you would be best served either by the regular a.swap(b) or by storing a as type int* instead, like this:
std::vector<int> b(10000000,20);
std::pair<int*, int*> a(&b[0], &b[b.size()]);
Now you have an a which can be passed around cheaply and refers to the original vector. Just make sure you don't invalidate a by modifying b afterwards.