¿Qué significa esto const int * & var?

Question

vi a alguien usando este

void methodA(const int*& var); 

en una respuesta, pero no podía entender lo que significa el argumento.

yo sepa:

• const int var => valor const que no puede ser cambiado

• const int* var => puntero a int que es decir const * var no se puede cambiar, pero puede ser var cambiado

• const int& var => referencia a const int es decir, valor de var no se puede cambiar

¿Qué significa const int*& var y es const int& *var también posible?

¿Podría darme algún ejemplo también, como qué se puede hacer y qué no se puede hacer con él?

ACTUALIZACIÓN:

No estoy seguro de si estoy pensando manera correcta, pero empecé a pensar en referencia con el alias de la variable que se pase como argumento, por lo const int * p; MethodA (p) => aquí estamos pasando p como const int *, pero no sabemos si se trata de pasar por valor o lo que hasta que veamos la definición de método A,

así que si MethodA es así MethodA (const int * & p2) aquí p2 es otro nombre para p, es decir, p y p2 son los mismos de ahora en adelante y si el método A (const int * p2) ==> aquí p2 se pasa como valor, es decir, p2 es solo local a este método,

por favor corrígeme si estoy pensando mal? Si es así, ¿podría necesitar estudiar un poco más sobre esto? ¿Puedes señalar algunas buenas referencias?

ACTUALIZACIÓN 2 Si algún principiante como yo quiero saber más sobre esto, puede utilizar C++ decl/programa cdecl, que acabo de descubrir a muy útil desde here

$ c++decl 
Type `help' or `?' for help 
c++decl> explain const int&* p 
declare p as pointer to reference to const int 
c++decl> explain const int*& p 
declare p as reference to pointer to const int 

Pero como todos señalaron aquí, el primer ejemplo no es legal en C++.

Gracias

Answer 1

es una referencia a un puntero a un int que es const.

Hay otra publicación algo relacionada, de hecho, here. Mi respuesta da una especie de algoritmo general para resolver estas cosas.

Esto: const int& *var no tiene ningún significado, porque no puede tener un puntero de referencia.

Si y punteros de la const están recibiendo en el camino, recuerde que puede typedef estas cosas:

typedef int* IntPointer; 
typedef const IntPointer ConstIntPointer; 

void foo(ConstIntPointer&); // pass by reference 
void bar(const ConstIntPointer&); // pass by const reference 
void baz(ConstIntPointer); // pass by value 

puede hacer que sea más fácil de leer.

---

Si necesita más ayuda sobre C++, read this. Más específicamente, references.

Referencias como variables hacen no toma el espacio:

int i; // takes sizeof(int) 
int*pi = &i; // takes sizeof(int*) 

int& ri = i; // takes no space. 
      // any operations done to ri 
      // are simply done to i 

referencias como parámetros utilicen indicadores para lograr el efecto final:

void foo(int& i) 
{ 
    i = 12; 
} 

void foo_transformed(int *i) 
{ 
    *i = 12; 
} 

int main() 
{ 
    int i; 

    foo(i); // same as: 
    foo_transformed(&i); // to the compiler (only sort of) 
} 

Así que en realidad es pasar la dirección de i en la pila , así que toma sizeof(int*) espacio en la pila. Pero no empieces a pensar en referencias como punteros. Son no lo mismo.

Answer 2

Es una referencia a un puntero const, es decir, un puntero donde no se pueden modificar los datos apuntados. Como la referencia se usa como argumento para un método, el método puede modificar el puntero para permitirle apuntar a otra cosa (todavía algo que no se puede modificar).

Con respecto a su cambio:

por lo que si es así MethodA MethodA (const int * & p2) ==> p2 aquí es otro nombre para p, es decir, P y P2 son los mismos de ahora en adelante y si el método A (const int * p2) ==> aquí p2 se pasa como valor, es decir, p2 es simplemente local para este método

Sí, está en lo correcto.

Answer 3

En su ejemplo, var es una referencia a un puntero a const char.

Ya que es una referencia, un cambio en el parámetro dentro methodA() se verá reflejado en el argumento que se pasa a methodA():

void methodA(const char*& var) 
{ 
    static const char newdata[] = {'a', 'b', 'c', '\0'}; 

    printf("var points to %s\n", var); 

    var = newdata; 
} 


int main() 
{ 
    const char * p = "123"; 

    printf("p points to: %s\n", p);  // prints "p points to: 123" 
    methodA(p); 
    printf("now p points to: %s\n", p); // prints "now p points to: abc" 
} 

Answer 4

Algunas personas les resulta más fácil la lectura este de derecha a izquierda. Así

const int * &

es una referencia a un puntero a un entero que es const.

Como usted sabe, las referencias no se pueden cambiar, solo se puede cambiar a lo que hacen referencia. Entonces la referencia se referirá a un solo puntero a un entero que es const. Como el puntero no es const - el entero es const - puede cambiar el puntero para apuntar a un entero diferente.

comparar esto con

int * const &

Ésta es una referencia a un puntero constante a un entero. De nuevo, la referencia es inmutable, y en este caso es una referencia a un puntero constante. Lo que puede cambiar en este caso es el valor entero ya que no hubo const ninguno de los lados de la palabra clave int.

Solo para agregar confusión, const int e int const son lo mismo. Sin embargo, int const * e int * const son muy diferentes. El primero es un puntero a un entero constante, por lo que el puntero es mutable. El segundo es un puntero constante a un entero, por lo que el entero es mutable.

Espero que esto ayude!