Cosa significa const int * & var?

Question

Ho visto qualcuno che utilizza questo

void methodA(const int*& var); 

in una risposta, ma non riuscivo a capire che cosa significa l'argomento.

AFAIK:

• const int var => valore const che non può essere modificato

• const int* var => puntatore a int che è const ie * var non può essere cambiato, ma var può essere cambiato

• const int& var => riferimento const int ovvero valore di var non può essere modificato

Che cosa significa const int*& var, ed è anche const int& *var possibile?

Potete per favore dare qualche esempio, come cosa si può fare e cosa non si può fare con esso?

UPDATE:

Non sono sicuro se sto pensando modo giusto, ma ho cominciato a pensare di riferimento come alias della variabile che era passata come argomento, in modo da const int * p; Methoda (p) => qui stiamo passando p come const int *, ma non sappiamo se questo è passaggio per valore o quello che fino a quando vediamo la definizione di metodo A,

quindi se Methoda è così Methoda (const int * & p2) ==> qui p2 è un altro nome per p, cioè p e p2 sono gli stessi di adesso e se methodA (const int * p2) ==> qui p2 viene passato come valore cioè p2 è solo locale a questo metodo,

per favore correggimi se sto pensando in modo sbagliato? Se sì, potrei aver bisogno di studiarne un altro? Puoi per favore indicare delle belle referenze?

UPDATE 2 Se qualche principiante come me vogliono sapere di più su questa cosa, è possibile utilizzare C++ decl/programma cdecl, che ho appena scoperto di molto utile da 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 

Ma come indicato da tutti qui, il primo esempio non è legale in C++.

Grazie

Answer 1

È un riferimento a un puntatore a un int che è const.

C'è un altro post in qualche modo correlato, in realtà, here. La mia risposta fornisce una sorta di algoritmo generale per capire queste cose.

Questo: const int& *var non ha alcun significato, poiché non è possibile avere un puntatore a cui fare riferimento.

Se il const e puntatori stanno ottenendo nel senso, ricorda che puoi typedef queste cose:

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 

potrebbe rendere più facile da leggere.

---

Se è necessario ulteriore aiuto su C++, read this. Più specificamente, references.

riferimenti come variabili fanno non prendere spazio:

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 

riferimenti come parametri utilizzano puntatori per ottenere l'effetto finale:

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) 
} 

Così è in realtà passando l'indirizzo della i sullo stack , quindi occupa lo spazio sizeof(int*) nello stack. Ma non iniziare a pensare ai riferimenti come puntatori. Sono non uguali.

Answer 2

È un riferimento a un puntatore const, ovvero un puntatore in cui non è possibile modificare i dati puntati. Poiché il riferimento è usato come argomento per un metodo, il metodo è in grado di modificare il puntatore per farlo puntare a qualcos'altro (ancora qualcosa che non può essere modificato).

Per quanto riguarda l'aggiornamento:

quindi se Methoda è così Methoda (const int * & p2) ==> qui P2 è un altro nome per p, cioè P e P2 sono gli stessi da ora in poi e se metodoA (const int * p2) ==> qui p2 viene passato come valore cioè p2 è solo locale a questo metodo

Sì, sei corretto.

Answer 3

Nell'esempio, var è un riferimento a un puntatore a const char.

Dal momento che è un punto di riferimento, una modifica al parametro all'interno methodA() si rifletterà nella discussione che viene passato al 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

Alcune persone trovano più facile la lettura questo da destra a sinistra. Così

const int * &

è un riferimento a un puntatore a un intero che è const.

Come sapete, i riferimenti non possono essere modificati, solo ciò a cui si riferiscono può essere modificato. Quindi il riferimento si riferirà a un solo puntatore a un intero che è const. Poiché il puntatore non è const - il numero intero è const - puoi cambiare il puntatore in modo che punti a un numero intero diverso.

confronta questo

int * const &

Questo è un riferimento a un puntatore costante a un intero. Di nuovo il riferimento è immutabile e in questo caso è un riferimento a un puntatore costante. In questo caso, ciò che è possibile modificare è il valore intero poiché non vi è stato alcun lato positivo della parola chiave int.

Giusto per aggiungere confusione, const int e int const sono gli stessi. Tuttavia int const * e int * const sono molto diversi. Il primo è un puntatore a un numero intero costante, quindi il puntatore è mutabile. Il secondo è un puntatore costante a un numero intero, quindi il numero intero è mutabile.

Spero che questo aiuti!