C++ : Practica 4: Constantes en C++

Las constantes son expresiones con un valor fijo.

Literales

Los Literales son el tipo más obvio de constantes. Expresan valores particulares dentro del código fuente de un programa. Ya hemos utilizado algunos literales en capítulos anteriores para dar valores específicos a variables o para expresar mensajes que queríamos imprimir en pantalla, como por ejemplo, cuando escribimos:

a = 5;

El 5 en este pedazo de código era una constante literal.
Las constantes literales se pueden clasificar en:

• enteros integers, 
• punto flotante, 
• caracteres char, 
• cadenas strings, 
• booleanos bool, 
• punteros y 
• literales definidas por el usuario.

Números Enteros Integer: 

1776
707
-273

Estas son constantes numéricas que identifican valores enteros integer. Tenga en cuenta que no se encierran entre comilllas o cualquier otro tipo carácter especial; ya que son una simple sucesión de cifras que representan un número entero en la base decimal; por ejemplo: 1776 representa siempre el valor mil setecientos setenta y séis.
Tambien tenemos los números decimales y C++ permite el uso de números octales (osea de base 8) y números hexadecimales (base 16) como constantes literales. Para literales octales, los dígitos están precedidos de un carácter 0 (cero). Y para hexadecimal, están precedidos por los caracteres 0x (cero, x). Por ejemplo, las siguientes contantes literales son todas equivalentes entre sí:

75
0113
0x4b

Todos ellos representan el mismo número que es: 75 (setenta y cinco) expresado como un numeral de base 10, numeral octal (0113) y numeral hexadecimal (0x4b), respectivamente.
Estas constantes literales tienen un tipo, al igual que las variables.
Por defecto, literales enteros son de tipo int. Sin embargo, ciertos sufijos pueden añadirse a un literal entero, para especificar un tipo de entero diferente:

Sufijo	Tipo de Modificador
u ó U
	unsigned
l ó L
	long
ll ó LL
	long long

Unsigned se puede combinar con cualquiera de los otros dos en cualquier orden para formar unsigned long ó unsigned long long.
Por ejemplo:

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

En todos los casos encima, el sufijo puede ser especificado usando letras mayúsculas ó minúsculas.

Numeros de Punto Flotante

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

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 el lenguaje C++.

• El primer numero 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) y
• El cuarto es el número 3 expresado como literal numérico con punto flotante.

El tipo predetermiando para literales de punto flotante es double. Los literales de tipo flotante de tipo float ó long double se pueden especificar agregando uno de los siguientes sufijos:

Sufijo	Tipo
f ó F
	float
l ó 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) pueden ser escritas utilizando letras mayúsculas o minúsculas sin diferencia de significado.

Literales de caracteres y strings 

Los literales de caracteres y strings son colocados entre aspas ( ' ' ), veamos:

'z'
'p'
"Hello World"
"How do you do?"

Las dos primeras expresiones representan literales de un sólo carácter y las dos siguientes representan literales de strings compuestas de varios carácteres.
Observe que para representar un sólo carácter lo hemos incluído entre comillas simples ('z' ó 'p') y para expresar una string (que generalmente consta de más de un carácter), la incluimos con caracteres entre comillas dobles ( "Hello World" ó "How do you do?" ).
Los literales de un sólo carácter y de string requieren comillas que los rodeen para distinguirlos de posibles identificadores de variables o palabras claves reservadas. Observe la diferencia entre estas dos expresiones:

x
'x'

Aquí x sin aspas se refiere a un identificador, como el nombre de una variable o un tipo compuesto, mientras que 'x' (entre aspas simples) se referiría al carácter literal 'x' (o carácter que representa una letra minúscula x).
Caracteres y literales de strings tambien pueden representar caracteres especiales que son difíciles o imposibles de expresar de otra manera en el código fuente del programa, como por ejemplo nueva línea (\n) ó tab (\t). Estos caracteres especiales están todos precedidos por un carácter de barra invertida (\).
Aquí tiene usted una lista de códigos de escape de un sólo carácter:

Código de Escape	Descripción
\n
	Nueva línea
\r
	retornar
\t
	Tabulación
\v
	Tab Vertical
\b
	backspace
\f
	Feed de formulário (feed de página)
\a
	alert (beep)
\'
	Comilla simple single quote
\"
	Comilla Doble double quote
\?
	Simbolo de interrogación
\\
	back slash

Por ejemplo:

'\n'
'\t'
"izquierda \t Derecha"
"uno\ndos\ntres"

