Capítulo 2: Variables.

Saltar al capítulo 3

Las variables son algo que varían. Cualquier cosa puede ser representada por una variable, por ejemplo una variable que defina el color de tu pelo (char*), la edad que tienes (int), el valor de PI (double), etc... . En C las variables no son más que nombres que le damos a direcciones de memoria que usaremos para almacenar un valor, que puede ser numérico (entero o Interger en ingles), con decimales (flotante float), puede ser una letra (caracter o character en inglés) o una cadena de texto, también puede ser binario (1 o 0).

Nota: El lenguaje C es poco típado. Al ser poco típado se le puede declarar el tipo de dato que se guardará en esa variable, pero nada te impide de darle a esa variable un valor que sea otro tipo de dato diferente. En consecuencia cuando se inicializa la variable con otro tipo de dato, este valor hace una conversión para poder ser almacenado en esa variable (como un int puede almacenar un numero con decimales, pero sus decimales no los almacena) por lo que puede dar errores inesperados.

Tipos de Variables.

Para declarar una variable solo debes colocar el tipo de variable (int, float, char,...) y después colocar su nombre que puede ser cualquier palabra o frase que no esté previamente definido.

Hay reglas a seguir para declarar variables. Antes veamos algunos ejemplos de variables:

// https://github.com/dabl03/C-tutorial-code/tree/main/cap-2 #include <stdio.h> //Para poder usar la función printf y getchar que se usa para la IO/OUT int main(void){ //Variables enteras: int entero=100;// Entero de 32bits. Su valor puede ser de -2147483648 hasta 2147483647. Ni más, ni menos. short p_entero=300;// Un entero de 16bits. Puede almacenar −32767 hasta 32767 //Variables con decimales: float decimales=2.4; // Su valor puede ser de -3.40282e+38 a 3.40282e+38 double decimales_doble_precisión=10000.9023921839021; // Lo mismo que float, pero almacena con más precisión: -1.79769e+308 a 1.79769e+308 //Carácter: char caracter='a'; // Pude almacenar un carácter. iNotar que lo encerramos en comillas simples, no puede ser de otra forma. //Caracteres o String en inglés: char* cadena_de_caracteres="Los string están diseñado para almacenar varios caracteres para formar palabras y oraciones"; // iNotar que usamos comillas dobles; y notar que es char pero con el signo (*) en otro capitulo lo explico!. //Mostramos sus valores por consola: printf("La variable entera vale: %d\n", entero); printf("Los decimales son: %f y %f\n", decimales,decimales_doble_precisión); printf("El carácter único es: %c\n", caracter); printf("El mensaje oculto es:\n - %s\n", cadena_de_caracteres); puts("Se terminó el programa, presionar enter para terminar..."); getchar(); return 0; }

Esos son los tipos de variables que más usaras mientra aprendes, todavía hay más. También se puede crear tipos de datos personalizados, pero hablaremos de eso en otro capítulo.

---

Ahora vamos con las reglas para declarar variables:

1. Las variables no pueden tener caracteres que no sean del abecedario inglés (no ñ; no á,é, í, ó, ú), números o el signo '_'.
2. Los nombres no pueden estar separados con espacios, en su lugar podemos usar guiones bajos (_). Por ejemplo:

   Malo:

   int cantidad caramelos;// dará error

   Bueno:

   int cantidad_caramelos;// Se compilará correctamente

3. Las variables nunca deben empezar con números, pero pueden tenerlo en todo el cuerpo de la variable. Ejemplo:

   Malo:

   int 4gua_3mb0t3llada;//iError!

   Bueno:

   int Agua_3mb0t3llada;//Correcto:D

4. El lenguaje C distingue mayúsculas y minúsculas (Case Sensitive en inglés). Por lo que las siguientes variables son todas diferentes:
   • int sec;
   • int Sec;
   • int sEc;
   • int seC;
   • int SeC;
   • int SEC;
   Al ser diferentes si realizamos una operación con la variable SEc o sEC notaremos que dará un error, porque no se ha definido SEc ni la variable sEC. Las dos al no estar definidas, para el compilador no existen, ni sabe qué hacer con ellas y detendrá la compilación con un bonito error.
5. La última, pero no menos importante: iNO PUEDE HABER VARIABLES PREVIAMENTE DEFINIDAS!, ni puedes usar palabras reservada por el lenguaje C. Aquí puedes ver una lista de palabras reservadas por el lenguaje C.

Nota: Si quieres saber que caracteres hay en el abecedario inglés: Haz click aquí.
Otra cosa: Los caracteres que son del abecedario inglés o que son números se les conocen como caracteres alfanumérico

Ahora que sabemos las reglas vamos a ver cuáles son los tipos básico de variables:

