Xnechijli01

Freelancer

Xnechijli01 Freelancer

Constantes en C++

Logotipo del Freelancer Xnechijli01

Freelancer Xnechijli01: Construimos tus sitios web con SEO onpage y SEO ofpage. Contáctanos pulsando esta imágen.

Constantes en C++. Te damos la bienvenida a este capítulo de nuestro curso de C++ dedicado a la programación de este lenguaje. Ahora estaremos hablando de las constantes. Las constantes son expresiones con un valor fijo.

Tipos de constantes

Constantes literales en C++

Las constantes literales son las más obvias. Se utilizan para expresar valores particulares dentro del código fuente de un programa. Ya hemos usado algunos en capítulos anteriores de este curso de C++ para dar valores específicos a variables o para expresar mensajes que queríamos que nuestros programas imprimieran, por ejemplo, cuando escribimos:

a = 5;

El 5 en esta pieza de código fue una constante literal.

Las constantes literales se pueden clasificar en entero, coma flotante, caracteres, cadenas, booleanos, punteros y literales definidos por el usuario.

Números enteros

1776
707
-273

Estas son constantes numéricas que identifican valores enteros. Ten en cuenta que no deben estar entre comillas o cualquier otro carácter especial porque son una simple sucesión de dígitos que representan un número entero en base decimal. En terminos sencillos, por ejemplo, 1776 siempre representa el valor mil setecientos setenta y seis.

Además de los números decimales (los que la mayoría de nosotros usamos todos los días), C++ permite el uso de números octales (base de 8) y números hexadecimales (base de 16) como constantes literales. Para los literales octales, los dígitos van precedidos de un carácter 0 (cero). Y para el hexadecimal, están precedidos por los caracteres 0x (cero equis). Por ejemplo, las siguientes constantes literales son todas equivalentes entre sí:

75 // decimal
0113 // octal
0x4b // hexadecimal

Todos estos representan el mismo número: 75 (setenta y cinco) expresados ​​como un número de base 10, un número octal y un número hexadecimal, respectivamente.

Estas constantes literales tienen un tipo, al igual que las variables. Por defecto, los literales enteros son de tipo int. Sin embargo, ciertos sufijos se pueden agregar a un literal entero para especificar un tipo entero diferente:

SufijoModificador de tipo
u o U Sin firmar
l o L Largo
ll o LL Largo largo

U (sin firmar) puede combinarse con cualquiera de los otros dos en cualquier orden para formar un unsigned long (sin firmar largo) o un unsigned long long (sin firmar largo largo).

Por ejemplo:

75 //int
75u //unsigned int
75l //long
75ul //unsigned long
75lu //unsigned long

En todos los casos anteriores, el sufijo se puede especificar usando letras mayúsculas o minúsculas.

Números de punto flotante

Expresan valores reales, con decimales y / o exponentes. Pueden incluir un punto decimal, un carácter "e" (que expresa "por diez en la altura X" , donde X es un valor entero que sigue al carácter "e" ), o un punto decimal y un carácter "e":

3.14159 //3.14159
6.02e23 //6.02 x 10^23
1.6e-19 //1.6 x 10^-19
3.0 //3.0

Estos son cuatro números válidos con decimales expresados ​​en C++. El primer número es PI, el segundo es el número de Avogadro, el tercero es la carga eléctrica de un electrón (un número extremadamente pequeño), todos ellos aproximados, y el último es el número tres expresado como flotante.

Punto numérico literal.

El tipo predeterminado para los literales de punto flotante es doble. Los literales de punto flotante de tipo float (flotante) o long double (doble largo) pueden especificarse agregando uno de los siguientes sufijos:

Sufijo Tipo
f o F float
l o L long double

Por ejemplo:

3.14159L //long double
6.02e23f //float

Cualquiera de las letras que pueden formar parte de una constante numérica de punto flotante ( e , f , l ) puede escribirse con letras mayúsculas o minúsculas sin diferencia de significado.

Literales de caracteres y cadenas en C++

Los literales de caracteres y cadenas están entre comillas:

'z'
'p'
"Hello world"
"¿Cómo estás?"

Las dos primeras expresiones representan literales de un solo carácter y las dos siguientes representan literales de cadena compuestas de varios caracteres. Observa que para representar un solo carácter, lo encerramos entre comillas simples ( ' ), y para expresar una cadena (que generalmente consiste en más de un carácter) encerramos los caracteres entre comillas dobles ( " ).

Tanto los literales de un solo carácter como los de cadena requieren comillas que los rodean para distinguirlos de los posibles identificadores de variables o palabras clave reservadas. Nota la diferencia entre estas dos expresiones:

x
'x'

Aquí, solo x sin comilla se referirá a un identificador, como el nombre de una variable o un tipo compuesto, mientras que 'x' (entre comillas simples) se referirá al literal de carácter 'x' (el carácter que representa una x minúscula carta).

Los literales de caracteres y cadenas también pueden representar caracteres especiales que son difíciles o imposibles de expresar de otro modo en el código fuente de un programa, como nueva línea ( \n ) o pestaña ( \t ). Estos caracteres especiales son todos ellos precedidos por un carácter de barra invertida ( \ ).

Aquí tienes una lista de los códigos de escape de un solo carácter:

Código de escape Descripción
\n nueva línea
\r retorno de carro
\t lengüeta
\v pestaña vertical
\b retroceso
\f avance de página
\a alerta (bip)
\' comilla simple ( ' )
\" comillas dobles ( " )
\? signo de interrogación ( ? )
\\ barra invertida ( \ )

