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.
http: // stackoverflow.com/questions/455518/how-many-and-which-are-the-uses-of-const-in-c – karlphillip
@karlphillip: No es una respuesta. Eso enumera los usos de const en C++, pero no enumera las diferencias en const entre C y C++. Completamente diferente. –
Si supuestamente fuera una respuesta, lo habría publicado como tal. – karlphillip