constante (programación informática)

En algunos lenguajes de programación , `const` es un calificador de tipo (una palabra clave aplicada a un tipo de dato ) que indica que los datos son de solo lectura. Si bien esto se puede usar para declarar constantes , consten la familia de lenguajes C difiere de construcciones similares en otros lenguajes en que es parte del tipo y, por lo tanto, tiene un comportamiento complicado cuando se combina con punteros , referencias, tipos de datos compuestos y verificación de tipos . En otros lenguajes, los datos no están en una sola ubicación de memoria , sino que se copian en tiempo de compilación para cada uso. ^{[ 1 ]} Los lenguajes que lo usan incluyen C , C++ , D , JavaScript , Julia y Rust .

Cuando se aplica en la declaración de un objeto , ^{[ a ]} indica que el objeto es una constante : su valor no puede modificarse, a diferencia de una variable . Este uso básico —declarar constantes— tiene paralelismos en muchos otros lenguajes.

Sin embargo, a diferencia de otros lenguajes, en la familia de lenguajes C, el constes parte del tipo , no parte del objeto . Por ejemplo, en C, declara un objeto de tipo – el es parte del tipo, como si se analizara como "(const int) x" – mientras que en Ada , declara una constante (un tipo de objeto) de tipo: el es parte del objeto , pero no parte del tipo .constintx=1;xconst intconstX:constantINTEGER:=1_XINTEGERconstant

Esto tiene dos consecuencias sutiles. En primer lugar, constse puede aplicar a partes de un tipo más complejo; por ejemplo, const int* const x;declara un puntero constante a un entero constante, mientras que const int* x;declara un puntero variable a un entero constante, y int* const x;declara un puntero constante a un entero variable. En segundo lugar, dado que constforma parte del tipo, debe coincidir como parte de la comprobación de tipos. Por ejemplo, el siguiente código no es válido:

void f ( int & x ); // ... const int i ; f ( i );

porque el argumento de fdebe ser un entero variablei , pero es un entero constante . Esta coincidencia es una forma de corrección del programa y se conoce como corrección constante . Esto permite una forma de programación por contrato , donde las funciones especifican como parte de su firma de tipo si modifican sus argumentos o no, y si su valor de retorno es modificable o no. Esta verificación de tipos es de interés principalmente en punteros y referencias, no en tipos de valor básicos como los enteros, pero también para tipos de datos compuestos o tipos con plantillas como los contenedores . Está oculta por el hecho de que a constmenudo se puede omitir, debido a la coerción de tipos ( conversión de tipo implícita ) y a que C es paso por valor (C++ y D son paso por valor o paso por referencia).

La idea de la constancia no implica que la variable, tal como se almacena en la memoria del ordenador , sea inmodificable. Más bien, constla constancia es una construcción de tiempo de compilación que indica lo que un programador debería hacer, no necesariamente lo que puede hacer. Sin embargo, cabe señalar que, en el caso de datos predefinidos (como const char*literales de cadena ), C constsuele ser inmodificable .

Si bien una constante no cambia su valor mientras el programa se está ejecutando, un objeto declarado constsí puede cambiar su valor mientras el programa se está ejecutando. Un ejemplo común son los registros de solo lectura dentro de los sistemas embebidos, como el estado actual de una entrada digital. Los registros de datos para entradas digitales a menudo se declaran como consty volatile. El contenido de estos registros puede cambiar sin que el programa haga nada ( volatile), pero sería incorrecto que el programa intentara escribir en ellos ( const).

Además, una función miembro (no estática) puede declararse como const. En este caso, el thispuntero dentro de dicha función es de tipo const T*en lugar de simplemente de tipo T*. ^{[ 2 ]} Esto significa que las funciones no constantes para este objeto no pueden ser llamadas desde dentro de dicha función, ni se pueden modificar las variables miembro . En C++, una variable miembro puede declararse como mutable, lo que indica que esta restricción no se aplica a ella. En algunos casos, esto puede ser útil, por ejemplo con el almacenamiento en caché , el conteo de referencias y la sincronización de datos . En estos casos, el significado lógico (estado) del objeto no cambia, pero el objeto no es físicamente constante ya que su representación bit a bit puede cambiar.

