指针和c ++中的引用作为参数

Question

What does this do exactly?

void insertar (struct pila *&p);

What are advantages of using *& versus if the method were only declared like so:

void insertar (struct pila *p);

or like so:

void insertar (struct pila &p);

I know that the * is pointer and & is address, but both in the method signature?

what is the advantage?

And what are they used for?

What does it do?

Answer 1

You're mixing up two meanings of & . It is the "address of" operator when used in an expression. That is, if you have an int x; and you do &x , you get the address of x . However, in a type, the & means that it is a reference type. These are two totally separate concepts.

The following takes a pila , copying it into the function. Modifying p will only effect the copy inside the function:

void insertar(pila p);

The following takes a pila by reference, so that the object inside the function is the same one as outside. Modifying p here will modify the object that was passed in:

void insertar(pila& p);

The following takes a pointer to a pila , copying the pointer into the function. Modifying the pointer will only have an effect inside the function. The object it points to is the same as outside however:

void insertar(pila* p);

The following takes a pointer to a pila by reference, so that the pointer inside the function is the same one as outside. If you modify the pointer , you'll modify the pointer outside too:

void insertar(pila*& p);

Answer 2

Here & is a reference. A *& is pretty much like a ** . It will allow you to change a pointer.

int u = 3;

void change( int *& p ) {
    p = &u;
}

void main() {
    int *p;
    change( p );
    // p == &u
}

Answer 3

*& is a reference to a pointer in your example. In short, you can modify the data pointed by the pointer and the pointer itself. Example:

int global1 = 0, global2 = 1;
void func(int*& p)
{
    *p = 42;
    p = &global1;
}

int main()
{
    int* p = &global2;
    func(p); // Now global2 == 42 and p points to global1 (p == &global1).
}