Véndeme en constante corrección

Entonces, ¿por qué es exactamente que siempre se recomienda usar const con la mayor frecuencia posible? Me parece que usar const puede ser más un dolor que una ayuda en C ++. Pero, de nuevo, estoy llegando a esto desde la perspectiva de Python: si no quieres que algo cambie, no lo cambies. Dicho esto, aquí hay algunas preguntas:

1. Parece que cada vez que marco algo como constante, obtengo un error y tengo que cambiar alguna otra función en algún lugar para que también sea constante. Entonces esto hace que tenga que cambiar otra función en otro lugar. ¿Es esto algo que se vuelve más fácil con la experiencia?

2. ¿Los beneficios de usar const son realmente suficientes para compensar el problema? Si no tiene la intención de cambiar un objeto, ¿por qué no simplemente no escribir código que no lo cambie?

Debo señalar que en este momento, estoy más enfocado en los beneficios de usar const para propósitos de corrección y mantenibilidad, aunque también es bueno tener una idea de las implicaciones de rendimiento.

Este es el artículo definitivo sobre "corrección de const": https://isocpp.org/wiki/faq/const-correctness .

En pocas palabras, usar const es una buena práctica porque ...

1. Te protege de cambiar accidentalmente variables que no están destinadas a ser cambiadas,
2. Le protege de realizar asignaciones variables accidentales, y

3. El compilador puede optimizarlo. Por ejemplo, estás protegido de

   if( x = y ) // whoops, meant if( x == y )

Al mismo tiempo, el compilador puede generar un código más eficiente porque sabe exactamente cuál será el estado de la variable / función en todo momento. Si está escribiendo un código C ++ ajustado, esto es bueno.

Tiene razón en que puede ser difícil usar la corrección constante constantemente, pero el código final es más conciso y más seguro para programar. Cuando haces mucho desarrollo de C ++, los beneficios de esto se manifiestan rápidamente.

Aquí hay un fragmento de código con un error común que la corrección constante puede protegerlo contra:

void foo(const int DEFCON)
{
   if (DEFCON = 1)     //< FLAGGED AS COMPILER ERROR! WORLD SAVED!
   {
       fire_missiles();
   }
}

Parece que cada vez que marco algo como constante, obtengo un error y tengo que cambiar alguna otra función en algún lugar para que también sea constante. Entonces esto hace que tenga que cambiar otra función en otro lugar. ¿Es esto algo que se vuelve más fácil con la experiencia?

Por experiencia, este es un mito total. Ocurre cuando no const-correct se sienta con el código const-correct, claro. Si diseña const-correct desde el principio, esto NUNCA debería ser un problema. Si hace algo constante, y luego algo más no se cumple, el compilador le está diciendo algo extremadamente importante, y debe tomarse el tiempo para arreglarlo correctamente .

No es para ti cuando escribes el código inicialmente. Es para alguien más (o usted unos meses más tarde) que está mirando la declaración del método dentro de la clase o interfaz para ver qué hace. No modificar un objeto es una información importante para obtener de eso.

Si usa const rigurosamente, se sorprenderá de las pocas variables reales que hay en la mayoría de las funciones. A menudo no es más que un contador de bucle. Si su código está llegando a ese punto, tiene una sensación cálida en el interior ... validación por compilación ... el reino de la programación funcional está cerca ... casi puede tocarlo ahora ...

const es una promesa que está haciendo como desarrollador y que cuenta con la ayuda del compilador para hacer cumplir.

Mis razones para ser constante:

• Se comunica a los clientes de su función que no cambiará la variable u objeto
• Aceptar argumentos por referencia constante le brinda la eficiencia de pasar por referencia con la seguridad de pasar por valor.
• Escribir sus interfaces como const correct permitirá a los clientes usarlas. Si escribe su interfaz para tomar referencias que no sean const, los clientes que usan const necesitarán desechar la const para poder trabajar con usted. Esto es especialmente molesto si su interfaz acepta caracteres no constantes * y sus clientes usan cadenas std ::, ya que solo puede obtener un tipo constante * de ellos.
• El uso de const hará que el compilador lo mantenga honesto para que no cambie por error algo que no debería cambiar.

Mi filosofía es que si va a utilizar un lenguaje quisquilloso con comprobaciones de tiempo de compilación, haga el mejor uso posible. constes una forma forzada por el compilador de comunicar lo que quiere decir ... es mejor que los comentarios o el doxygen. Estás pagando el precio, ¿por qué no deducir el valor?

Programar C ++ sin constante es como conducir sin el cinturón de seguridad.

Es difícil ponerse el cinturón de seguridad cada vez que sube al automóvil, y 364 de los 365 días llegará seguro.

