Variables en C++

Ing. Juan Camilo Correa Chica

Variables en C++

• ¿Qué son las variables y por qué son necesarias?

• Declaración de variables en C++
• Tipos de datos en C++
• Asignación de memoria a variables
• Ámbito de las variables
• Modificadores de variables
• Calificadores de tipo
• Especificadores de almacenamiento en memoria (storage classes)
¿Qué son las variables y por qué son necesarias?
Las aplicaciones computacionales (programas de escritorio, aplicaciones móviles,
aplicaciones web, aplicaciones embebidas, etc.) son de manera indistinta un conjunto
de procedimientos que manipulan y procesan datos. Esos datos deben de alguna
manera estar disponibles en algún lugar para que los procedimientos puedan acceder
a ellos.

De acuerdo con lo anterior, una variable es un dato de algún tipo, que puede ser
manipulado y que además debe estar almacenado en memoria para que pueda ser
accedido y posteriormente procesado.

En general, una variable dentro de una aplicación es una ubicación de

almacenamiento en memoria identificada por un nombre, y en la cual se almacena un
dato que está caracterizado por su valor y por el tipo en especifico de ese valor.

Ejemplo:

Una variable denominada dato_numerico almacena un dato cuyo valor es

numérico y cuyo tipo es de número entero.

dato_numerico = 55
Declaración de variables en C++

Para declarar una variable en C++ es necesario denominarla con un nombre o

identificador, que debe ser único para cada variable. Y adicionalmente debe
especificarse el tipo de dato que se va almacenar en la variable.

<tipo> <identificador>;

Una buena práctica es inicializar el valor de la variable con un valor por defecto, por lo
general se inicializa con el valor cero.

int my_var = 0;

Notas adicionales:

• C++ es un lenguaje sensible a minúsculas y mayúsculas, es decir: “…una ROSA no

es lo mismo que una Rosa ni una rosa…”
• El primer caracter del identificador puede ser una letra o el underscore (_), no
puede ser un número. El identificador no puede tener espacios ni símbolos.
• No puede usarse una palabra reservada del lenguaje C++ para identificar a una
variable.
Tipos de datos en C++

Para declarar una variable en C++ es necesario denominarla con un nombre o

identificador, que debe ser único para cada variable. Y adicionalmente debe
especificarse el tipo de dato que se va almacenar en la variable.

<tipo> <identificador>;

C++ soporta los siguientes tipos de datos:

• bool (tipo booleano (binario), falso o verdadero, 1 ó 0)

• char (tipo carácter, longitud 1 byte)
• int (tipo entero, longitud 4 bytes)
• float (tipo decimal, longitud 4 bytes)
• double (tipo decimal de alta precisión, longitud 8 bytes)

Ejemplos:
bool my_boolean_var = true;
char my_character_var = 'a';
int my_integer_var = 100;
float my_floating_var = 5.6;
double my_double_var = 3.1415926535
Tipos de datos en C++

Rangos numéricos de los tipos de datos nativos de C++.

• char (tipo carácter, longitud 1 byte)

- Con signo: -128 a 127
- Sin signo: 0 a 255

• int (tipo entero, longitud 4 bytes)

- Con signo: -2147483648 a 2147483647
- Sin signo: 0 a 4294967295

• float (tipo decimal, longitud 4 bytes)

- 3.4E-38 a 3.4E+38 (y los negativos)

• double (tipo decimal de alta precisión, longitud 8 bytes)

- 1.7E-308 a 1.7E+308 (y los negativos)
Asignación de memoria a variables en C++

Las variables en C++ pueden ser globales o locales. Es decir, tanto variables que
pueden ser accedidas desde cualquier parte del programa (cualquier función) ya que
no se declaran dentro de ninguna función (globales), como variables que solo tienen
validez al interior de las funciones donde son declaradas (locales).
Ámbito (visibilidad) de las variables en C++

