Python

Variables y Tipos de Datos

Un programa que solo muestre información en la pantalla no es más que una curiosidad que poca utilidad puede tener. En la vida real resulta necesario manipular información, de hecho es lo que regularmente hacen los programas. Tomar algún dato, procesarlo y presentarlo (ya sea en pantalla, enviarlo por algún medio, o simplemente entregarlo a otro proceso

Tomar un dato o conjunto de datos o realizar un proceso, implica “mover” información en uno o varios sentidos. Para realizar esta tarea utilizamos Variables.

Variables

C++ se conoce por ser un lenguaje fuertemente tipado, esto significa que antes de utilizar cualquier variable, se deberá definir primero, no hacerlo ocasionará un error de compilación.

Una variable es un identificador que puede cambiar su valor durante la ejecución de un programa. Una variable tiene asociado un Tipo de Dato, que determina el tipo de valor que puede almacenar dicha variable. A bajo nivel una variable es una referencia a una localidad de memoria que se encuentra dentro del segmento de datos del programa, una de las más grandes fortalezas de C++ es su capacidad de manipular de múltiples formas estas localidades de memoria

Sintaxis para declarar variables

Para definir una variable debes utilizar la siguiente sintaxis:

<tipo> <variable(s)>;

En donde tipo denota un tipo de dato válido y variable(s) es el nombre de la(s) variable(s), si son varias variables, se deben separar con una coma. Por ejemplo:

int numero;
bool continuar;
char repuesta, Respuesta; //respuesta y Respuesta son diferentes, recuerda que en C++ se diferencían mayúsculas de minúsculas
int numero1, numero2, numero3, resultado; //Los espacios entre los nombres de variable son opcionales pero facilitan la lectura

Tipos de Dato

Un tipo de dato determina las operaciones que son válidos con él y la forma en que es almacenada e interpretada la información en memoria. A continuación se listan los tipos de datos básicos de C++.

Tipo Nombre Tamaño Rango* Comentario
char Character (Carácter) 1 byte con signo: -128 to 127 sin signo: 0 a 255 Se utiliza en los caracteres ASCII de cadenas de estilo C antiguas u objetos std::string que nunca tendrán que convertirse a UNICODE.
bool Booleano 1 byte 0-1 Representa valores que pueden ser true o false.
int Integer (Entero) 4 bytes con signo: -2147483648 a 2147483647 sin signo: 0 a 4294967295 Opción predeterminada para los valores enteros.
double Doble 8 bytes 1.7e +/- 308 (15 digitos) Opción predeterminada para los valores de punto flotante.

*Debes considerar que el tamaño de una variable depende de la arquitectura del sistema en donde se ejecuta el compilador, los valores ilustrados son válidos en plataformas de 32 bits.

En C++ existen modificadores que cambian el comportamiento y el rango de los tipos de variables expresados anteriormente, en esta etapa no profundizaremos en este tema debido a que en etapas de aprendizaje son los tipos comúnmente utilizados, incluso en términos estrictos debo indicar que en C++ solo existen 3 categorías fundamentales de tipos de dato: entero, punto flotante y void. La tabla anterior y muchas de las que se encuentran a Internet, pertenecen generalmente a las 2 primeras categorías.

Asignar valor a una variable

Para asignar valor a una variable utilizamos la siguiente sintaxis:

<variable> = <valor>;

Recuerda que para poder utilizar <variable> primero debemos definirla, si intentamos utilizar una variable antes de definirla, provocará un error de compilación. El símbolo de asignación “=” le indica al compilador que asigne el valor de <valor> a la <variable> que se encuentra del lado izquierdo del símbolo de asignación.

Ejemplo de asignación de variables

// variables.cpp
// Este programa ilustra la declaración de variables, la asignación de variables
// y el despliegue en pantalla de variables
// 2017, Por http://about.me/carlosgbr
// Versión 1
// Compilado en https://www.tutorialspoint.com/compile_cpp_online.php
#include <iostream>
using namespace std;
int main()
{
  //Primero definimos las variables antes de usarlas
  int suma;
  char respuesta;
  bool continuar;
  double pi;
  //asiganción de variables
  suma = 3 + 2;
  respuesta = 's';
  continuar = false;
  pi = 3.141516;
  //Desplegamos en pantalla el valor de nuestras varibles
  cout << "suma es de tipo entero y tiene un valor de " << suma << endl;
  cout << "respuesta es de tipo char y tiene un valor de " << respuesta << endl;
  cout << "continuar es de tipo booleano y tiene un valor de " << continuar << endl;
  cout << "pi es de tipo double y tiene un valor de " << pi << endl;
  return 0;
}

Inicialización de variables

En el programa anterior vimos que una vez que definimos una variable podemos utilizarla, en este caso la asignación se hizo más adelante de la definición de las variables.

Frecuentemente se utiliza “Inicializar las variables”, algunas razones para hacer esto son:

  • Una variable no inicializada toma el valor de la localidad de memoria que le ha sido asignada por el compilador, lo cual en programas grandes puede causar errores difíciles de localizar, inicializando variables eliminamos este riesgo.
  • Mejora la legibilidad de un programa.
  • Inicializar las variables al momento de declararlos nos facilita la actualización del programa en un solo punto.

Para declarar una variable al momento de declararla se utiliza la siguiente sintaxis.

<tipo> <variable> = <valor>;

Si observas con cuidado, es una forma compuesta de declarar una variable y asignarle un valor en la misma línea.

El siguiente programa ilustra la inicialización de variables así como lo que ocurre con las variables no inicializadas.

// inicializacion_variables.cpp
// Este programa ilustra la inicialización de variables así como los valores
// basura que toman las variables no inicializadas.
// 2017, Por http://about.me/carlosgbr
// Versión 1
// Compilado en https://www.tutorialspoint.com/compile_cpp_online.php
#include <iostream>
using namespace std;
int main()
   {
   //Inicialización de variables al momento de declararlas
   int edad_minima = 18;
   char respuesta = 'n';
   bool autorizado = true;
   double pulgada = 2.54;
   //Variables sin inicalizar
   int edad_actual;
   double estatura;
   bool continuar;
   //mostramos el valor de las variables no inicializadas.
   cout << "edad_actual es de tipo entero y tiene un valor de " << edad_actual << endl;
   cout << "estatura es de tipo double y tiene un valor de " << estatura << endl;
   cout << "continuar es de tipo bool y tiene un valor de " << continuar << endl;
   return 0;
}

A continuación puedes observar la salida de las variables sin inicializar, podemos observar que en los 3 casos obtenemos salidas distintas. Lo cual es inaceptable en un programa. Por esta razón es conveniente inicializar las variables para evitar errores potenciales y el lugar más adecuado para hacer esto es al momento de declarar las variables.

Salida de Variables sin Inicializar 1
Salida de Variables sin Inicializar 2
Salida de Variables sin Inicializar 3

Conversión de Tipos

Finalmente es importante mencionar que si bien C++ es un lenguaje de fuerte tipado, lo cual ya indicamos, implica que es obligatorio definirlas antes de utilizarlas, hay ciertas libertades que pueden servirnos en circunstancias muy específicas. Una de ellas es aprovechar que internamente las variables no son mas que bytes en memoria, por esta razón es posible hacer lo siguiente

// conversion_de_tipos.cpp
// Este programa ilustra la asignación de variables de un tipo
// definido que reciben valores de otro tipo al indicado
// 2017, Por http://about.me/carlosgbr
// Versión 1
// Compilado en https://www.tutorialspoint.com/compile_cpp_online.php
#include <iostream>
using namespace std;
int main()
{
  //Inicialización de variables al momento de declararlas
  int numero1, numero2, numero3;
  char respuesta = 'n';
  double pulgada = 2.54;
  int suma = 0;
  double pulgada_a_cm = 0;
  bool continuar = false;
  //Asignación de valores a variables de tipo distinto
  numero1 = 100.01;     //asignamos un real a variable entera
  numero2 = respuesta;  //asignamos un char a variable entera
  numero3 = continuar;  //asignamos un boolean a variable entera
  continuar = numero1;  //asignamos un entero a variable boolean
  respuesta = pulgada;  //asignamos un real a variable char
  //mostramos el valor de las variables con conversión de tipos
  cout << "numero1 recibe el valor 100.01 y muestra: " << numero1 << endl;
  cout << "numero2 recibe el valor \'n\' y muestra: " << numero2 << endl;
  cout << "numero3 recibe el valor false y muestra: " << numero3 << endl;
  cout << "continuar recibe el valor 100 y muestra: " << continuar << endl;
  cout << "respuesta recibe el valor 2.54 y muestra: " << respuesta << endl;
return 0;
}

Si analizas la asignación de valor a las variables puedes observar que la variable declara de un tipo, pero el valor que se le asigna es distinto. En este caso el compilador lo que hace es “ajustar” el valor para que se ajuste al tipo de variables que es asignado. En esta conversión existe pérdida de información o una transformación del valor para que sea compatible con el tipo de variable de destino.

Salida del programa

Si ejecutas el programa anterior puedes obtener una salida similar a la siguiente (considera que puede cambiar según el compilador que utilices).

$g++ -o main *.cpp
$main
numero1 recibe el valor 100.01 y muestra: 100
numero2 recibe el valor 'n' y muestra: 110
numero3 recibe el valor false y muestra: 0
continuar recibe el valor 100 y muestra: 1
respuesta recibe el valor 2.54 y muestra: 
  • numero1 se definió como entero, por tanto la parte fraccionaria se pierde solo queda el 100
  • numero2 se definió como entero, ‘n’ se representa en su valor ASCII correspondiente para visualizarse como un entero por eso muestra 110
  • numero3 se definió como entero, false internamente se representa con 0, por esta razón la salida que se muestra es 0
  • continuar se definió como booleano, cualquier valor superior a 1 se interpreta como 1 (verdadero) por eso la salida es 1
  • respuesta es char, al recibir un valor real, se crea “basura” que no se puede representar en una variable tipo char, por eso muestra un caracter no imprimible.

Del ejemplo anterior podemos decir 3 cosas:

  • Si sabes lo que haces, puedes hacer conversiones implícitas que en un momento dado, pueden simplificar el desarrollo de un programa
  • No puedes dejar que el compilador “resuelva” este tipo de conversiones, pues pueden existir diferncias de acuerdo al compilador y arquitectura utilizada, lo cual puede restar portabilidad a tu código.
  • Finalmente, es una mala práctica utilizar conversiones implícitas, evítalas, el lenguaje ofrece alternativas para realizar conversiones. Más adelante veremos estos casos.

Sin embargo la conversión de tipos es una actividad que no es “rara”, y el compilador tiene definido un procedimiento para realizar las conversiones, si deseas leer más sobre el tema, te sugiero revisar la entrada correspondiente el el blog de C con Clase, (que dicho de paso, es una de las mejores referencias que te puedes encontrar de C++ en TODO Internet, no es exageración, te invito a revisarlo)


Ethical hack

Fuente Imágenes:

  • “Todas las imágenes de esta sección”: by Nala Systems

Código Fuente:


Variables y Tipos de Datos by Roberto C. González is licensed under a Creative Commons Reconocimiento-NoComercial-CompartirIgual 4.0 Internacional License.
eHack Blog

Entradas recientes

dnsenum

El comando dnsenum es una herramienta de línea de comandos para realizar enumeración de DNS…

1 año hace

Las 24 listas negras de IPv4 más comunes.

En esta entrada te presento 24 de las listas negras más comunes que los servidores…

2 años hace

ZoomIt – SysInternals

ZoomIt es una herramienta de anotación y zoom de pantalla para presentaciones técnicas que incluyen…

2 años hace

WinObj – SysInternals

WinObj es el visor de espacios de nombres de Object Manager definitivo. Es la primera…

2 años hace

WhoIs – SysInternals

Whois realiza el registro de registro para el nombre de dominio o la dirección IP…

2 años hace

VolumeID – SysInternals

VolumeID – Esta utilidad, le permite cambiar los identificadores de los discos FAT y NTFS…

2 años hace