significado - structur c++

¿Qué significa `* &` en una declaración de función?

Question

Escribí una función en este sentido:

void myFunc(myStruct *&out) {
    out = new myStruct;
    out->field1 = 1;
    out->field2 = 2;
}

Ahora en una función de llamada, podría escribir algo como esto:

myStruct *data;
myFunc(data);

Lo que llenará todos los campos en los data . Si omito el '' & '' en la declaración, esto no funcionará. (O más bien, funcionará solo localmente en la función pero no cambiará nada en la persona que llama)

¿Podría alguien explicarme lo que realmente hace este '' *& ''? Parece raro y no puedo darle mucho sentido.

Answer 1

¡Esto parece que estás re-implementando un constructor!

¿Por qué no crear el constructor apropiado?
Tenga en cuenta que en C ++ una estructura es como una clase (puede tener un constructor).

struct myStruct
{
    myStruct()
        :field1(1)
        ,field2(2)
    {}
};

myStruct*  data1 = new myStruct;

// or Preferably use a smart pointer
std::auto_ptr<myStruct>   data2(new myStruct);

// or a normal object
myStruct    data3;

Answer 2

Como con la mayoría de los tipos de datos en C ++, puede leerlo de derecha a izquierda y tendrá sentido.

myStruct *&out

out es una referencia ( & ) a un puntero ( * ) a un objeto myStruct . Debe ser una referencia porque desea cambiar lo out apunta a (en este caso, un new myStruct ).

Answer 3

Como han dicho otros, el & significa que está tomando una referencia a la variable real en la función en lugar de una copia de la misma. Esto significa que cualquier modificación hecha a la variable en la función afecta a la variable original. Esto puede resultar especialmente confuso cuando se pasa un puntero, que ya es una referencia a otra cosa. En el caso de que su firma de función se vea así.

void myFunc(myStruct *out);

Lo que sucedería es que a su función se le pasaría una copia del puntero para trabajar. Eso significa que el puntero apuntaría a la misma cosa, pero sería una variable diferente. En este caso, cualquier modificación hecha a *out (es decir, a lo que apunta) sería permanente, pero los cambios realizados a out (el puntero en sí) solo se aplicarían dentro de myFunc . Con la firma así.

void myFunc(myStruct *&out);

Está declarando que la función tomará una referencia al puntero original. Ahora, cualquier cambio realizado en la variable de puntero out afectará al puntero original que se pasó.

Dicho esto, la línea

out = new myStruct;

Está modificando la variable de puntero out y no *out . Lo out sea ​​que esté acostumbrado a señalar todavía está vivo y bien, pero ahora se ha creado una nueva instancia de myStruct en el montón, y se ha modificado para que apunte hacia ella.

Answer 4

El símbolo & en una declaración de variable C ++ significa que es una reference .

Resulta que es una referencia a un puntero, lo que explica la semántica que estás viendo; La función llamada puede cambiar el puntero en el contexto de la llamada, ya que tiene una referencia a ella.

Entonces, para reiterar, el "símbolo operativo" aquí no es *& , esa combinación en sí misma no significa mucho. El * es parte del tipo myStruct * , es decir, "puntero a myStruct ", y el & convierte en una referencia, por lo que lo leería como " out es una referencia a un puntero a myStruct ".

El programador original podría haber ayudado, en mi opinión, escribiéndolo como:

void myFunc(myStruct * &out)

o incluso (no es mi estilo personal, pero por supuesto sigue siendo válido):

void myFunc(myStruct* &out)

Por supuesto, hay muchas otras opiniones sobre el estilo. :)

Answer 5

En C ++ es una referencia a un puntero, equivalente a un puntero a puntero en C, por lo que el argumento de la función es asignable.

Answer 6

En C y C ++, & significa llamada por referencia; Permites que la función cambie la variable. En este caso, su variable es un puntero al tipo myStruct. En este caso, la función asigna un nuevo bloque de memoria y lo asigna a su ''datos'' de puntero.

En el pasado (digamos K&R) esto tenía que hacerse pasando un puntero, en este caso un puntero a puntero o **. El operador de referencia permite un código más legible y una verificación de tipos más fuerte.

Answer 7

MyClass * & MyObject

Aquí MyObject es una referencia a un puntero de MyClass. Así que llamar a myFunction (MyClass * & MyObject) es llamada por referencia, podemos cambiar MyObject que es referencia a un puntero. Pero si hacemos myFunction (MyClass * MyObject) no podemos cambiar MyObject porque es llamada por valor, solo copiará la dirección en una variable temporal para poder cambiar el valor donde MyObject apunta pero no es MyObject.

por lo tanto, en este caso, el escritor primero asigna un nuevo valor a eso, por lo que es necesario llamar por referencia.

Answer 8

Puede valer la pena explicar por qué no es &* , sino al revés. La razón es que las declaraciones se construyen de forma recursiva, por lo que una referencia a un puntero se acumula como

& out // reference to ...
* (& out) // reference to pointer

Los paréntesis se eliminan porque son redundantes, pero pueden ayudarlo a ver el patrón. (Para ver por qué son redundantes, imagine cómo se ve la cosa en las expresiones, y notará que primero se toma la dirección y luego se elimina la referencia: ese es el orden que queremos y que los paréntesis no cambiarán). Si cambias el orden, obtendrías

* out // pointer to ...
& (* out) // pointer to reference

El puntero a referencia no es legal. Es por eso que el orden es *& , que significa "referencia al puntero".

Answer 9

Ver reference