Las variables globales son visibles desde cualquier función o parte del programa dentro del
mismo archivo fuente .cpp (visibilidad a nivel de módulo). Las variables locales son visibles al
interior de la función donde están declaradas, no son visibles desde fuera de dicha función.

Ejemplo:

int my_global_var = 10;

int main()
{
int my_local_var = 5;
int my_result = 0;

my_result = my_global_var + my_local_var; //This is valid both variables are visible

return 0;
}

void other_function()
{
int other_local_variable = 3;
int other_result = 0;

other_result = my_global_var + other_local_variable; //This is valid both variables are visible

other_result = other_result + my_local_var; //This will not work!
}
Modificadores de las variables en C++

Los tipos de dato básicos de C++ pueden ser modificados con el fin de especificar de una
manera más acertada y detallada el tipo de dato que se alojara en una variable determinada.
Con los modificadores se puede acotar la cantidad necesaria de memoria para el dato que se va
almacenar, y también se puede indicar si el dato es sensible al signo o no.

Modificadores de C++:

• signed – indica que una variable es sensible al signo del valor numérico.
• unsigned – indica que la variable no es sensible al signo, luego sus valores son positivos.
• short – solo se utiliza en variables tipo int para acotar el tipo int a solo 2 bytes.
• long – se utiliza en variables tipo int y double para que al momento de compilación se
garantice por completo el tamaño del tipo de dato en especifico, 32 bits para int y 64 bits
para double.

Ejemplos:

signed char s_char; //A signed char datum

unsigned short int a_short_int; //A positive 16 bit int datum
long double long_double; //Guaranteed 64 bit double datum
Calificadores del tipo de las variables en C++

Los calificadores se usan en C++ para dar información más detallada del tipo de dato que se
almacena en la variable.

Calificadores de C++:

• const – indica que la variable alojara un valor constante que no puede ser modificado luego.
• volatile – indica al compilador que la variable puede cambiar de valor repentinamente por
fuera del flujo de programa (interrupciones de hardware).
• mutable – se utiliza en clases para indicar que un miembro de la clase puede ser
modificado por un método de la clase de tipo const.

Ejemplos:

const unsigned int my_constant = 50; //A constant declaration

volatile bool my_interrupt_check = false; //A variable that can be

suddenly changed
Especificadores de almacenamiento en memoria de las variables en C++

Los especificadores de almacenamiento se utilizan para detallar con mayor precisión la

visibilidad (scope) y el tiempo de vida de una variable en C++. Es decir, sirven para indicar en que
región de memoria de la aplicación se deben almacenar las variables para que de acuerdo a esa
característica se pueda definir la visibilidad de la variable en el programa.

Especificadores de almacenamiento en C++:

• auto – se utiliza solo con variables locales para definir automáticamente el tipo de dato.
• register – indica que una variable local se debe almacenar en un registro de la CPU y no
en RAM. Esto se hace en casos en los que se necesita optimizar el acceso a un dato
determinado.
• static – En el caso de variables locales se usa para que la variable no sea almacenada en
el stack y que pueda ser visible durante toda la duración de la aplicación. En el caso de
variables globales, se usa para que la variable solo sea visible en el modulo donde se declara.
• extern – se utiliza solo con variables globales para aumentar su visibilidad, es decir para
que se puedan utilizar en módulos distintos a en el que fue declarada. En el modulo donde se
declara, la variable se define tal cual como se ha visto pero sin inicializar. En el modulo que se
desea que la “visualice” se debe declarar usando el especificador.
Detalles adicionales….

En aplicaciones y proyectos de desarrollo de software es una práctica común que los

programadores definan sus propios tipos de dato, con base en los pre-definidos por C++, para
facilitar y hacer más intuitivo el proceso de declaración de variables.

C++ ofrece la función typedef para realizar la tarea mencionada anteriormente.

Ejemplos:

/* Un programador decide llamar byte a cualquier variable de tipo unsigned int

y uint_32 a cualquier variable de tipo unsigned long int */

