3. Programación Estructurada

La programación estructurada es una técnica para escribir programas orientados a mejorar la claridad, calidad y tiempo de desarrollo de un programa de computadora recurriendo únicamente a subrutinas y tres estructuras básicas: secuencia, selección (if y switch) e iteración (bucles for y while)

Variables y tipos de datos (Asignación y clasificación)

Un tipo de dato es una clasificación que el programador le da a la información almacenada para avisarle al compilador cómo va a ser interpretada.

Tipos de datos primitivos:

Numéricos: int (números enteros), float (números decimales)
Caracteres: char
Booleanos: bool (True or false)

Una variable es un espacio reservado en memoria, definido por un tipo de dato y un nombre asignado, en el cual se puede guardar un valor y se puede modificar.

Operadores aritméticos

Los operadores los utilizamos para realizar operaciones aritméticas en nuestras funciones. Algunos operadores son:

Suma: +
Resta: -
Multiplicación: *
División: /
Módulo: %

La operación módulo es el residuo de la división de dos números.

Operadores de asignación, de incremento y decremento

Otros operadores de asignación pueden ser:

Operador	Ejemplo	Equivalente sin operador
`+=`	`a += 5`	`a = a + 5`
`-=`	`a -= 5`	`a = a - 5`
`*=`	`a *= 5`	`a = a * 5`
`/=`	`a /= 5`	`a = a / 5`
`%=`	`a %= 5`	`a = a % 5`

El operador de asignación “=” asigna el valor del lado derecho del operador a la variable en el lado izquierdo.

Los operadores de asignación compuestos: realizan una operación y una asignación en una sola declaración.

Ejemplo:

int x = 42;
x += 2; //Equivalente a x = x +2
x -= 6; //Equivalente a x = x - 6

Operadores de Incremento y decremento

Operador	Ejemplo	Equivalente en asignación
`++`	`a++`	`a = a + 1`
`--`	`a--`	`a = a - 1`

Operador de incremento, por ejemplo:

int miNumero = 7;
miNumero++;
//salida 8

El operador de decremento (–) funciona de la misma forma que el operador de incremento, pero en lugar de incrementar el valor, lo disminuye en uno.

El operador de incremento tiene dos formas prefijo y sufijo.

x; //prefijo
x; //sufijo

La variante de prefijo incrementa el valor y luego continua con la expresión.

La variante de sufijo evalúa la expresión y luego ejecuta el incremento.

Ejemplo de prefijo:

int x = 3;
int y = x++;
//x es 4, y es 4

Ejemplo de sufijo:

int x = 3;
int y = x++;
// x es 3, y es 4

Conclusión: El ejemplo de prefijo incrementa el valor de “x” , y luego se lo asigna a “y”.

El ejemplo de sufijo asigna el valor de “x” a “y” y luego incrementa el valor de “x”.

Condicional if e if - else

Las condicionales son instrucciones que evalúan resultados booleanos (true or false), generalmente usados para alterar el flujo de un programa.

Una sentencia condicional es una instrucción o grupo de instrucciones que se pueden ejecutar o no en función del valor de una condición.

Sintaxis

main(){
	// if - Instruccion condicional
	if (vidasExtras == 0){ //vidasExtras == 0 - Operaciones
	printf(""Game Over""); // Bloque al cumplimiento de la condicion 
	}
}

Operadores relacionales y lógicos

Los operadores relacionales son:

Menor que (<)
Menor o igual que (≤)
Mayor que (>)
Mayor o igual que (>=)
Igual que (==) : Comparación
No igual que (!=) : Diferente

Los operadores lógicos son:

AND (&&) : Y // El resultado será verdadero si ambas condiciones son verdaderas. Por ejemplo: if (key1 == true && key2 == true)
OR (||) : O // El resultado será verdadero si alguna de las condiciones es verdadera. Por ejemplo: if (key1 == true || key2 == true)
NOT (!) : No // El resultado será inverso al operando. Por ejemplo: hasKey = !hasKey;

Switch es una estructura de control para agilizar el flujo del programa en opciones múltiples.

Se tiene una condición que se puede cumplir dependiendo de diferentes casos, cada caso nos lleva a un bloque de cumplimiento de la condición y ese bloque nos lleva a continuar el programa.

switch(balas)
{
    case 0:
	    printf("No hay balas!");
    break;

	case 1:
	    printf("Te queda una bala");
    break;

	case 5:
	    printf("Tu arma está llena");
    break;

	default:
	    printf(":");
    break;
}

if(balas == 0)
{	    
	printf("No hay balas!");
}
else if(balas == 1)
{
	printf("Te queda una bala");
}
else if(balas == 5)
{
	printf("Tu arma está llena");
}
else
{
    printf(": ");
}

¿Qué es un iterador?

Un loop es una estructura iterativa que permite repetir un bloque de instrucciones. Esta repetición es controlada por una condición booleana.

