C++ / Variables, constantes y Arrays

Bienvenidos sean a este post, hoy veremos los primeros tres temas complementarios.

Variables

Las variables seran las encargadas de almacenar los valores que usaremos en nuestros codigos. Estos se almacenaran en memoria y para ello la variable reservara un espacio en la misma, y su tamaño es determinado por el tipo de dato que almacenara la variable. Veamos como es su sintaxis mas basica:

tipo_de_dato nombre_variable [= valor];

Siempre ira primero el tipo de dato que almacenara y seguido del nombre identificador y de manera opcional le podemos asignar un valor, un ejemplo es:

int inicio;

Esta es una variable llamada inicio y almacenara valores numericos de tipo entero. Pero no tendra ningun valor y solo reservara el espacio en memoria. Para iniciarla con un valor debemos hacerlo de la siguiente manera:

int inicio = 0;

Simplemente mediante el operador de asignacion le pasamos un valor inicial. Cualquiera de las dos sintaxis son validas para establecer una variable pero si usan la primera tengan en cuenta que para utilizarla deberan asignarle un valor previamente porque de lo contrario puede devolver un error. Veamos primero los tipos primitivos que disponemos:

• int, representa numeros sin decimales solo enteros
• float, representa numeros con decimales de precision simple
• double, representa numeros con decimales de precision doble
• bool, representa valores booleanos (true y false)
• char, es la encargada de manejar las cadenas de textos

El ultimo tipo es el basico para manejar las cadenas de texto y es heredado de C, como la mayoria, pero aqui disponemos de una libreria que nos permite utilizar un tipo string facilitando la tarea pero sobre este tema lo veremos en otro post. Para entender este concepto vamos a analizar un ejemplo, para ello deben crear un archivo con el nombre de ejemplo01.cpp y agreguen el siguiente codigo:

#include <iostream>

int valor_1;
int valor_2 = 10;

int main()
{
        valor_1 = 1;
        int total = valor_1 + valor_2;
        std::cout << total << std::endl;
        return 0;
}

Si vienen del post anterior, tenemos nuestra primer variante del codigo basico que vimos. Antes del main definimos las dos variables que usaremos. La primera sin ningun valor y la segunda con un valor inicial. Luego en el main lo primero que haremos sera asignarle un valor a la variable que no lo tenia. Lo siguiente sera definir una nueva variable con la suma de las dos anteriores para despues mostrarla en consola. Si lo compilan y ejecutan veran la siguiente salida:

$ ./ejemplo01
11
$

Que hubiera pasado si no le asignamos un valor a la variable valor_1? En este caso, nada porque de manera predeterminada le asigna el valor de 0 y no afecta a nuestra operacion. Pero esto no sera siempre asi y algunos compiladores pueden asignar el valor null y esto si puede generar algun error. Por otro lado aplicamos un tema muy importantes como es el scope o rango de una variable.

Cuando hablamos del scope de una variable nos estamos refiriendo del alcance de la misma. Las cuales suelen denominarse mas comunmente como locales o globales. Siendo las globales aquellas que pueden ser utilizadas en cualquier parte del codigo y las locales unicamente en el bloque donde fueron definidas. Esto es asi porque las variables siempre se eliminan cuando finaliza el bloque donde fueron definidas. En el caso de las globales se eliminan cuando se finaliza el programa y en el caso de las locales cuando finaliza el bloque de codigo. Consideren que un bloque de codigo puede ser el de una funcion, un condicional, un bucle, etc. Por ejemplo, en el caso de una funcion cuando llegamos al final o utilizamos a return da por finalizada la funcion. Por lo tanto, todo el contenido de esta se elimina de la memoria para liberar espacio. Si miramos el ejemplo, las funciones globales seran valor_1 y valor_2 porque estan por fuera de main y cualquier otra funcion. Y total es de orden local porque solo se puede utilizar dentro de main, impidiendo que cualquier elemento externo al main pueda acceder a esta.