Internamente, las computadoras representan a estos personajes como códigos numéricos: los ordenadores normalmente usan una extensión del sistema de codificación de caracteres ASCII (para ver más informaciones entre aquí). Los caracteres tambien se pueden representar en literales usando su código numérico escribiendo un carácter de barra invertida (\) seguido por el código expresado como un número octal (base-8) ó hexadecimal (base 16). 

• Para un valor octal, la barra invertida es seguida directamente por los dígitos; 
• mientras que para un valor hexadecimal, un carácter x se inserta entre la barra diagonal invertida y los dígitos hexadecimales a continuación (por ejemplo: \x20 ó \ x4A).

Varios literales de string pueden ser concatenados para formar una cadena literal, esto se realiza simplemente separándolos por uno o más espacios en blanco, incluyendo pestañas tabs (\t), líneas nuevas newlines (\n) y otros caracteres en blanco válidos. Por ejemplo:

"esto forma" "una sola"     " cadena " 
"de caracteres" 

Lo anterior es una cadena literal equivalente a:

"esto formauna sola cadena de caracteres"

Observe como los espacios dentro de las aspas son parte del literal mientras que los que estan fuera no lo son.

x = "string expresado en \
dos lineas"

es equivalente a:

x = "string expresado en dos lineas"

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

Prefijo	Tipo de Carácter
u
	char16_t
U
	char32_t
L
	wchar_t

Tenga en cuenta que, a diferencia de los sufijos de tipo para literales enteros, estos prefijos son sensibles a mayúsculas y minúsculas:

• minúsculas para char16_t y
• mayúsculas para char32_t y wchar_t

Para literales de cadenas, aparte de lo anterior u, U y L, existen dos prefijos adicionales:

Prefijo	Descripción
u8
	El literal de string se codifica en el ejecutable usando UTF-8
R
	El literal de string es un string sin formato

En cadenas sin formato, las barras invertidas backslashes y las comillas simples y dobles son carácteres válidos; el contenido del literal está delimitado por un inicial R "secuencia (y un final) secuencia", donde secuencia es cualquier secuencia de caracteres(incluyendo una scuencia vacía).
El contenido de la cadena es lo que está dentro del paréntesis, ignorando la secuencia de delimitación en sí. Por ejemplo:

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

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

Otros Literales

Existen 3 literales de palabras claves en C++, 

• true,
• false y
• nullptr

true y false son los dos valores posibles para variables de tipo bool.

nullptr es el valor del puntero nulo.

bool foo = true;
bool bar = false;
int* p = nullptr;

Tipos de Expresiones Constantes

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

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

A continuación, podemos utilizar estos nombres en lugar de los literales que se definieron, veamos esto en un ejemplo práctico:

//constantes
#include <iostream>
using namespace std;
//declarando constantes
const double pi = 3.14159;
const char nuevalinea = '\n';

int main()
{
    //declarando variables
    double r = 5.0;  //radio
    double circulo;

    circulo = 2 * pi * r;
    cout << circulo;
    cout << nuevalinea; 
}

Definiciones de PreProcesador (#define)

Otro mecanismo para nombrar valores constantes es el uso de definiciones de preprocesador. Estos tienen el siguiente formato:

#define identifier replacement

Después de esta directiva #define, cualquier ocurrencia de identificador en el código se interpreta como reemplazo replacement, donde "replacement" es cualquier secuencia de caracteres (hasta el final de la línea).
Este reemplazo es realizado por el preprocesador y sucede antes de que el programa sea compilado, provocando así una especie de reemplazo ciego: la validez de los tipos o sintaxis involucradas, no serán comprobadas de ninguna manera.
Por ejemplo:

//constantes
#include <iostream>
using namespace std;
//declarando constantes
#define PI 3.14159
#define NUEVALINEA '\n'
int main()
{
    //declarando variables
    double r = 5.0;  //radio
    double circulo;

    circulo = 2 * pi * r;
    cout << circulo;
    cout << nuevalinea; 
}

Note usted que las lineas #define son directivas de pre-procesador y como tales son instrucciones de una sola línea - como las declaraciones C++ - no requieren punto y coma (;) al final, la directiva se extiende automáticamente hasta el final de la línea!, interezante no?

Culminado y entendido este paso, habremos llegado a una parte importante más de conocimientos para empezar a trabajar con C++, no podemos desistir si queremos llegar a desenvolver cualquier cosa con este maravilloso lenguaje!, más adelante veremos lo que son los Operadores en este lenguaje con lo cual iremos practicando con varios programas más complejos. No deje de practicar, eso es vital!