int - Entero de 32 bits. Almacena números sin decimales. float - Esta variable almacena números y decimales. Los decimales se delimitan por el signo ".", ejemplo: float PI=3.14; double - Lo mismo que float pero ofrece más capacidad de almacenamiento (64bits). char - Es un entero de 8bits que puede almacenar un numero hasta desde -127 hasta 127. Esta variable se usa para almacenar caracteres en código ASCII (Es un estándar para representar caracteres por medio de números) //---------------------------------------------------------------------

Para ver que caracteres se puede almacenar en una variable tipo "char" puedes ver esta lista: https://elcodigoascii.com.ar/.

Estos son los tipos de variables que hay en C. También hay dos operadores para indicar si la variables pueden o no almacenar números negativos y estos son: signed y unsigned.

También hay un operador para aumentar la capacidad normal de las variables: long.

Estos 3 operadores se pueden usar con todos los tipos de variables, pero no se pueden usar en punteros (más tarde explico que son los punteros).

Ejemplos: unsigned int contador=10;// Un entero que no puede ser negativo (sin signo). Puede almacenar de 0 hasta 4294967296. signed int count=-100;// Entero con signo. Este todas las variables tienen el signed por defecto. Puede almacenar desde -2147483648 hasta 2147483648. signed char caracter='a';// Puede almacenar un entero desde -127 hasta 127. unsigned char caracter_x2='ñ';// Desde 0 hasta 255 de almacenamiento. //Etc... //https://github.com/dabl03/C-tutorial-code/tree/main/cap-2 #include <stdio.h> int main (void){ long int big_int=-10000;// Un rango de −2147483647 a +2147483647 long double PI=3.141593;// Es un double de 128 bits unsigned long int big_int_big=-100000000;// Entero sin signo, si lo inicializas con -100000000 la variable contendrá 100000000 signed long int _big_int=-100000000;// Lo mismo que long int // Mostrar los valores de las variables: printf("La variable \"big_int\" se inicializó con -10000 y ahora contiene: %ld.\n",big_int); printf("El valor de \"PI\" es: %Lf.\n",PI); printf("La variable \"big_int_big\" se inicializó con -100000000 y ahora contiene: %lu.\n",big_int_big); printf("La variable \"_big_int\" se inicializó con -100000000 y ahora contiene: %ld.\n",_big_int); return 0; }

No quise abarcar todas las variables posibles, pero aquí te dejo una lista completa de variables: wikipedia data type in ansi C.

• Otra observación es que usamos la función printf de stdio.h, esta función es usada para mostrar algo por la consola, pero a diferencia de puts, esta nos permite pasar más argumentos y hacer las conversiones para mostrar los valores de los diferentes tipos de variables.

  Nota: Cada % debe corresponder con la cantidad de argumentos pasado, porque si haces: printf("El entero nombre_var es: %d\nEl entero nombre_int2 es: %d\n",nombre_var); El programa se cerrará porque la función printf intenta agarrar 2 parámetros y tú solo pasaste 1, pero si haces: printf("El entero nombre_var es: %d\nEl entero nombre_int2 es: %d\n",nombre_var,nombre_int2);, te funcionará (Claro debes tener esas dos variables inicializadas).

  Para obtener una lista de qué % corresponde a cada tipo de variable fíjate en la lista que te di, en la sección: Format specifier. Si no sabes cual lista aqui está.

• float: Esto es para números con decimales, puede almacenar hasta 3 decimales sin perder precisión.

Constantes

Las constantes es un operador usado para indicar que la dirección de memoria de las variables es de solo lectura, lo que significa que lo que haya almacenado en esa variable no se puede alterar.

Las constantes son usadas para evitar cambiar por accidente el valor de una variable, o si trabaja con varias personas un mismo proyecto servirá para indicarles a los demás que esta variable está pensada para no ser modificada.

Para declarar constante una variable solo debes usar el operador const antes del tipo de variable. Ejemplo de constantes:

// https://github.com/dabl03/C-tutorial-code/tree/main/cap-2 #include <stdio.h> int main(){ const double PI=3.1415;//... int diametro=30;// cm PI=0;// Esto dará error, quítalo para que compile el programa. double circunferencia=PI*diametro; //Imprimimos la circunferencia: printf("De una pizza con %dcm de diámetro su circunferencia será %lf.\n",diametro,circunferencia); puts("Press enter for exit program..."); getchar(); return 0; }

Nota: Los nombres de las constantes sigue un estándar que dice: Toda constante será escrita en mayúscula. Claro, puedes escribirlo en minúscula, pero es un buen indicativo colocarla siempre en mayúscula.

Recomiendo leer: Data type in CPP Reference