在课堂上传递矢量而不复制

Question

I've got a class:

someclass header code:

class SomeClass{
    SomeClass();
    vector<int> somePointerVector;

    public:
    SomeClass(vector<int> &someVector);
};

Im a little confused about how to use vectors here. I'd like to set somePointerVector = someVector, so that I can manipulate the data in someVector with other parts of the class using somePointerVector and I also don't want to copy all of someVectors data.

With an array I'd do it with:

int* somePointerArray = someArray;

But how would I do this with vectors?

Answer 1

Make somePointerVector a reference and put it in the initialization list of your class. (And please give it a better name.)

class SomeClass
{
    vector<int> &somePointerVector;

  public:
    SomeClass(vector<int> &someVector)
      : somePointerVector(someVector)
    {}
};

Answer 2

To understand the most-appropriate solution, you need to understand the lifetime and ownership of 'SomeClass' and the vector that it's passed. For example, if SomeClass takes the vector by reference, then the code that constructs SomeClass needs to make sure that the lifetime of the vector is greater than that of SomeClass - otherwise SomeClass could end-up with a reference that is no longer valid. By passing by reference, SomeClass isn't 'taking ownership' of the vector

Alternatively, if the code that constructs SomeClass wants to 'hand-off' responsiblity of the vector (and you have a compiler and STL implementation that is 'r-value reference aware'), then you can pass an r-value reference to the vector;

class SomeClass { 
    vector<int> data_;

 public:
    SomeClass(vector<int>&& data) : data_(data) 
} 

The code that constructs SomeClass would then;

vector<int> data;
data.push_back(1);
data.push_back(2);
data.push_back(3);
data.push_back(4);

SomeClass someClass(std::move(data));

In this case, you've 'moved' the vector into SomeClass to avoid copying, and SomeClass has 'taken ownership' of the 'data'.

Answer 3

How about

class SomeClass {
    vector<int> myVector;

    void MyMethod(vector<int>* theVector);
}

and in your method

void SomeClass::MyMethod(vector<int>* theVector)
{
    theVector->push_back(7);
}

Been ages since I worked with STL, but I think it's push_back?

Oh, and to use indices you could just (*theVector)[2]...