Las variables globales y locales tienen sus pros y contras. Las ventajas de las globales es que podemos accederlas en cualquier momento y desde cualquier parte. Las locales no poseen este privilegio pero si son mas rapidas que las globales. Por otro lado, acumular muchas variables globales puede desencadenar en problemas de memoria. Por lo general, siempre conviene tener muy pocas variables globales y la manipulacion de la informacion realizarla mediante variables locales en cada funcion. A medida que vayamos practicando mas se entendera este concepto.

Constantes

Las constantes son tambien variables pero con la particularidad de que no se puede modificar el valor una vez establecido. Veamos como es la sintaxis para definirlo:

const tipo_de_dato nombre_const = valor;

Siempre ira precedida por la palabra const seguida del tipo de dato que contendra, como una variable, el nombre que lo identificara y siempre le asignaremos un valor. Recuerden que este no puede ser modificado. Con esto comentado tomemos el codigo anterior y realicemos la siguiente modificacion:

#include <iostream>

const int valor_1 = 1;
const int valor_2 = 10;

int main()
{
        valor_1 = 3;
        int total = valor_1 + valor_2;
        std::cout << total << std::endl;
        return 0;
}

En este ejemplo, hicimos unas sutiles modificaciones donde ahora las variables globales son constantes y tendran sus respectivos valores. En el cuerpo del main le establecemos un nuevo valor a la primera variable, compilemos y veamos como es su salida:

$ g++ ejemplo01.cpp -o ejemplo01
ejemplo01.cpp: In function ‘int main()’:
ejemplo01.cpp:8:17: error: assignment of read-only variable ‘valor_1’
    8 |         valor_1 = 3;
      |         ~~~~~~~~^~~
$

En este caso no lo compilo porque como informa el error al ser de solo-lectura no podemos asignarle un nuevo valor. Para solucionarlo, simplemente borren la asignacion del nuevo valor y si lo vuelven a compilar no deberia devolver ningun error y al ejecutarlo deben tener la misma salida que antes. Estos estan pensados para cuando necesitamos un valor fijo y que no debe ser alterado en todo el codigo. Un ejemplo es el valor de Pi que podemos necesitarlo para distintos calculos, y esto nos asegura que no se modificara bajo ninguna circunstancia. Pasemos al siguiente tema.

Arrays

Los arrays, arreglos o matrices, se pueden conocer con estos tres nombres, son una variante de las variables porque en lugar de almacenar un solo dato, almacena varios. Para ello, le asigna a cada uno una posicion dentro del mismo. El cual sirve tanto para asignarlo, como para recuperarlo. Su sintaxis es la siguiente:

tipo_de_datos nombre_array[tamaño];

Es muy similar a una variable donde primero estableceremos el tipo de dato que almacenara la variable, luego el nombre identificador y junto a este entre corchetes el tamaño del mismo, o la cantidad de elementos que podra almacenar. Otra forma de hacerlo es la siguiente:

tipo_de_datos nombre_array[] = { valor_1, valor_2, valor_3,..., valor_N };

En este caso no fue necesario pasar el tamaño porque este se asignara automaticamente en base a los valores que asignemos. A diferencia de lo que sucede en lenguajes modernos, los arrays no tienen un tamaño dinamico sino que es estatico. Por lo tanto, no se puede modificar una vez establecido. Siempre debemos armarlo en base a nuestras necesidades pero tampoco exageren porque arrays muy grandes pueden desencadenar en problemas de memoria. Vamos a tomar el archivo que estuvimos trabajando y modifiquemos el codigo de la siguiente manera:

#include <iostream>

int arreglo[3];

int main()
{
        arreglo[0]=100;
        arreglo[1]=200;
        arreglo[2]=300;
        std::cout << arreglo[0] << std::endl;
        std::cout << arreglo[1] << std::endl;
        std::cout << arreglo[2] << std::endl;
        return 0;
}

