¿En qué se diferencia "const" en C y C++?

Question

¿Cómo difiere la calificación de const en las variables en C y C++?

de: Does "const" just mean read-only or something more?

"¿Qué le pide a esta pregunta era esta respuesta: https://stackoverflow.com/questions/4024318#4024417 donde afirma const 'sólo' significa solo lectura en C. pensé que eso es todo const significaba, independientemente de si se trataba de C o C++ . ¿Qué quiere decir?"

Answer 1

const en C no se puede utilizar para crear expresiones constantes.

Por ejemplo:

#include <stdio.h> 
int main() 
{ 
    int i = 2; 
    const int C = 2; 
    switch(i) 
    { 
     case C : printf("Hello") ; 
     break; 

     default : printf("World"); 
    } 
} 

no funciona en C porque etiqueta caso no se reduce a una constante entera.

Answer 2

const significa que usted prometen no mutar la variable. Todavía podría ser cambiado.

class A { 
    public: 
    A(const int& a); 
    int getValue() const; 
    void setValue(int b); 
    private: 
    const int& a; 
}; 
A::A(a) : a(a) {} 
int A::getValue() const { 
    return a; 
} 
void A::setValue(int b) { 
    a = b; // error 
} 

int main() { 
    int my_a = 0; 
    A a(my_a); 
    std::cout << a.getValue() << std::endl; // prints 0 
    my_a = 42; 
    std::cout << a.getValue() << std::endl; // prints 42 
} 

Ningún método A::* puede cambiar a, pero main lata. Eso es idéntico entre C y C++.

---

Lo que sí tiene ++ C son una pareja (limitados) formas de evitar const, que se supone para disuadir a los programadores de descartar const inapropiada.

Tome una clase como esta.

class A { 
    public: 
    A(); 
    int getValue(); 
    private: 
    static int expensiveComputation(); 
    int cachedComputation; 
}; 

A::A() : cachedComputation(0) {} 

A::getValue() { 
    if (cachedComputation == 0) 
     cachedComputation = expensiveComputation(); 
    return cachedComputation; 
} 

cachedComputation significa implícitamente this->cachedComputation. Mantén esto en mente.

int main() { 
    A a1; 
    const A a2; 
    std::cout << a1.getValue() << std::endl; 
    std::cout << a2.getValue() << std::endl; // error 
} 

a2.getValue() es ilegal, ya que un método no const está siendo llamado en un const A a2. Se podría desecharon la -ness const ...

std::cout << ((A&)a2).getValue() << std::endl;   // C-style cast 
    std::cout << const_cast<A&>(a2).getValue() << std::endl; // C++-style cast 

El segundo es preferido, porque el compilador comprobará que sólo el const -ness está siendo fundido, nada más. Sin embargo, esto todavía no es ideal. En cambio, debería haber un nuevo método agregado a la clase.

class A { 
    public: 
    int getValue() const; 
}; 

A::getValue() const { 
    if (cachedComputation == 0) 
     cachedComputation = expensiveComputation(); // error 
    return cachedComputation; 
} 

Ahora hay un método const, por lo a2.getValue() está muy bien. Sin embargo, el const final significa que el método recibe un puntero const A *this, no un puntero A *this como de costumbre, lo que hace que this->cachedComputation sea que no se puede mutar.

const_cast podría aplicarse dentro del método, pero sería mejor cambiar la declaración de este miembro.

class A { 
    private: 
    mutable int cachedComputation; 
}; 

Ahora, incluso con un const A *this, this->cachedComputation puede mutarse sin poner.