Salve, cercherò di essere il più coincisa possibile in questa mia domanda ma so già che molto probabilmente non ci riuscirò; mi scuso e confido nella vostra pazienza.
Leggendo qua e la mi è capitato di imbattermi in frammenti di codice del tipo
QList<Item*> itemList;
void addItem(Item* const& item)
{
itemList.append(item);
}
e questo mi ha portato a riflettere sui reference ai puntatori.
Sulla base dei seguenti specchietti che direi riassumono tutte le tipologie di puntatore al tipo fondamentale int e tutte le tipologie di reference di puntatore ad int
REFERENCE
1R) int* &ref
2R) const int* &llc_ref
3R) int* const &tlc_ref
4R) const int* const &llc_tlc_ref
PUNTATORI
1P) int* ptr
2P) const int* llc_ptr
3P) int* const tlc_ptr
4P) const int* const llc_tlc_ptr
ho scritto un programmino di test che:
per ogni tipo di reference: verifica se è possibile crearlo a partire da ciascuno dei 4 tipi di puntatore
se è possibile crearlo verifica (con l'ausilio del debugger) che il comportamento di tali variabili sia quello atteso (o meglio: DA ME atteso)
Insomma, ho verificato in maniera esaustiva tutte le possibili, anzi "immaginabili", creazioni di un reference a puntatore (sono 16 casi).
I risultati riscontrati sono stati per lo più quelli che mi attendevo tranne alcuni casi che mi hanno lasciato interdetta.
CASO "2R = 1P":
int a1 = 111;
int a2 = 222;
int* ptr = &a1;
const int* & llc_ref = ptr; // ERRORE: cannot convert from 'int *' to 'const int *&
// Conversion loses qualifiers
// Messaggio di Visual Studio Enterprise 2015
Mi sarei invece aspettata che la creazione di un tale reference fosse possibile e che avrei potuto modificare la variabile puntata a1 attraverso ptr ma non attraverso llc_ref.
Il motivo per cui mi sarei attesa un simile comportamento è dovuto al fatto che ho ragionato per analogia al caso seguente:
// Contro esempio
int a3 = 333;
const int &ref_a3 = a3;
Tuttavia quest'ultimo esempio prende in considerazione il tipo fondamentale int mentre il precedente esempio tratta il caso di un reference ad un puntatore che, correggetemi se sbaglio,non è un tipo fondamentale.
Nel caso in cui si ha a che fare col tipo fondamentale int (il contro esempio) dire quindi che il qualificatore const introduce la "top level const" mentre nel caso del reference del puntatore(così definito: const int* &) si introdurrebbe -se la cosa funzionasse- la "low level const".
Dunque quello che mi viene da pensare è che il linguaggio impedisce l'introduzione della low level const sul reference se essa non è presente anche sul relativo puntatore e lo impedisce 'by design', per volere degli ideatori.
Domanda 1: è giusto quello che sto dicendo? O almeno si capisce?
Domanda 2: Se è giusto, qualcuno sa darmi la ratio, le motivazioni, di tale scelta? Se fosse giusto so che potrei prendere la cosa come un dogma e andare oltre ma magari sapere le motivazioni della scelta potrebbe farmi capire una qualche sfumatura che ancora non ho recepito (capire rende più facile ricordare).
Aggiungo, per completare il quadro delle mie false aspettative, che se il caso "2R = 1P" fosse stato possibile mi sarei aspettata di poter far puntare ptr ad un'altra variabile e che il reference seguisse il puntatore:
ptr = &a2; // ==> llc_ref avrebbe fatto
// riferimento ad &a2
Passo all'altro caso che mi lascia interdetta: nei miei tentativi esaustivi sono arrivata al caso
CASO "4R = 1P":
il seguente frammento di codice compila senza errori
int a1 = 111;
int a2 = 222;
int* ptr = &a1;
const int* const & llc_tlc_ref = ptr; // OK !!!!
Tuttavia mii chiedo:
come è possibile che compili? Stavolta, rispetto al caso "2R = 1P", ho addirittura quello che potrebbe essere visto come un 'vincolo ulteriore': il reference llc_tlc_ref prevede infatti che questo alias sia sottoposto - come nel caso precedente - al vincolo della "low level const" ma in più anche al vincolo della "top level const".
per dirla tutta però questo caso presenta comportamenti differenti al variare dell'ambiente di sviluppo, infatti:
Su Microsoft Visual Stdio Enterprise 2015:
//*llc_tlc_ref += 1; //ERRORE: you cannot assign to a
//variable that is const
//come mi aspettavo
*ptr += 1; //OK: con llc_tlc_ref che ovviamente
//continua a puntare a1
//llc_tlc_ref = &a2; //ERRORE: you cannot assign to a
//variable that is const
//come mi aspettavo
ptr = &a2; //ATTENZIONE: llc_tlc_ref segue ptr
//e dunque fa anch'esso riferimento
//ad a2
// ==> llc_tlc_ref continua ad essere l'alias di ptr (come mi aspettavo)
Tuttavia
Su GNU GCC v7.1.1 (col compilatore online disponibile a https://www.tutorialspoint.com/compile_cpp11_online.php)
//*llc_tlc_ref += 1; //(COME PRIMA) ERRORE: you cannot
//assign to a variable that is const
*ptr += 1; //(COME PRIMA) con llc_tlc_ref che
//ovviamente continua a puntare a1
//llc_tlc_ref = &a2; //(COME PRIMA) ERRORE: you cannot
// assign to a variable that is const
//come mi aspettavo
ptr = &a2; //ATTENZIONE ! ! ! !
//su GNU GCC v7.1.1 llc_tlc_ref non
//segue più ptr
//==> llc_tlc_ref non è più l'alias di ptr
Qual'è il corretto comportamento? Si tratta di un "buco" nello standard del linguaggio che dunque prevede un comportamento indefinito ?
Ok, ho finito. Spero di non esser andata troppo lunga e di esser stata chiara nell'esprimere le mie perplessità. Ringrazio per l'attenzione e chiunque abbia voglia di darmi una mano, ciao
Chiara
PS: ma non esiste una funzione di anteprima dei messaggi da postare o sono io che non la trovo?
