perché il valore viene modificato anche in una funzione const?

Question

#include<iostream> 
using namespace std; 

class temp 
    { 
     int value1; 
     public : 
     void fun() const 
     { 
     ((temp*)this)->value1 = 10; 
     } 
     void print() 
     { 
      cout<<value1<<endl; 
     } 
    }; 
int main() 
{ 
    temp t; 
    t.fun(); 
    t.print(); 
} 

Answer 1

Perché si sta gettando via const ...

Quando lanci una cosa, la responsabilità è tua per fare in modo che non fa qualcosa di stupido.

---

Nota che se temp t; viene modificato in const temp t;, si ottiene un comportamento indefinito, per la modifica di un valore const.

Per coincidenza ho letteralmente toccato questo in my blog. (Quasi la stessa funzione anche.)

Answer 2

Il C++ cerca di prevenire errori accidentali, ma non si sforza di combattere un programmatore che è determinato a fare le cose a modo suo. Se usi gli operatori del cast gli stai dicendo "fidati di me, so cosa c'è", chiedendo di ignorare la propria conoscenza del programma. È proprio perché l'operatore di casting in stile C che hai usato è pericoloso e può essere facilmente utilizzato in modo improprio che C++ introduce static_cast, const_cast e reinterpret_cast, che comunicano l'intento del programmatore in modo tale che il compilatore possa ancora dire "hey, tieni lì , che richiederebbe più del solo tipo di clemenza che stai chiedendo ". reinterpret_cast è il grande papà però ... non discutere con quello ... altrettanto brutale quanto il cast di C e raramente necessario in un'applicazione di alto livello. Proprio perché raramente è necessario, prolisso e facilmente visibile, richiama l'attenzione. Il codice disseminato di cast in stile C può nascondere facilmente i bug.

Answer 3

$ 5,4/5 è di circa explicit type conversion (che è quello che viene utilizzato qui)

Le conversioni eseguite da

- un const_cast (5.2.11),

- uno static_cast (5.2.9),

- uno static_cast seguito da un const_cast,

- una ri interpret_cast (5.2.10), o

- un reinterpret_cast seguito da un const_cast,

possono essere eseguite utilizzando la notazione cast di conversione esplicita. Si applicano le stesse restrizioni e comportamenti semantici semantica. Se una conversione può essere interpretato in più di uno dei modi di cui sopra, l'interpretazione che appare per primo nella lista è utilizzato, anche se un cast risultante da che l'interpretazione è mal formati. Se una conversione può essere interpretata in più di un modo come un static_cast seguito da un const_cast, la conversione non è corretta.

In questo caso, ((temp*)this) è stato trattato come (const_cast<temp *>(this)) ed era ben formato. Questo rimosse la costanza, permettendo così di cambiare il valore del membro della classe.