Newsgroup: it.comp.lang.c++
Titolo: punatori a variabili const

Ciao, è da diverso tempo che vi seguo ma è la prima volta che vi posto un
messaggio.
C'è una cosa che non riesco a capire per quanto riguarda i puntatori. Allora
io ho il seguente codice:
---
#include <iostream.h>
#include <conio.h>
main()
{
  const int j = 10;
  int * pj;
  pj = (int *) &j;
  *pj = 45;
  cout << j << '\n';
  getch();
  return 0;
}
---
quello che con riesco a capire è perchè quando visualizzo il valore della
variabile j questo è 10 invece che 45, valore impostato utilizzando il
puntatore pj.
Grazie in anticipi!
*MASTER BLAST*

 *MASTER BLAST*
Non ne sono sicurissimo (poi dipende anche dal compilatore che 
in un caso come questo dovrebbe darti un bel warning) ma 
probabilmente l'assegnazione *pj = 45; avviene in una variabile
temporanea creata solo per quel momento.
Non potendo usare il vero j perche' const allora crea un int temporaneo
su cui fare ricadere l'assegnazione, che poi verra distrutto.
Questo accade solitamente nel passaggio parametri a funzioni
con paramentri non-const a cui viene passato un dato const.
Non sono sicuro sia lo stesso.
		bax

puntatore pj.
Mi permetto di risponderti io: hai dichiarato j come CONST, per cui il
suo valore non viene modificato. Se togli il CONST otterrai come input
45, come desideri tu.
Sm3P
"Ninetta mia crepare di maggio, ci vuole tanto troppo coraggio,
 Ninetta bella dritto all'inferno, avrei preferito andarci d'inverno."

 *MASTER BLAST*
Utilizzando il debugger e andando avanti un istruzione alla volta, prima
di cout
<< j mi indica che il valore di j è 45 (infatti aggiungendo la riga  
std::cout
<< *pj << '\n'; scrive 45)e poi invece scrive 10. Ho letto da poco (non
mi
ricordo dove) un testo che spiegava i vantaggi dell'utilizzo delle
variabili
const rispetto alla macro #define. In pratica veniva detto che il
compilatore
non alloca memoria per le variabili const se non ci è costretto perchè
qualcuno
ne richiede l'indirizzo (come in questo caso), ma si limita
semplicemente a
sostituire la variabile con il valore indicato. Lo stesso testo dice che
chiamare una conversione cast esplicita per assegnare l'indirizzo di una
variabile const a un puntatore non const è "Legal but bad practice
" (dicitura molto elegante :P). Evidentemente nel tuo esempio il
compilatore
assegna sì la memoria per la variabile const (altrimenti *pj = 45
darebbe una
violazione d'accesso), ma esegue anche la sostituzione della variabile j
con il
valore 10 e quindi cout << j << '\n' equivale a cout << 10 << '\n'.
Chissà se è
un errore del compilatore (con la Microsoft non si può mai dire).

 puntatore pj.
Perché non puoi alterare il valore di una costante neanche attraverso un
puntatore ad essa. Un paio di note:
1. In C++ non si può scrivere main() ma int main().
2. Meglio utilizzare il const_cast invece del cast alla C:
   pj = const_cast <int *> ( &j );
   che comunque non ti serve a niente lo stesso.
EMG

 in un caso come questo dovrebbe darti un bel warning)
Non può darti il warning in quanto questo è stato esplicitamente
disattivato attraverso l'uso del cast.
EMG

 un errore del compilatore (con la Microsoft non si può mai dire).
No, fa la stessa cosa con il DJGPP. Per stavolta la MS non ha colpa. :-)
EMG

  pj = (int *) &j;
^^^^^^^^^^^^
questo e` undefined behaviour
(per la serie i cast fanno male).
Avendo dichiarato j costante, il compilatore e`
autorizzato a sostituirne tutte le occorrenze con il
valore a cui e` inizializzata la costante (anche se
come accade in seguito all'inizializzazione di pj
alloca memoria per j).
Paolo
-----------------------------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
  home:   
http://www.cli.di.unipi.it/~marotta
-----------------------------------------------------------------