2 vector objects pointing to the same allocated memory

Question

In C++, how to make a copy of an existing vector pointing to the same allocated memory ?

e.g :

vector<int> o1;
o1.push_back(1);

vector<int> o2;
//Make o2 share same memory as o1
o2[0]=2;

cout << o1[0]; //display 2

EDIT : I haven't been clear about the objective : if o1 is allocated on the heap and gets destroyed, how can I create an object o2 that would point to the same allocated memory as o1 to keep it outside of the o1 scope ?

You cannot. There is no way to make the proposed solution work. There may be a solution to the currently undisclosed problem, but the requirements need to be made clear. — R. Martinho Fernandes, Nov 12 '12 at 09:40
either use shared_ptr > or boost::shared_array< int > although with boost::shared_array you cannot resize your array. — CashCow, Nov 12 '12 at 10:55

score 3 · Answer 1 · answered Nov 12 '12 at 09:41

3

make o2 a reference to o1

std::vector<int> &o2 = o1;

answered Nov 12 '12 at 09:41

billz

44,644
9
83
100

4

That doesn't yield "two vector objects". – juanchopanza Nov 12 '12 at 09:45
agree, the question isn't 100% clear. I had to GUESS a pointer or a reference is what he means. – billz Nov 12 '12 at 09:47
Yes, indeed it works for the simplified example I gave. But what if the first object o1 gets destroyed but I want to keep its allocated memory for o2 ? – Yann Abrowitch Nov 12 '12 at 09:58
This would require a dynamic allocation isn't it ? My problem is that o1 is allocated on the heap – Yann Abrowitch Nov 12 '12 at 10:02
if o1 is on heap, why can't? – billz Nov 12 '12 at 10:04
To create o1 using a smart pointer I would have to use the operator "new" which would allocate o1 on the stack. I need o1 on the heap. – Yann Abrowitch Nov 12 '12 at 10:15
@YannAbrowitch "new" allocates on the heap by default. You woudl create a shared_ptr with `new` and then copy it. The dynamically allocated object will live as long as the two shared_ptrs are alive. – juanchopanza Nov 12 '12 at 10:37

score 0 · Accepted Answer · answered Nov 12 '12 at 11:01

There is a boost::shared_array template.

This however shares a fixed-size array of data and you cannot modify the size.

If you want to share a resizeable vector then use

boost::shared_ptr< vector< int > >

What you can also do is swap the vector memory into a different vector.

{
   std::vector< int > o1; // on the stack
     // fill o1
   std::vector< int > * o2 = new std::vector< int >; // on the heap
   o2->swap( o1 );
    // save o2 somewhere or return it
} // o2 now owns the exact memory that o1 had as o1 loses scope

C++11 will bring in "move" semantics allowing you to keep the actual memory in o1 with std::move thus

std::vector<int> && foo()
{
      std::vector<int> o1;
       // fill o1
      return std::move( o1 );
}


// from somewhere else
std::vector< int > o2( foo() );

2 vector objects pointing to the same allocated memory

2 Answers2

Linked