La única diferencia es que cuando tenga problemas con su automóvil, lo sentirá de inmediato, mientras que con la programación sin constante puede que tenga que buscar durante dos semanas lo que causó ese accidente solo para descubrir que descuidó inadvertidamente un argumento de función que Has pasado por referencia no constante para la eficiencia.

Para la programación incrustada, el uso constprudente al declarar estructuras de datos globales puede ahorrar una gran cantidad de RAM al hacer que los datos constantes se ubiquen en ROM o flash sin copiarlos en la RAM en el momento del arranque.

En la programación diaria, el uso constcuidadoso le ayuda a evitar escribir programas que se bloquean o se comportan de manera impredecible porque intentan modificar los literales de cadena y otros datos globales constantes.

Cuando trabaje con otros programadores en proyectos grandes, el uso constadecuado ayuda a evitar que otros programadores lo estrangulen.

constle ayuda a aislar el código que "cambia las cosas" a sus espaldas. Entonces, en una clase, marcaría todos los métodos que no cambien el estado del objeto como const. Esto significa que las constinstancias de esa clase ya no podrán llamar a ningún constmétodo que no sea . De esta forma, no podrá llamar accidentalmente a la funcionalidad que puede cambiar su objeto.

Además, constforma parte del mecanismo de sobrecarga, por lo que puede tener dos métodos con firmas idénticas, pero uno con consty otro sin él. El uno con constse llama para constreferencias, y el otro se llama para no constreferencias.

Ejemplo:

#include <iostream>

class HelloWorld {
    bool hw_called;

public:
    HelloWorld() : hw_called(false) {}

    void hw() const {
        std::cout << "Hello, world! (const)\n";
        // hw_called = true;  <-- not allowed
    }

    void hw() {
        std::cout << "Hello, world! (non-const)\n";
        hw_called = true;
    }
};

int
main()
{
    HelloWorld hw;
    HelloWorld* phw1(&hw);
    HelloWorld const* phw2(&hw);

    hw.hw();    // calls non-const version
    phw1->hw(); // calls non-const version
    phw2->hw(); // calls const version
    return 0;
}

la corrección constante es una de esas cosas que realmente necesita estar en su lugar desde el principio. Como ha encontrado, es un gran dolor agregarlo más tarde, especialmente cuando hay mucha dependencia entre las nuevas funciones que está agregando y las funciones antiguas no correctas que ya existen.

En gran parte del código que escribo, realmente valió la pena el esfuerzo porque tendemos a usar mucho la composición:

class A { ... }
class B { A m_a; const A& getA() const { return m_a; } };

Si no tuviéramos una corrección constante, entonces tendría que recurrir a devolver objetos complejos por valor para asegurarse de que nadie estuviera manipulando el estado interno de la clase B a sus espaldas.

En resumen, la corrección constante es un mecanismo de programación defensivo para salvarse del dolor en el futuro.

Digamos que tiene una variable en Python. Sabes que no debes modificarlo. ¿Qué pasa si accidentalmente lo haces?

C ++ te brinda una forma de protegerte de hacer accidentalmente algo que no se suponía que pudieras hacer en primer lugar. Técnicamente puedes evitarlo de todos modos, pero tienes que hacer un trabajo extra para dispararte.

Hay un buen artículo aquí sobre const en c ++. Es una opinión bastante directa, pero espero que ayude a algunos.

Cuando usa la palabra clave "const", está especificando otra interfaz para sus clases. Hay una interfaz que incluye todos los métodos, y una interfaz que incluye solo los métodos const. Obviamente, esto le permite restringir el acceso a algunas cosas que no desea cambiar.

Sí, se hace más fácil con el tiempo.

Me gusta la corrección constante ... en teoría. Cada vez que he tratado de aplicarlo rigurosamente en la práctica, finalmente se ha roto y const_cast comienza a arrastrarse para hacer que el código sea feo.

Tal vez son solo los patrones de diseño que uso, pero const siempre termina siendo un pincel demasiado ancho.

Por ejemplo, imagine un motor de base de datos simple ... tiene objetos de esquema, tablas, campos, etc. Un usuario puede tener un puntero de 'tabla constante', lo que significa que no puede modificar el esquema de la tabla en sí ... pero ¿qué pasa con la manipulación? los datos asociados con la tabla? Si el método Insert () está marcado como constante, internamente tiene que desechar la constante para manipular realmente la base de datos. Si no está marcado como constante, no protege contra la llamada al método AddField.

Tal vez la respuesta sea dividir la clase en función de los requisitos de constancia, pero eso tiende a complicar el diseño más de lo que me gustaría por el beneficio que aporta.

Puede dar al compilador pistas const también ... según el siguiente código

#include <string>

void f(const std::string& s)
{

}
void x( std::string& x)
{
}
void main()
{
    f("blah");
    x("blah");   // won't compile...
}