Un iterador es utilizado por un algoritmo para recorrer los elementos almacenados en un contenedor. Dado que los distintos algoritmos necesitan recorrer los contenedores de diversas maneras para realizar diversas operaciones, y los contenedores deben ser accedidos de formas distintas, existen diferentes tipos de iteradores.

While: Es una estructura de control en la que la repetición se realizará tantas veces como se indique mientras se cumpla una condición.

Sintaxis

while (a < 5) // Condicion
{
    a++; // Bloque al cumplimiento de la condicion 
}

Ciclo For: El ciclo for es una estructura de control que nos permite repetir un bloque de comandos un número de veces específico.

Este ciclo se compone de tres partes:

Inicialización: Se inicializa una variable (generalmente ““i””) al asignarle el valor 0.
Condición: Se indica la condición necesaria para que termine el ciclo.
Incremento: También puede ser decremento; este va a indicar los pasos en los que se moverá el ciclo, este número siempre debe ser entero, para ir de uno en uno se utiliza el i++.

Sintaxis

// int i = 0 - Inicializacion
// i < 10 - Condicion
// i++ - Incremento
for (int i = 0; i < 10; i++) 
{
    // Bloque al cumplimiento de la condicion 
}

Ciclo Do-While: El Do - While es una estructura de control donde la condición de continuación del ciclo se prueba al final del mismo. Funciona de manera similar a la estructura while, la diferencia es que esta evalúa al final.

Sintaxis

do
{
    a++; // Bloque antes del cumplimiento de la condicion
}
while (a <= 5);

Diferencias entre For, While y Do-While:

For: Permite repetir un bloque de comandos un número de veces específico, tiene 3 partes: Inicialización, Condición y Cambio de la variable (Incremento o Decremento). Útil para recorrer arreglos.
While: Se repiten las instrucciones mientras la condición es verdadera (se detiene hasta que no se cumple, en el caso de que no sea verdad al principio, no entrará al bucle).
Do-While: Se ejecuta al menos una vez, primero hace el bloque de instrucciones y después evalúa la condición. Útil para hacer un Menú.

Arreglos unidimensionales

Un arreglo es una serie de elementos, del mismo tipo de dato y son almacenados de manera consecutiva. En programación, la primera posición de los arreglos empieza en "“0"”.

Declarar un arreglo

// Estructura 
Data_type name[size];

// Ejemplo
int maxElements[5];

int - Tipo de dato
maxElements - Nombre del arreglo
[5] - Tamaño del arreglo

Inicializar un arreglo

// Estructura 
Data_type name[size] = {contenido};

// Ejemplo
int maxElements[5] = {0, 12, 5, 9, 55};

int - Tipo de dato
maxElements - Nombre del arreglo
[5] - Tamaño del arreglo
{0, 12, 5, 9, 55} - Contenido del arreglo

Arreglos bidimensionales

Los arreglos bidimensionales son también llamados tablas o matrices.

Tiene dos índices: el primero indica el número de fila y el segundo el número de columna en que se encuentra el elemento.

Declarar un arreglo

// Estructura
Data_type name[size][size];

// Ejemplo
int matrix[2][2];

int - Tipo de dato
matrix - Nombre del arreglo
[2] - Filas
[2] - Columnas

Inicializar un arreglo

// Estructura
Data_type name[size][size];