Lo primero que hacemos es declarar un array de tres posiciones. Luego en el main le asignaremos un valor a cada posicion y para ello usaremos el nombre del array y entre los corchetes le pasamos la posicion donde se almacenara. Siempre la primera posicion es 0 y despues sigue incrementandose hasta llegar al limite. Por lo tanto la ultima posicion siempre sera una anterior al limite. Con nuestros tres valores establecidos lo que haremos es mostrar cada uno de ellos. Observen que para mostrarlos simplemente pasamos el nombre del array y entre corchetes la posicion a recuperar. Compilemos y veamos la salida:

$ ./ejemplo01
100
200
300
$

De esta manera podemos tener multiples valores en un solo elemento, esto es muy utilizado cuando recuperemos informacion desde un elemento externo, como una base de datos, hasta manejar distintas propiedades de un solo elemento en el codigo.

El array que vimos anteriormente se lo denomina habitualmente como array unidimensional porque tiene una sola dimension. Pero estos pueden ser multidimensionales. Es decir, si tienen dos dimensiones sera bidimensional, si tiene tres sera tridimensional y asi sucesivamente en infinitas dimensiones. Su sintaxis es la siguiente:

tipo_de_dato nombre_array[dim_1][dim_2][dim_3]...[dim_N];

Es muy parecido al anterior pero entre corchetes iremos agregando los tamaños de las nuevas dimensiones. Tomemos el codigo anterior y realicemos las siguientes modificaciones:

#include <iostream>

int arreglo[2][3];

int main()
{
        arreglo[0][0]=100;
        arreglo[0][1]=101;
        arreglo[0][2]=102;
        arreglo[1][0]=200;
        arreglo[1][1]=201;
        arreglo[1][2]=202;
        std::cout << arreglo[0][0] << " " << arreglo[0][1];
        std::cout << " " << arreglo[0][2] << std::endl;
        std::cout << arreglo[1][0] << " " << arreglo[1][1];
        std::cout << " " << arreglo[1][2] << std::endl;
        return 0;
}

En esta ocasion declaramos un array de dos dimensiones donde la primera tendra dos lugares y la segunda es de tres lugares. En el bloque del main agregaremos cada dato, observen como lo hicimos. Primero trabajamos con la primera posicion de la primera dimension y luego vamos variando la segunda dimension para almacenar cada una de las posiciones de este. Cuando lo hayamos hecho pasaremos a la segunda posicion de la primera dimension y volvimos a repetir el proceso de la segunda dimension y en cada una con su respectivo valor. En este caso podemos considerarlo como una tabla similar a esta:

dim 1 \ dim 2	0	1	2
0	100	101	102
1	200	201	202

Donde las filas seran la primera dimension y las columnas la segunda dimension y en cada posicion almacenamos cada valor. Tambien podriamos considerarlo como un tablero de ajedrez, si tuviera una dimension mas podemos considerarlos como los ejes X, Y, Z. A mayor necesidad se pueden agregar mas dimensiones. En mi experiencia no he visto nada mas alla de un array tridimensional pero no quita que en desarrollos mas de estilo cientifico se utilicen. Siguiendo con el codigo, mostraremos cada valor almacenado en las «celdas» de la tabla anterior. Para ello, mostraremos todos los valores de la primera linea, y luego de la segunda linea. Al igual que al momento de asignarlo para recuperarlo hacemos lo mismo. Si lo compilan y prueban tendran una salida como la siguiente:

$ ./ejemplo01
100 101 102
200 201 202
$

Con esto tenemos un conocimiento basico de las tres formas para manipular informacion en nuestros codigos, lo visto es lo mas basico y tienen mas complementos pero los cuales iremos viendo en su debido momento, por el momento quedense con lo visto en este post.

En resumen, hoy hemos visto primero a variables, que son, para que sirven, como se declaran, y sus alcances, despues vimos la primer variante como son las constantes, que son, como se declaran y como se utilizan, para finalmente ver la ultima variante como son los arrays, que son, para que sirven, como se utilizan y las variedades que disponemos, asi como un ejemplo para cada tema. Espero les haya resultado de utilidad sigueme en tumblr, Twitter o Facebook para recibir una notificacion cada vez que subo un nuevo post en este blog, nos vemos en el proximo post.