Por ejemplo:

'\n'
'\t'
"Left \t Right"
"one\ntwo\nthree"

Internamente, las computadoras representan los caracteres como códigos numéricos: por lo general, usan una extensión del sistema de codificación de caracteres ASCII (consulta el código ASCII para obtener más información). Los caracteres también se pueden representar en literales usando su código numérico escribiendo un carácter de barra invertida ( \ ) seguido del código expresado como un número octal (base-8) o hexadecimal (base-16). Para un valor octal, la barra invertida va seguida directamente por los dígitos; mientras que para hexadecimal, se inserta un carácter x entre la barra invertida y los dígitos hexadecimales (por ejemplo: \x20 o \x4A ).

Se pueden concatenar varios literales de cadena para formar un literal de cadena simple con solo separarlos con uno o más espacios en blanco, incluidas las pestañas, las nuevas líneas y otros caracteres en blanco válidos. Por ejemplo:

"Esto es solo" "un ejemplo" " de cadena " "de carácteres"

Lo anterior es una cadena literal equivalente a:

"Esto es soloun ejemplo de cadena de carácteres"

Al ver esta línea no llegues a la conclución que está mal escrita. Observa cómo los espacios dentro de las comillas son parte del literal, mientras que los que están fuera de ellas no lo son.

Algunos programadores también utilizan un truco para incluir literales de cadena larga en varias líneas: en C++, una barra diagonal inversa ( \ ) al final de la línea se considera un carácter de continuación de línea que combina esa línea y la siguiente en una sola línea. Por lo tanto el siguiente código:

x = "Cadena expresada en \ dos líneas"

es equivalente a:

x = "Cadena expresada en dos líneas"

Todos los literales de caracteres y literales de cadena descritos anteriormente están hechos de caracteres de tipo char. Se puede especificar un tipo de carácter diferente utilizando uno de los siguientes prefijos:

Prefijo Tipo de caracter
u char16_t
U char32_t
L wchar_t

Ten en cuenta que, a diferencia de los sufijos de tipo para literales enteros, estos prefijos char16_t entre mayúsculas y minúsculas: minúsculas para char16_t y mayúsculas para char32_t y wchar_t .

Para los literales de cadena, aparte de los anteriores u , U y L , existen dos prefijos adicionales:

Prefijo Descripción
u8 La cadena literal está codificada en el ejecutable usando UTF-8
R La cadena literal es una cadena en bruto

En cadenas sin formato, las barras invertidas y las comillas simples y dobles son todos caracteres válidos; el contenido del literal está delimitado por una R "sequence", donde sequence es cualquier secuencia de caracteres (incluida una secuencia vacía). El contenido de la cadena es lo que se encuentra dentro del paréntesis, ignorando la secuencia delimitadora en sí. Por ejemplo:

R "(string with \backslash)" R "&%$(string with \backslash)&%$"

Las dos cadenas anteriores son equivalentes a "string with \\backslash" . El prefijo R se puede combinar con cualquier otro prefijo, como u , L o u8 .

Expresiones constantes escritas

A veces, es conveniente asignar un nombre a un valor constante:

const double pi = 3.1415926; const char tab = '\t' ;

Luego podemos usar estos nombres en lugar de los literales a los que se definieron para:

#include <iostream>
using namespace std;
const double pi = 3.14159;
const char newline = '\n' ;
int main () {
double r=5.0; // radius double circle;
circle = 2 * pi * r;
cout << circle; cout << newline;
}

Definiciones de preprocesador (#define)

Otro mecanismo para nombrar valores constantes es el uso de definiciones de preprocesador. Tienen la siguiente forma:

#define identifier replacement

Después de esta directiva, cualquier aparición de identifier en el código se interpreta como replacement o (reemplazo), donde reemplazo es cualquier secuencia de caracteres (hasta el final de la línea). Este reemplazo lo realiza el preprocesador y sucede antes de que se compile el programa, lo que provoca una especie de reemplazo ciego: la validez de los tipos o la sintaxis en cuestión no se verifica de ninguna manera.

#include
<iostream>
using namespace std;
#define PI 3.14159
#define NEWLINE '\n'
int main () {
double r=5.0; // radius double circle;
circle = 2 * PI * r;
cout << circle;
cout << NEWLINE;
}

Ten en cuenta que las líneas #define son directivas de preprocesador y, como tales, son instrucciones de una sola línea que, a diferencia de las declaraciones de C++, no requieren puntos y comas (;) al final; La directiva se extiende automáticamente hasta el final de la línea. Si se incluye un punto y coma en la línea, es parte de la secuencia de reemplazo y también se incluye en todas las apariciones reemplazadas. Esto es todo sobre constantes en nuestro curso C++. En nuestra siguiente nota te hablaremos más de este lenguaje de programación.