// Ejemplo
int matrix[3][4] = {1{1,2,3,4},
                    2{5,6,7,8},
                    3{9,1,2,3};
                      1 2 3 4

int - Tipo de dato
matrix - Nombre del arreglo
[3] - Filas
[4] - Columnas

Arreglos e iteradores unidimensionales

¿Por qué utilizar iteradores en arreglos unidimensionales?

Para manipular todos los elementos de un arreglo podemos utilizar una estructura repetitiva. La más usual es el ciclo for pero también podemos usar while.
Cuando se desea imprimir el contenido del arreglo.
Cuando se suman todos los elementos.
También cuando se va a inicializar el arreglo.

Ejemplo:

int numbers[4];

for(int i = 0; i < 4; i++)
{
	numbers[i] = i;
}

Arreglos e iteradores bidimensionales

Para poder utilizar el iterador for junto con un arreglo bidimensional es necesario entender el concepto de un for anidado. Esto es un for dentro de un for, la sintaxis es la siguiente:

Ejemplo:

// For anidado
for(i=0; i<2; i++){ // Primer for
	    for(j=0; j<1; j++){ // Segundo for
	            printf(""%i,matriz[i][j]"");
	    }
}

En esta estructura al iniciar el for, se recorre vuelta por vuelta ambos fors, iniciando por la primera vuelta del primer for y continuando con todas las vueltas del segundo for. Siguiendo con la siguiente vuelta del primer for y continuando con todas las vueltas del segundo for, y así sucesivamente.

Esto es muy útil para recorrer arreglos bidimensionales.

Cadena de caracteres (string)

Generalmente se dice que es un arreglo de caracteres cuando lo que se almacenó son caracteres y no existe el carácter nulo al final.

Cuando el arreglo de caracteres termina con el carácter nulo se llama cadena de caracteres.

Funciones: Divide y vencerás

Las funciones son bloques de código que realizan alguna operación o instrucciones. Pueden aceptar datos de entrada (parámetros) y devolver un dato de salida.

Estas al igual que en matemáticas pueden aceptar datos de entrada, a estos les llamamos parámetros o argumentos y datos de salida. La función ya creada que hemos estado utilizado hasta ahorita, es la función main().

Se pueden utilizar para:

Encapsulamiento
Reusabilidad de código
Separar tareas
Cambios a futuro

La sintaxis para escribir una función es la siguiente:

// Estructura
tipo_de_dato nombre(parametros)
{
	Bloque de instrucciones;
}

// Ejemplo
int suma(int a, int b)
{
	return a + b;
}

int - Tipo de dato
suma - Nombre de la función
int a, int b - Parámetros de la función
return a + b; - Bloque de instrucciones

Primero se escribe el tipo de dato de la salida de datos, luego el nombre por el que se identificará la función y finalmente entre paréntesis los parámetros o entrada de datos.

Y entre paréntesis el bloque de instrucciones. No es necesario que una función tenga una entrada y salida de datos, puede tener una, otra, ambas o ninguna.

Pero si tiene salida de datos, el dato final necesita ser descrito con el comando return y el dato que vamos a regresar, que tiene que ser el mismo tipo de dato el cual indicamos inicialmente al crear la función. De la misma manera para los parámetros necesitamos declarar las variables dentro de los paréntesis que vayamos a necesitar, cada una es separada por una coma.

De no necesitar un dato de salida nuestra función puede ser de tipo void, esto quiere decir que no regresa ningún dato.

Variables locales y globales

Las variables globales se declaran fuera de cualquier función y, según donde se declaren, varias funciones pueden tener acceso a ellas.

Naturalmente al tener secciones de código, o sea funciones, creamos una necesidad de tener variables que puedan ser compartidas entre estas. Para esto creamos variables globales.

Variables locales quiere decir que son creadas dentro de una función y solo pueden ser utilizadas en esta función.

La única diferencia entre una variable local y una global es su ámbito de acción.

Variable local: es aquella que sólo es utilizable dentro del código de la función.
Variable global: es aquella cuyo ámbito es todo el programa, incluso dentro de una función.

Recursividad

En C, las funciones pueden llamarse a sí mismas.
Si una expresión en el cuerpo de una función llama a la propia función, se dice que ésta es recursiva.
La recursividad es el proceso de definir algo en términos de sí mismo y a veces se llama definición circular.

Apuntadores

Un apuntador es una variable que guarda la dirección de memoria de otra variable.

Las direcciones de memoria se suelen describir como números en hexadecimal. Un apuntador es una variable cuyo valor es la dirección de memoria de otra variable. Se dice que un apuntador “apunta” a la variable cuyo valor se almacena a partir de la dirección de memoria que contiene el apuntador.

El operador de dirección (&) regresa la dirección de una variable.
El operador de indirección (*) toma la dirección de una variable y regresa el dato que contiene esa dirección.

Sintaxis

float val;

// Declaración del apuntador  
float apVal;

// Regresa la dirección de una variable  
apVal = &val;

// Asignar el dato en la dirección de memoria guardada  
apVal = 3.1416;

Struct y manejo de archivos

Creación y apertura de archivos

Parámetros para la función fopen():

“rb”: Abre un archivo en modo binario para lectura, el fichero debe existir.
“w”: Abrir un archivo en modo binario para escritura, se crea si no existe o se sobreescribe si existe.

Creación y apertura

// Creación y apertura
fopen("DatosPersonales.dat" "r");

// Cierre
fclose(archivo);

DatosPersonales.dat - Nombre y extensión del archivo
r - Modo de accesibilidad del archivo
archivo - Archivo por cerrar

Escritura

fwrite(void *apuntador, size_t tamaño, size_t cantidad, FILE archivo);

Cuenta con cuatro parámetros, estos son:

void *apuntador - Apuntador con la dirección de la información que estamos guardando
size_t tamaño - Tamaño de cada elemento que será escrito
size_t cantidad - Número de elementos
FILE archivo - Apuntador con la dirección al archivo donde estamos guardando/escribiendo

Lectura

fread(void *apuntador, size_t tamaño, size_t cantidad, FILE archivo);

Cuenta con cuatro parámetros, estos son:

void *apuntador - Apuntador con la dirección de la información que estamos leyendo
size_t tamaño - Tamaño de cada elemento que será leído
size_t cantidad - Número de elementos
FILE archivo - Apuntador con la dirección al archivo donde estamos leyendo

Manejo de librerías

Una librería es código de programación ya escrito; un conjunto de funciones independientes para solucionar problemas concretos.

miCodigo.c // Nombre del código donde se llamará la librería

#include "libreria.h" // Hay que llamar la librería previamente hecha con #include

main() // Función creada en libreria.h
{    
    miFuncion();
}

// libreria - Nombre del código
libreria.h // .h - Extension

void miFuncion() 
{
    //Instrucciones
} // Función a llamar en cualquier otro código