typedef unsigned int byte;

typedef unsigned long int uint_32;

byte my_byte; // Una variable de tipo byte (unsigned int)

uint_32 my_long_var; //Una variable tipo uint_32 (unsigned long int)
Detalles adicionales….

Para la declaración de constantes globales es una práctica común entre programadores usar la
directiva del preprocesador #define.

Ejemplos:

/* Constantes globales usando la directiva #define */

#define MAX_VALUE 500

#define MIN_VALUE 50

unsigned int valor_maximo = MAX_VALUE;

unsigned int valor_minimo = MIN_VALUE;

unsigned int valor_promedio = (MAX_VALUE + MIN_VALUE) / 2;

Detalles adicionales….

Enumeraciones.

Ejemplos:

enum day {sunday, monday, tuesday, wednesday, thursday, friday, saturday};

int main()
{
enum day d = thursday;
std::cout<<"The day number stored in d is “<<d;
return 0;
}
Detalles adicionales….

Estructuras: Son tipos de dato definidos por el programador que permiten agrupar variables de
distintos tipos en un solo tipo.

Ejemplos:

struct estructura
{
char char_var;
unsigned int int_var;
float float_var;
double double_var;
enum State {Active, On_hold, Inactive};
};

El ejemplo anterior solo corresponde a la definición de la estructura, para declarar una variable
del tipo de dato de esa estructura se debe declarar así:

struct estructura mi_estructura;

mi_estructura.char_var = 0x41; //Acceso a los miembros de la estructura
Detalles adicionales….

Conversión explícita “Type casting”: Permite convertir (enmascarar) el tipo de dato almacenado
en una variable para que se pueda ejecutar una operación o procesamiento en la que se requiera
que la variable se presente con un tipo de dato distinto al que fue declarada.

Ejemplos:

double x = 10.3;
int y;

y = int (x); // functional notation

y = (int) x; // C-like cast notation

Conversión implícita: La realiza el compilador automáticamente, cuando en una operación hay

operandos de distintos tipos de datos. Es decir, el compilador adapta el tipo de dato para agilizar
la realización de la operación. A ese proceso se le conoce como “promoción del tipo de dato”.
Detalles adicionales….

Promoción del tipo de dato: Cuando hay datos de distintos tipos involucrados en una misma
operación, el compilar opta por hacer conversiones para homogeneizar los datos y facilitar el
computo de la operación. En general, existen dos tipos de promociones que son: la promoción a
tipo entero y la promoción a punto flotante. En la promoción de tipo entero se promocionan los
tipos de dato char y short al tipo de dato int. En la promoción de punto flotante se promocionan
los datos de tipo float a tipo double. Como regla general, si un operando de tipo long int o double
está involucrado en una operación entonces el resto de operadores serán promocionados a long
int o double. Nota: Si Coca-Cola mata tinto…..punto flotante mata entero.

En síntesis:

char y short -> int

float -> double

¿Cuál es el tipo de dato resultante de la siguiente operación?

Res = Char + Short + Long_Int + Float + Double

Enlaces útiles

https://www.geeksforgeeks.org/structures-c/
https://en.cppreference.com/w/cpp/language/typedef
https://www.w3schools.in/cplusplus-tutorial/qualifiers-storage-classes/
https://www.tutorialspoint.com/cplusplus/cpp_data_types.htm
https://www.tutorialspoint.com/cplusplus/cpp_variable_types.htm
https://www.tutorialspoint.com/cplusplus/cpp_variable_scope.htm
https://www.tutorialspoint.com/cplusplus/cpp_modifier_types.htm
https://www.tutorialspoint.com/cplusplus/cpp_storage_classes.htm
http://c.conclase.net/curso/?cap=006#inicio
http://www.ntu.edu.sg/home/ehchua/programming/cpp/cp0_introduction.html
http://c.conclase.net/curso/?cap=042
https://www.cprogramming.com/tutorial/lesson11.html?sb=tutmap