在C ++中通过指针和引用传递向量

Question

A quick question about how to safely pass and use vectors in c++.

I know that when using vectors you have to be very careful with addresses to them and their elements because when you dynamically change their size they may change their address (unless you use reserve etc. but I'm imagining I will not know how much space I will need).

Now I want to pass an existing vector (created elsewhere) to a function which adapts it and changes it size etc. but I'm a little unclear as to what is safe to do because I would normally achieve all of this with pointers. On top of this there is using references to the vector and this just muddies the water for me.

For instance take the two following functions and comments in them

void function1(std::vector<int>* vec){

    std::cout<<"the size of the vector is: "<<vec->size()<<std::endl; //presumably valid here  

    for (int i=0;i<10;i++){

        (*vec).pushback(i);  //Is this safe? Or will this fail?
        // Or: vec->pushback(i); Any difference?
    }

    std::cout<<"the size of the vector is: "<<vec->size()<<std::endl; //Is this line valid here??

}

AND

void function2(std::vector<int>& vec){

    std::cout<<"the size of the vector is: "<<vec.size()<<std::endl; //presumably valid here  

    for (int i=0;i<10;i++){

        vec.pushback(i);  //Is this safe? Or will this fail?

    }

    std::cout<<"the size of the vector is: "<<vec.size()<<std::endl; //Is this line valid here??

}

Is there any difference between the two functions, both in terms of functionality and in terms of safety?

Or in other words, if I only have a pointer/reference to a vector and need to resize it how can I be sure where the vector will actually be in memory, or what the pointer to the vector really is, after I operate on it. Thanks.

Answer 1

In term of functionality, in the very limited context you gave us, they are essentially the same.

In more general view, if you want to write generic code, consider that operation and operators bind directly to reference, but not to pointers

a = b + c;

To compile requires

A operator+(const B&, const C&);

But

A* operator+(const B*, const C*);

is all a different beast.

Also, an expression taking reference and taking value have the same syntax, but an expression taking pointers require pointers to be deference to provide equal semantics, but this leads to different expression syntax ( *a + *b against a+b ) thus leading to "less general code".

On the counterpart, if you are writing a class that have runtime polymorphism (and lyskov substitution in mind), you will most likely treat dynamically allocated object, and hence, manipulating them through pointers may be more natural.

There are "grey areas" where the two things mesh, but -in general- pointer taking function are more frequent in runtime based OOP frameworks, while reference taking functions are more frequent in "value based generic algorithms", where static type deduction is expected, and on-stack based allocation is most likely wanted.