En C, C++ y D, todos los tipos de datos, incluidos los definidos por el usuario, pueden declararse como constantes const, y la corrección constante exige que todas las variables u objetos se declaren como tales a menos que necesiten modificarse. Este uso proactivo de las constantes consthace que los valores sean "más fáciles de entender, rastrear y razonar" ^{[ 3 ]} , lo que aumenta la legibilidad y la comprensibilidad del código y simplifica el trabajo en equipo y el mantenimiento del código, ya que comunica información sobre el uso previsto de un valor. Esto puede ayudar tanto al compilador como al desarrollador al razonar sobre el código. También puede permitir que un compilador optimizador genere código más eficiente ^{[ 4 ] .}

void foo ( int * p , const int * cp , int * const pc , const int * const cpc ) { * p = 0 ; // OK: modifica los datos a los que apunta p = NULL ; // OK: modifica el puntero* cp = 0 ; // ¡Error! No se puede modificar el dato al que apunta cp = NULL ; // OK: modifica el puntero* pc = 0 ; // OK: modifica los datos a los que apunta pc = NULL ; // ¡Error! No se puede modificar el puntero* cpc = 0 ; // ¡Error! No se puede modificar el dato al que apunta cpc = NULL ; // ¡Error! No se puede modificar el puntero }

int * p ; // *p es un valor entero const int * cp ; // *cp es una constante int int * const pc ; // pc es una constante int* const int * const cpc ; // cpc es un puntero constante y apunta a un valor constante

const int * cp ; // equivalente a int const* cp, const int * const cpc ; // equivalente a int const* const cpc

int ** pp ; // un puntero a un puntero a enteros const int ** cpp ; // un puntero a un puntero a un valor entero constante (no un puntero a un puntero constante a enteros) int * const * pcp ; // un puntero a un puntero constante a valores enteros (no un puntero constante a un puntero a enteros) int ** const ppc ; // un puntero constante a punteros a enteros (ppc, el identificador, al ser constante no tiene sentido) const int ** const cppc ; // un puntero constante a punteros a valores enteros constantes

// dos formas: int * a ; // asterisco alineado a la izquierda int * a ; // asterisco alineado a la derechaint * a , b ; // confuso (a es un puntero a un int pero b es simplemente un int) int * a , b ; // a es un puntero a un int y b es un intint * a , * b ; // feo (a y b son ambos punteros a enteros, pero esta es una forma incómoda de escribirlo) int * a , * b ;

int * a , * b ; // ilegal en C# int * a , b ; // declara dos int*

int i = 22 ; const int & cr = i ; const int & cr2 = i , cr3 = i ; // confuso: // cr2 es una referencia, pero cr3 no lo es: // cr3 es una constante int inicializada con el valor de i// error: ya que las referencias no pueden cambiar de todos modos. int & const rc = myInt ;// C++: int && rref = int ( 5 ), value = 10 ; // confuso: rref es una referencia a rvalue, pero value es un simple int. int && rref = int ( 5 ), value = 10 ;

En C++, existen cuatro tipos diferentes de const:

• const, la constante de tiempo de ejecución tradicional
• constexpr, una constante o expresión que puede evaluarse en tiempo de compilación (ver constexpr )
• consteval, que declara que cualquier llamada a una función debe producir un valor que sea una expresión en tiempo de compilación.
• constinit, que declara que la expresión tiene inicialización estática (constante)

clase Entero { privado : int i ; público : // observe la etiqueta const [[ nodiscard ]] int get () const noexcept { return i ; }// Nótese la falta de "const" void set ( int j ) noexcept { i = j ; } };void foo ( Integer & nonConstInteger , const Integer & constInteger ) { int y = nonConstInteger . get (); // OK int x = constInteger . get (); // OK: get() es constantenonConstInteger.set ( 10 ); // OK: nonConstInteger es modificable constInteger.set ( 10 ); // ¡ Error! set ( ) es un método no constante y constInteger es un objeto calificado como constante }

importar std ;usando std :: array ;clase IntegerArray { privado : array < int , 100 > datos ; público : [[ nodiscard ]] int & obtener ( int i ) noexcept { return datos [ i ]; }[[ nodiscard ]] int const & get ( int i ) const noexcept { return data [ i ]; } };void foo ( IntegerArray & a , const IntegerArray & ca ) { // Obtiene una referencia a un elemento de la matriz // y modifica su valor referenciado.a.get ( 5 ) = 42 ; // ¡OK! ( Llamada: int& IntegerArray::get(int)) ca.get ( 5 ) = 42 ; // ¡ Error! (Llamada: int const& IntegerArray::get(int) const ) }

En C y C++ existen varias excepciones a la corrección absoluta mediante `const`. Estas excepciones existen principalmente para garantizar la compatibilidad con el código existente.

La primera, que se aplica solo a C++, es el uso de const_cast, que permite al programador eliminar el constcalificador, haciendo que cualquier objeto sea modificable. La necesidad de eliminar el calificador surge al usar código y bibliotecas existentes que no se pueden modificar pero que no son consistentes. Por ejemplo, considere este código:

// Prototipo para una función que no podemos cambiar pero que // sabemos que no modifica el objeto al que apunta. void myLibFunc ( int * p , int size );void callLibFunc ( const int * p , int size ) { myLibFunc ( p , size ); // ¡Error! Elimina el calificador constint * nonConstPtr = const_cast < int *> ( p ); // Eliminar calificador myLibFunc ( nonConstPtr , size ); // OK }

Sin embargo, cualquier intento de modificar un objeto que se declara constmediante una conversión constante produce un comportamiento indefinido según el estándar ISO C++. En el ejemplo anterior, si ptrhace referencia a una variable global, local o miembro declarada como const, o a un objeto asignado en el montón mediante new int const, el código solo es correcto si LibraryFuncrealmente no modifica el valor al que apunta ptr.

El lenguaje C necesita una excepción debido a una situación particular. Se permite definir variables con duración de almacenamiento estática con un valor inicial. Sin embargo, el inicializador solo puede usar constantes, como constantes de cadena y otros literales, y no se le permite usar elementos no constantes, como nombres de variables, independientemente de si los elementos del inicializador están declarados consto no, o de si la variable de duración estática está declarada consto no. Existe una forma no portable de inicializar una constvariable con duración de almacenamiento estática. Al construir cuidadosamente una conversión de tipo en el lado izquierdo de una asignación posterior, constse puede escribir en una variable, eliminando efectivamente el constatributo y "inicializándola" con elementos no constantes, como otras constvariables, etc. Escribir en una constvariable de esta manera puede funcionar como se espera, pero causa un comportamiento indefinido y contradice seriamente la corrección de const.

constexpr size_t BUFFER_SIZE = 8 * 1024 ; const size_t userTextBufferSize ; // El valor inicial depende de const BUFFER_SIZE, no se puede inicializar aquí....int setupUserTextBox ( TextBox * defaultTextBoxType , Rectangle * defaultTextBoxLocation ) { * ( size_t * ) & userTextBufferSize = BUFFER_SIZE - sizeof ( TextBoxControls ); // advertencia: podría funcionar, pero no está garantizado por C ... }

Otra laguna ^{[ 12 ]} se aplica tanto a C como a C++. Específicamente, los lenguajes dictan que los punteros y referencias a miembros son "superficiales" con respecto a la constnaturaleza de sus propietarios; es decir, un objeto contenedor consttiene todos constlos miembros excepto que los miembros a los que apuntan (y los que hacen referencia) siguen siendo mutables. Para ilustrarlo, considere este código C++:

struct MyStruct { int val ; int * ptr ; };void foo ( const MyStruct & s ) { int i = 42 ; s.val = i ; // Error: s es constante, por lo que val es un entero constante s.ptr = & i ; // Error : s es constante, por lo que ptr es un puntero constante a un entero *s.ptr = i ; // OK : los datos a los que apunta ptr siempre son mutables, aunque a veces esto no sea deseable }

Aunque el objeto spasado foo()es constante, lo que hace que todos sus miembros sean constantes, el objeto al que apunta s.ptrsigue siendo modificable, aunque esto puede no ser deseable desde el punto de vista de constla corrección, ya que spodría ser el único propietario del objeto al que apunta. Por esta razón, Meyers argumenta que el comportamiento predeterminado para los punteros y referencias a miembros debería ser la constpropiedad "profunda", que podría ser anulada por un mutablecalificador cuando el objeto al que apunta no pertenece al contenedor, pero esta estrategia crearía problemas de compatibilidad con el código existente. Por lo tanto, por razones históricas , esta laguna permanece abierta en C y C++.

Esta última laguna se puede cerrar usando una clase para ocultar el puntero detrás de una constinterfaz correcta, pero dichas clases o bien no admiten la semántica de copia habitual de un constobjeto (lo que implica que la clase contenedora tampoco se puede copiar mediante la semántica habitual) o permiten otras lagunas al permitir la eliminación de la constnaturaleza a través de una copia inadvertida o intencional.

Finalmente, varias funciones en la biblioteca estándar de C violan la corrección de const antes de C23 , ya que aceptan un constpuntero a una cadena de caracteres y devuelven un constpuntero que no es un puntero a una parte de la misma cadena. strstry strchrestán entre estas funciones. Algunas implementaciones de la biblioteca estándar de C++, como la de Microsoft ^{[ 13 ],} intentan cerrar esta laguna proporcionando dos versiones sobrecargadas de algunas funciones: una constversión " " y una constversión "no ".

El uso del sistema de tipos para expresar constancia conlleva diversas complejidades y problemas, por lo que ha sido criticado y no se ha adoptado fuera de la reducida familia C (C, C++ y D). Java y C#, fuertemente influenciados por C y C++, rechazaron explícitamente constlos calificadores de tipo de estilo , expresando en su lugar la constancia mediante palabras clave que se aplican al identificador ( finalen Java consty readonlyen C#). Incluso dentro de C y C++, el uso de constvaría significativamente, con algunos proyectos y organizaciones que lo utilizan de forma consistente y otros que lo evitan.

char * strchr ( char * s , int c );

if ( p = strchr ( q , '/' )) { * p = ' ' ; }

char * strchr ( char * s , int c ); const char * strchr ( const char * s , int c );

plantilla < T > T * strchr ( T * s , int c ) { ... }

inout ( char )* strchr ( inout ( char )* s , int c );

char * strchr ( const char * s , int c );

En la versión 2 del lenguaje de programación D , existen dos palabras clave relacionadas con `const`. ^{[ 17 ]} La immutablepalabra clave denota datos que no pueden modificarse a través de ninguna referencia. La constpalabra clave denota una vista no mutable de datos mutables. A diferencia de C++ const, D consty immutableson "profundos" o transitivos , y cualquier cosa alcanzable a través de un objeto o es consto respectivamente .immutableconstimmutable

Ejemplo de constante frente a inmutable en D

int [] foo = new int [ 5 ]; // foo es mutable. const int [] bar = foo ; // bar es una vista constante de datos mutables. immutable int [] baz = foo ; // Error: todas las vistas de datos inmutables deben ser inmutables.int [] inmutable nums = new inmutable ( int )[ 5 ]; // No se puede crear ninguna referencia mutable a nums. const int [] constNums = nums ; // Funciona. inmutable es implícitamente convertible a const. int [] mutableNums = nums ; // Error: No se puede crear una vista mutable de datos inmutables.

Ejemplo de constante transitiva o profunda en D

clase LinkedList { int valor ; LinkedList siguiente ; }immutable LinkedList ll = new immutable ( LinkedList ); ll . next . value = 5 ; // No compilará. ll.next es de tipo immutable(LinkedList). // ll.next.value es de tipo immutable(int).

constfue introducido por Bjarne Stroustrup en C con Classes , el predecesor de C++ , en 1981, y originalmente se llamaba readonly. ^{[ 18 ] [ 19 ]} En cuanto a la motivación, Stroustrup escribe: ^{[ 19 ]}

"Cumplía dos funciones: como una forma de definir una constante simbólica que obedece a las reglas de ámbito y tipo (es decir, sin usar una macro) y como una forma de considerar un objeto en memoria como inmutable."

El primer uso, como alternativa tipada y con ámbito definido a las macros, se cumplió de forma análoga para las macros de tipo función mediante la inlinepalabra clave. Los punteros constantes y la * constnotación fueron sugeridos por Dennis Ritchie y, por lo tanto, adoptados. ^{[ 19 ]}

constLuego se adoptó en C como parte de la estandarización, y aparece en C89 (y versiones posteriores) junto con el otro calificador de tipo, volatile. ^{[ 20 ]} Se sugirió un calificador adicional, noalias, en la reunión de diciembre de 1987 del comité X3J11, pero fue rechazado; su objetivo finalmente se cumplió con la restrictpalabra clave en C99 . Ritchie no apoyó mucho estas adiciones, argumentando que no "tenían suficiente peso", pero finalmente no abogó por su eliminación del estándar. ^{[ 21 ]}

Posteriormente, D heredó constde C++, donde se conoce como constructor de tipos (no calificador de tipos ), y añadió dos constructores de tipos más, immutabley inout, para manejar casos de uso relacionados. ^{[ d ]}

Otros lenguajes no siguen el modelo de C/C++ al incluir la constancia como parte del tipo, aunque a menudo presentan construcciones superficialmente similares y pueden usar la constpalabra clave `constante`. Normalmente, esto se utiliza únicamente para constantes (objetos constantes).

C# tiene una constpalabra clave, pero con una semántica radicalmente diferente y más simple: significa una constante en tiempo de compilación y no forma parte del tipo. Es esencialmente equivalente a constexpren C y C++.

Nim tiene una constpalabra clave similar a la de C#: también declara una constante en tiempo de compilación en lugar de formar parte del tipo. Sin embargo, en Nim, una constante puede declararse a partir de cualquier expresión que pueda evaluarse en tiempo de compilación. ^{[ 22 ]} En C#, solo los tipos integrados de C# pueden declararse como const; los tipos definidos por el usuario, incluidas las clases, las estructuras y los arreglos, no pueden ser const. ^{[ 23 ]}

Rust tiene una constpalabra clave similar a la de C#, que declara constantes, funciones y otros símbolos en tiempo de compilación. ^{[ 24 ]} Por lo tanto, es esencialmente equivalente a la constexprde C y C++.

Java no usa const– en su lugar tiene final, que se puede aplicar a las declaraciones de "variables" locales y se aplica al identificador , no al tipo. Tiene un uso orientado a objetos diferente para los miembros de objetos, que es el origen del nombre. La especificación del lenguaje Java considera constcomo una palabra clave reservada – es decir, una que no se puede usar como identificador de variable – pero no le asigna ninguna semántica: es una palabra reservada (no se puede usar en identificadores) pero no una palabra clave (no tiene un significado especial). La palabra clave se incluyó como un medio para que los compiladores de Java detectaran y advirtieran sobre el uso incorrecto de palabras clave de C++. ^{[ 25 ]} Existe una solicitud de mejora para implementar constla corrección en el Proceso de la Comunidad Java , pero se cerró en 2005 basándose en que era imposible implementarla de forma retrocompatible. ^{[ 26 ]}

El Ada 83 contemporáneo tenía de forma independiente la noción de un objeto constante y una constantpalabra clave, ^{[ 27 ] [ e ]} con parámetros de entrada y parámetros de bucle implícitamente constantes. Aquí constantes una propiedad del objeto, no del tipo.

JavaScript tiene una constdeclaración que define una variable con ámbito de bloque que no se puede reasignar ni redeclarar. Define una referencia de solo lectura a una variable que no se puede redefinir, pero en algunas situaciones el valor de la variable en sí puede cambiar, como si la variable se refiere a un objeto y se modifica una propiedad del mismo. ^{[ 28 ]}

• constante
• Asignación única
• restringir
• Alias ​​de punteros

• "Const-Corrección" de Herb Sutter
• "¿Optimización constante?" por Herb Sutter
• Preguntas frecuentes de C++ simplificadas: La corrección de `const` por Marshall Cline
• Sección " Sustitución de valores " del libro electrónico gratuito Thinking in C++ de Bruce Eckel.
• "Aquí hay un const, allí hay un const" de Walter Bright
• "Constante e invariante" de la especificación del lenguaje de programación D, versión 2 (experimental)