[RISOLTO]C++ usare const_cast

[virtualmind]

Qualcuno sa dirmi se è lecita questa operazione? Con una variabile funziona, con l'array no.
Ho provato anche a creare un puntatore alla sola locazione del singolo elemento dell'array.

Codice: Seleziona tutto

#include <iostream>
int main() {
 const double ad[3] = {1,2,3};
 double * p_ad = const_cast<double *>(ad);
 p_ad[0] = 2; //a questo punto ottengo un segment fault
}

Grazie per l'aiuto, sto imparando adesso.

[lurebu]

Qualcuno sa dirmi se è lecita questa operazione? Con una variabile funziona, con l'array no.
Ho provato anche a creare un puntatore alla sola locazione del singolo elemento dell'array.

Codice: Seleziona tutto

#include <iostream>
int main() {
 const double ad[3] = {1,2,3};
 double * p_ad = const_cast<double *>(ad);
 p_ad[0] = 2; //a questo punto ottengo un segment fault
}

A naso

double * p_ad = const_cast(ad);
togli asterisco dopo double nel const_cast
double * p_ad = const_cast(ad);

Guarda qui .. la prima googolata
http://publib.boulder.ibm.com/infocente ... t_cast.htm

Grazie per l'aiuto, sto imparando adesso.

[virtualmind]

double * p_ad = const_cast(ad);
togli asterisco dopo double nel const_cast
double * p_ad = const_cast(ad);

sto compilando in c++ e il compilatore è molto attento ai tipi e non posso convertire una variabile in un puntatore, posso creare un puntatore a quella variabile come ho fatto io, solo che se questa è un'array non funziona e volevo capire se è un errore o una regola:

Codice: Seleziona tutto

#include <iostream>
int main() {
 const double ad[3] = {1,2,3};
 double * p_ad = const_cast<double *>(ad);//se p_ad non è un puntatore posso mettere const_cast<double>(ad)
 p_ad[0] = 2; //a questo punto ottengo un segment fault

const double noarray = 10;
double * p_noarray = const_cast<double *>(noarray);
*p_noarray = 15; //questo funziona
}

[Dahman]

Ciao
A me sembra strano: la prima assegnazione

p_ad[0] = 2;

dovrebbe funzionare senza problemi, perché scrivendo

const double ad[3] = {1,2,3};
double * p_ad = const_cast(ad);
p_ad[0] = 2;

é esattamente come scrivere

double ad[3] = {1,2,3};
ad[0] = 2;

il const_cast non cambia il valore del puntatore ma rende soltanto scrivibile la memoria alla quale punta.

E mi sembra anche strano che ti funzioni il secondo cast

double * p_noarray = const_cast(noarray)

stai tentando di trasformare un (double) in (double *). Come hai detto, giustamente, il C++ é attento ai tipi, quindi non dovrebbe permettertelo.

Che compilatore stai usando?
Appena rientro a casa provo a compilare il tuo esempio e ti potrò confermare o meno quanto ti ho detto.

Ciao

dahman

[virtualmind]

grande!
In effetti ho notato anche io questo ma ho pensato che io il puntatore lo sto dichiarando e assegnando con la stessa istruzione, quindi il compilatore prima crea il puntatore e poi lo trasforma da const double* a double*. In effetti con variabili di tipo standard e non array funziona, il const_cast mi toglie la qualificazione di const e io posso poi scrivere in quella locazione.

Cmq il compilatore è g++ di ubuntu 4.2.3-2ubuntu7.
Ti allego anche l'intero esercizio che ho fatto così non lo riscrivi:

Codice: Seleziona tutto

/*
esercizio 27 volume 1 capitolo 3
- creare array const double e volatile double.
- elencare ogni array
- usare const_cast per cambiare ogni elemento in non cast e non volatile rispettivamente e assegnare un valore ad ognuno
*/

#include <iostream>

using namespace std;

int main() {
 const double cd[3] = {100,200,300};
 volatile double vd[3] = {101,201,301};
 for (int i=0; i<3; i++)
  cout << "const double cd[" << i << "]: " << cd[i] << " - volatile double vd[" << i << "]: " << vd[i] << endl;
 const double * constpcd = cd;
 double * p_cd = const_cast<double *>(constpcd);
 double static * p_vd = const_cast<double *>(vd);
 for (int i=0; i<3; i++) {
  p_cd[i] *= i; // genera un segment foult
  p_vd[i] *= i;
 }
 cout << "Gli array dopo che sono stati modoficati tramite puntatore: " << endl << endl;
 for (int i=0; i<3; i++)
  cout << "const double cd[" << i << "]: " << cd[i] << " - volatile double vd[" << i << "]: " << vd[i] << endl;
 return 0;
}

Grazie Dahman.

[Dahman]

Dopo vari tentativi e prove, ecco il risultato:
Su Linux (gcc 4.2.1) non funziona
Su Windows (gcc 3.4.5) funziona tutto regolarmente.

Incuriosito, sono andato a leggere qua e la su vecchi libri che avevo e ho scoperto questo:
const double x;
const double *cpx = &x;
double *px = const_cast(cpx);
*cpx =3; //risultato indefinito (non garantito), quindi assegnazione non permessa

invece,
double x;
const double *cpx = &x;
double *px = const_cast(cpx);
*cpx =3; //assegnazione permessa con risultato regolare

Quindi il const_cast non va usato se la variabile originale é const, ma funziona se soltanto il puntatore é costante.

Non si finisce mai di imparare!

Ciao

Dahman

[lurebu]

Dopo vari tentativi e prove, ecco il risultato:
...

stesso risultato.
Avevo cercato in giro per vedere se ci fosse qualche eccezione alla regola, ma senza risultato  :-\

Quindi il const_cast non va usato se la variabile originale é const, ma funziona se soltanto il puntatore é costante.

che ha pensarci bene ... potrebbe avere anche senso ... per una questione di allocazione della memoria dovuta al const.

Non si finisce mai di imparare!

Ciao

Dahman

Questo è sicuro ...
e comunque i libri a cui fai riferimento .. sono veramente buoni. Googolando in giro non avevo trovato nulla di simile, a parte il fatto ,che mi aveva incuriosito, che il const_cast venisse risolto a livello di compilazione ..

Ma per curiosità .. a parte il caso del compito assegnato .. ma vi è mai capitato di usarla ?
A me no .. bho  ???

[virtualmind]

Ho avuto una settimana tosta, tanto che ho lasciato un attimo il pc accesso e invece adesso mi sto riavvicinando!

Dahman sei eccezionale!

In effetti il libro che sto studiando è una edizione del 2003 e quindi i compilatori su cui sono basati gli esempi si comportavano diversamente.

Ho trovato poi sul C++ International Standard (5.2.11 - const_cast) diverse condizioni per il suo utilizzo e una di queste spiega proprio che la conversione del solo qualificatore di un puntatore utilizzando const_cast.

inserisco la citazione perchè può darsi anche che ho capito male, a proposito ma non ci sarebbe in italiano il c++ international standard?

  [ Note: some conversions which involve only changes in cv-qualification cannot be done using const_cast. For
12
  instance, conversions between pointers to functions are not covered because such conversions lead to values whose use
  causes undefined behavior. For the same reasons, conversions between pointers to member functions, and in particular,
the conversion from a pointer to a const member function to a pointer to a non-const member function, are not covered.
— end note ]