martes, 23 de agosto de 2022
Introducción a la programación en C (XV)
miércoles, 10 de agosto de 2022
Introducción a la programación en C (XIV)
definir una constante
Anteriormente, cuando usamos una variable entera para definir la magnitud de un vector, usamos incorrectamente la definición de constante. Dijimos que el tamaño de una matriz debe ser constante, pero si usamos una variable, no respetamos completamente esta restricción.
Una de las muchas palabras clave, " define ", nos permite definir constantes.
La sintaxis de define es la siguiente: #define <nombre constante> <valor constante>
Todas las constantes deben definirse fuera de main y, en general, colocarse bajo todas las inclusiones de la biblioteca.
#incluir <stdio.h>
#define DIM 4
int principal () {
vector int [DIM];
}
la diferencia con el uso de una variable es que #define define constantes inmutables . De ahora en adelante, usaremos constantes para definir el tamaño de un vector o escribiremos el número directamente.
Introducción a la programación en C (XIII)
Llenado secuencial de vectores
Ahora introducimos un nuevo uso de los bucles, de hecho gracias a ellos podremos llenar nuestros vectores con muy pocas líneas de código. El principio es poner, dentro de los corchetes, el índice utilizado por el ciclo inicializado en la posición 0 de nuestro vector.
En cada ciclo, nuestro índice aumentará y nos moverá a la siguiente posición del vector. Cabe recordar que el número encerrado entre corchetes no es un tipo de dato sino un número constante que indica únicamente el tamaño o el número de vagones de nuestro tren.
De hecho, es posible usar una variable entera inicializada:
int dim = 5;
vector int [dim];
Si bien usar solo una variable declarada será imposible:
int dim;
vector int [dim] // ERROR
• Uso del bucle for para imprimir y rellenar
#include <stdio.h>
int principal () {
int dim = 5;
vector int [dim];
for (int i = 0; i <dim; i ++) {// llenar
vector [i] = i;
}
for (int i = 0; i <dim; i ++) {// imprimir
printf ("vector [%d] =%d \n", i, vector [i]);
}
}
Hay poco que explicar, en el primer ciclo se usa la variable incremental del for tanto para tomar el contenido de cada posición en el Array como para llenarlo con el mismo valor. De hecho, "i" tiene el mismo valor tanto a la izquierda de la misma como a la derecha, lo que cambia es el uso.
En el segundo ciclo se imprime el contenido del vector, de hecho el vector [i] define el contenido en la posición i.
Introducción a la programación en C (XII)
Vectores o arrays
¿Qué son los vectores en C?
Un vector , si queremos formalizar el concepto, es una colección finita de elementos del mismo tipo, cada uno de los cuales está definido por un índice.
Imagina un tren compuesto por un número definido de vagones , cada vagón está identificado por un número y en cada vagón es posible insertar algo. ¡Bueno! En “C” somos capaces de crear trenes que de ahora en adelante llamaremos arrays/vectores.
Su estructura es la siguiente: <tipo> <nombre_vector> [<tamaño>]; Aquí hay un ejemplo de un vector de números enteros de tamaño 5.
#include <stdio.h>
int principal () {
vector int [5];
}
La declaración es similar a la de cualquier variable. Además, a lo ya aprendido, se agregan corchetes donde se debe ingresar dentro de ellos el número de elementos presentes en el vector.
Inicializar un vector
Para inicializar/rellenar nuestro vector podemos seguir dos formas:
• El primero es definir el tamaño del vector y luego rellenarlo.
#include <stdio.h>
int principal () {
vector int [4];
vector [0] = 1;
vector [1] = 2;
vector [2] = 0;
vector [3] = -2;
}
• La segunda es no definir la cantidad sino inicializarla en la declaración. De esta manera, sin embargo, se definirá una cantidad.
Después del igual, se abren los corchetes y se dividen los elementos con una coma. Cuidado con el punto y coma, sigue siendo una declaración de variable.
#include <stdio.h>
int principal () {
vector int [] = {1,2,3,4}; // inicialización y declaración
}
Sin embargo, el primer caso se puede llenar de la misma manera que el segundo. Lo único que no se puede hacer es no definir que tamaño va a tener.
El número que define el tamaño del vector corresponde exactamente al número escrito, es decir si ingresa el vector se compone de 2 elementos, cuando desea inicializar cada posición con un valor (como en el caso 1) el índice comienza desde 0 y no desde 1.
Entonces, si "vector" está compuesto por dos elementos [2], la inicialización será v [0] = "algo", v [1] = "algo" y no v [1] y v [2]
#include <stdio.h>
int principal () {
vector int [2] = {22, 33};
printf ("contenido del vector en la posición 1 =%d \n", vector [0]);
printf ("contenido del vector en la posición 2 =%d \n", vector [1]);
}
Introducción a la programación en C (XI)
bucles de bucles!
Evidentemente nadie nos prohíbe unir uno o más bucles aunque sean de distinta naturaleza (for of while, while of while…). Lo único importante que hay que entender es cómo cooperan entre sí.
#incluir <stdio.h>
int principal () {
printf ("para de para \n");
for (int i = 0; i <2; i++) {
for (int j = 0; j <3; j++) {
printf("i=%dj=%d\n",i,j);
}
}
}
La instrucción contenida en el "for" externo es en sí misma un bucle y, como tal, no puede terminar su ejecución a menos que primero haya verificado su condición. El bucle for interno, de hecho, termina cuando ha ejecutado su instrucción 3 veces (j <2). Si observa que la variable “i” permanece durante toda la duración del ciclo interno establecida en 0, solo después de eso se incrementará y solo después de que haya terminado el ciclo interno puede detener su ejecución.
Obviamente, es posible aumentar la profundidad del código insertando más bucles. Mi consejo es no poner demasiados para evitar que el código se vuelva demasiado pesado y lento de ejecutar.
Introducción a la programación en C (X)
for, while o do-while? ¡Este es el dilema!
Comparemos el potencial de las 3 instrucciones realizando este sencillo ejercicio.
Suma de los primeros 10 enteros positivos.
Esto significa que debe realizar la suma 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10. Este cálculo particular se puede interpretar como una ecuación. Si tomamos en consideración solo la suma 1 + 2 se puede calcular como 1 + 1 + 1 o usando las variables:
Si x = 1 e i = 1, la suma 1 + 2 se puede escribir como x = x + (i + 1) . Si insertamos esta operación en un ciclo, aumentando la "i" en 1 en cada reingreso al ciclo, a la décima vez tendremos el mismo resultado que la suma 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10.
• for
int principal () {
int x = 1;
for (int i = 1; i <10; i ++) {
x = x + (i + 1);
}
printf ("%d \n", x);
}
• while
int principal () {
int x = 1;
int i = 1;
while (i <10) {
x = x + (i + 1);
i++;
}
printf ("%d \n", x);
}
• do while
int principal () {
int x = 1;
int i = 1;
hacer {
x = x + (i + 1);
i++;
} while (i <10);
printf ("%d \n", x);
}
No hay una diferencia real, los tres son buenos para resolver la mayoría de los problemas que necesitan instrucciones iterativas. El consejo que te doy es que uses el " for" cuando necesites una variable incremental; de hecho, solucionamos este problema en menos líneas de código que usando while y do-while.
Otro posible uso del "for" es poder crear bucles infinitos, pero infinito también significa la imposibilidad de salir del for y cerrar automáticamente el programa.
#incluir <stdio.h>
int principal () {
por (;;) {
printf ("Soy un bucle infinito \ n");
}
}
Uno de los principios fundamentales de la programación en C es que un programa comienza y termina en un tiempo definido (puede ser largo pero tarde o temprano terminará), con este procedimiento el ciclo infinito no permite la terminación natural del programa.
Para detener un bucle infinito, necesariamente debe finalizar la ejecución presionando la tecla "detener" de su IDE.
Sin embargo, estos errores no se dan solo con el uso del for (;;), basta con confundir la condición de evaliación de un bucle (ya sea for o while...) para que por arte de magia se atasque en un bucle infinito.
Pausa y parada de un ciclo.
Para resolver el problema de los bucles infinitos, es una buena idea detener la ejecución manualmente:
Piense en un programa que finaliza su ejecución después de que la suma de un número indefinido de números sea igual a 100. Sin saber a priori los números introducidos por un usuario, es útil utilizar bucles infinitos.
para poder salir del ciclo, se utiliza la palabra clave "break" (ya la utilizamos para salir del "case" del "switch"). Una vez alcanzada la suma == 100 invocaremos "break" que detendrá el ciclo.
#incluir <stdio.h>
int principal () {
int x = 0;
int suma = 0;
printf ("Suma x números hasta llegar a 100 \ n");
for (;;) {
printf ("ingrese un número: \n");
scanf ("%d", &x);
suma = suma + x;
printf ("suma =%d\n", suma);
if (suma > 100) {
printf ("¡ha superado el límite máximo de 100! \n");
printf ("restablecer la aplicación \n");
suma = 0;
x = 0;
}
if (suma == 100) {
printf ("ha llegado a 100 \n");
break; // cuando se llega a 100, el break sale del ciclo
}
}
printf ("Salí del ciclo for porque se invocó la instrucción break \n");
}
La construcción de un menú iterativo en C
La construcción de un menú iterativo en C
Gracias a la instrucción switch, que vimos anteriormente en el blog, podemos crear una especie de menú que nos permitía realizar ciertas acciones predeterminadas. El defecto de este programa es que cuando termine de realizar una acción (sumar, multiplicar, etc.) el programa finalizará su ejecución.
Con el bucle do-while podemos solucionar el problema.
Ejemplo : Una calculadora que realiza las operaciones de sumar, restar y multiplicar dos números.
#incluir <stdio.h>
int principal () {
int menu_choice;
float a,b,result;
printf("Calculadora v.1.0.0\n");
printf ("1 - suma dos números \n");
printf ("2 - resta dos números \n");
printf ("3 - multiplica dos números \n");
printf ("4 - salir del programa \n");
printf("\n");
do {
printf ("¿Qué acción desea realizar? \n");
printf (">>");
scanf ("%d", & opción_menú);
switch (menu_choice) {
case 1:
printf("\n");
printf ("insertar valor en:");
scanf ("%f", &a);
printf ("insertar valor b:");
scanf ("%f", & b);
printf("\n");
result = a + b;
printf ("resultado:%f\n", result);
break;
case 2:
printf("\n");
printf ("insertar valor en:");
scanf ("%f", &a);
printf ("insertar valor b:");
scanf ("%f", &b);
printf("\n");
result = a - b;
printf ("resultado:%f\n", result);
break;
case 3:
printf("\n");
printf ("insertar valor en:");
scanf ("%f", &a);
printf ("insertar valor b:");
scanf ("%f", &b);
printf("\n");
result = a * b;
printf ("resultado:%f\n", result);
break;
case 4:
printf ("Salí del programa \n");
break;
default:
printf ("ingresó una opción no válida \n");
break;
}
} while (opción_menú! = 4);
}
Explicación del código para las líneas:
• 4 - 7 , instala las variables que necesitará dentro del programa. dos variables (a y b) de tipo float para gestionar todo tipo de números, una variable para elegir la operación a realizar (choice_menu) y una variable que guarda el valor del resultado.
• 9 - 14 , imprime las características de mi menú en la pantalla.
• 17 - 20 , una vez ingresado el "do" empiezo a adquirir los datos del teclado para la operación que desea realizar. Esta adquisición debe colocarse dentro del bucle do-while para permitir que el usuario elija posteriormente otras operaciones para realizar.
• 22 - 63 , una vez adquirida la elección a través del teclado, el switch realiza el case concreto. Tenga en cuenta que el mismo código se repite en cada case, solo cambia la operación que realiza.
• 64 , después de ejecutar uno de los “cases” pasamos al “while” si el valor de la elección es diferente a 4 entonces se seguirá ejecutando a partir del “do” hasta elegir la opción 4.
Introducción a la programación en C (IX)
El bucle For en C
La sintaxis del bucle for es la siguiente:
for (<inicialización>; <condición>; <incremento>) {
<instrucciones de bucle>
}
• <inicialización> Se instancia una variable (se le debe dar un valor) que tenga en cuenta las repeticiones del bucle. generalmente es una variable entera y se suelen utilizar los siguientes nombres "i", "j", "k".
• <condición> La condición por la cual el ciclo sigue repitiéndose. como para el while o el do-while.
• <incremento> Esta instrucción determina el comportamiento de la instrucción instanciada en la instrucción 1. En general, la variable se incrementa o se reduce en cada ciclo según sea necesario. Los incrementos más utilizados son variable ++ o variable -- .
así es como se convierte en el ejemplo en la impresión de 10 "hola mundo" con el bucle for:
#incluir <stdio.h>
int principal () {
para (int i = 0; i <10; i ++) {
printf("Hola Mundo\n");
}
}
Como queremos imprimir 10 veces, nos conviene instanciar una variable en 0. El ciclo continuará hasta que "i" sea menor que 10. En cada paso del ciclo, "i" aumentará en 1. No se debe poner <= porque de 0 a 9 hay 10 pasos.
Introducción a la programación en C (VIII)
Instrucciones iterativas o bucles
Iterar es un término usado en el mundo de la programación para indicar la repetición de una o más líneas de código. Estas instrucciones surgen de la necesidad de poder fusionar y agilizar el código.
Imagina tener que imprimir la misma línea 100 veces. La verdad es que puede llegar a ser bastante tedioso, con las herramientas que tenemos, tener que escribir el mismo código 100 veces.
#incluir <stdio.h>
int principal () {
printf("hola mundo\n");
printf("hola mundo\n");
printf("hola mundo\n");
printf("hola mundo\n");
printf("hola mundo\n");
// por 100 veces
}
El ciclo while en C - Condición inicial
Una de las primeras instrucciones para ayudarnos es la instrucción while. Mientras no se cumpla una condición, continúa ejecutando las instrucciones dentro de su bloque.
Ahora con esta nueva instrucción repitamos el ejemplo anterior e intentemos imprimir la cadena “Hello World” 10 veces. Antes de continuar con el código, necesitamos un momento para entender cómo usar completamente esta nueva herramienta.
• Para verificar la condición necesitaremos una variable, llamémosla con la letra “i”, que tiene en cuenta la cantidad de veces que se imprime “Hello World” en la pantalla. Se inicializará a int i = 0 ya que cuando encuentra la instrucción while aún no ha impreso ninguna cadena.
• Cada vez que i <10 ingrese la instrucción, imprimirá "Hello World" e incrementará i en una unidad, i = i + 1 .
• Cuando el while haya verificado que i == 10 , procederá con el resto del código principal.
#incluir <stdio.h>
int principal () {
int i = 0;
while (i <10) {
printf("Hola Mundo\n");
i = i + 1;
}
printf ("Se a imprimido por pantalla un total de %d\n", i);
printf ("código final \ n");
}
Do While - Bucle con condición final
De la misma forma que el bucle anterior, el do-while permite , de forma inversa, ejecutar primero una instrucción y luego verificarla .
#incluir <stdio.h>
int principal () {
int i = 0;
do {
printf("hola mundo\n");
i = i + 1;
} while (i <10);
printf ("Se a imprimido por pantalla %d veces \ n", i);
}
• ¡Ten cuidado! el bucle do-while siempre ejecuta las sentencias "do" al menos una vez . En algunas circunstancias puede ser útil, en otras desastroso.
• Observa que usamos un punto y coma después de los corchetes while. mientras (yo <10);
Introducción a la programación en C (VI)
Declaraciones condicionales
If -Else
C proporciona dos palabras clave para verificar la veracidad de una condición o no. Estas palabras son “if (condición)” - “if else”, “si” la condición entre paréntesis generará 1 (es decir, la condición es verdadera) haz algo “sino” haz otra cosa.
int main() {
int x = 4;
int y = 5;
if (x > y) { // si x > y resultará en VERDADERO
// ingresa dentro de los corchetes
printf (“x es mayor que y“);
}
else {// de lo contrario (FALSO) haz lo que viene después de else
printf (“y es mayor que x“);
}
}
Si la condición if se verifica inmediatamente , una vez que se ejecuta la declaración dentro de sus paréntesis , la declaración else nunca se ejecutará .
Una sentencia if-else también puede estar en la forma sin el else. Esto no quiere decir que el código después del if se interpretará como si hubiera un else. El código después de los corchetes del if es parte del código principal y se ejecutará independientemente.
int principal () {
entero x = 4;
int y = 2;
si (x! = y) {
printf (“x no es igual a y”);
}
// terminó de ejecutar la sentencia if el programa
// continuará su ejecución normalmente
// por lo tanto presta atención a lo que escribes a continuación
printf (“x es igual a y“); // ¡¡ ambigüedad !!
}
También hay una forma contraída sin los corchetes que solo proporciona la ejecución de una declaración para el si y en caso de que también exista para el otro.
int main() {
float a;
float b;
float c;
a = 2.5;
b = 2;
c = 3.33;
if(a > b && b < c)
printf (“a es mayor que b y b es menor que c“);
else printf (“a es menor que b y b mayor que c“);
}
if (condición) - else if (condición) es la forma más compleja y le permite anidar múltiples condiciones. Esta forma se utiliza cuando se desea evitar en la medida de lo posible el manejo de datos incorrectos.
int main() {
float retiro, saldo;
saldo = 1000; // Supongamos que hay 1000 euros en la cuenta
printf("ingrese el valor para obtener n");
scanf("%f", &buscar);
if(retiro > saldo) {
printf("¡Error! No puedes retirar más que el saldo");
}
else if (retiro < 0) {
printf("no puede retirar una cantidad negativa n");
}
else if (retiro < saldo) {
printf("usted ha retirado %f euro n", retiro);
saldo = saldo - retiro;
printf("%f euro permanecen en su cuenta", saldo);
}
}
¡Atención! Poner una declaración if antes de otra puede resultar en errores lógicos graves. De hecho, en este ejemplo bastaba con poner el else if (retiro <0) después del else if (retiro <saldo) que mágicamente, una vez introducido un retiro negativo, nuestra cuenta se habría incrementado en esta cantidad.
Introducción a la programación en C (VII)
Instrucción de selección - switch
Con el if hemos visto que este tipo de sentencias no son solo condicionales sino también de selección . El if-else es un método de selección bidireccional, si una condición no se cumple, ejecuta la otra u otras según el nivel de anidamiento.
Ahora introducimos un método más complejo que es creado por la instrucción de selección “switch”, este tipo de instrucción permitirá, una vez que ocurra un evento, poder seleccionar su instrucción relativa para ejecutar. Podemos considerar el switch como una declaración if con muchos ifs dentro solo con un estilo de representación más mínimo.
switch en C
La instrucción switch tiene la siguiente sintaxis:
switch (variable) {
case <constante1>: <sentencia1>
case <constante2>: <sentencia2>
case <constante_x>: <instrucción_x>
default: <instrucción_predeterminada>
}
Entonces cuando hay un cambio en una variable podemos canalizar un evento asociado a este cambio en uno de los cases que puede manejar el cambio. Si el cambio no está bloqueado en ninguno de los cases, ejecutará la declaración predeterminada.
#include <stdio.h>
int principal () {
int variable;
printf ("ingrese 1 para imprimir <¡Hola mundo!> \ n");
printf ("ingrese 2 para imprimir <¡Mi nombre es Mario!> \ n");
printf("insertar 3 imprimir en pantalla la suma de dos enteros ingresados por teclado\n");
printf (">>"); // no importa esta línea, simplemente embellece el código
scanf ("%d", &variable);
switch (variable) {
case 1: // si el número elegido es 1 hacer este case
printf("Hola Mundo\n");
break;
case 2:
printf("Mi nombre es Mario\n");
break;
case 3: {
int a;
int b;
printf ("ingrese el valor de a: \n");
scanf ("%d", &a);
printf ("ingrese el valor de b: \n");
scanf ("%d", &b);
b = b + a;
printf ("la suma es igual a:%d\n", b);
break;
}
default:
printf ("ingresó una opción no válida \ n");
break;
}
}
Dado que el código se está empezando a complicar. Tomemos un momento para hacer una pausa y analizar los puntos más destacados.
• switch (variable) El switch es como un controlador, realiza un seguimiento de todos los cambios de una variable. Apenas llega la ejecución de nuestro código a la línea switch ve el valor de la variable entre paréntesis y se lo guarda para poder analizarlo en el código
• case change_variable: Después de la palabra clave case , se debe insertar el valor de la variable para la que se desea desencadenar una acción. dos puntos : indica el comienzo del código a ejecutar.
Si el código que desea insertar se compone de varias líneas, debe insertar las llaves después de los dos puntos. Dentro de los paréntesis se puede comportar como si estuviera trabajando dentro de un main.
• break Esta palabra clave es muy importante e indica el final de su case . Debe insertarse en la última línea del código de un case y cada case debe tener su propio break. Si intenta deshacer una ruptura, encontrará que su programa nunca saldrá del bloque.
• default: cualquier valor de variable no capturado por el case se anulará en el case default.
El uso del switch
Uno de los usos clásicos del switch está relacionado con la creación de menús. Cada programa siempre realiza las mismas acciones: retirar o añadir dinero de una cuenta, sumar o restar... Cada programa tiene su propio conjunto de acciones que el usuario repetirá varias veces al día. Para acceder a estas acciones es importante tener un método de acceso rápido, el switch es la instrucción ideal para tal menester.
Ejemplo: Un programa que automatiza la suma, multiplicación y división entre dos números.
#include <stdio.h>
int principal () {
char select;
float x;
float y;
printf ("<<< Calculadora >>> \ n");
printf("insertar numero:");
scanf ("%f", &x);
printf("ingrese el segundo numero:");
scanf ("%f", &y);
printf("\n");
printf (">> Menú multipunto \n");
printf ("a - Suma dos números \n");
printf ("b - Multiplica dos números \n");
printf ("c - Divide dos números \n");
printf ("insertar opción: \n");
scanf ("%c", &select);
printf("\n");
swich (select) {
float resultado;
case 'a':
printf ("suma los dos números \n");
resultado = x + y;
printf ("resultado: %f\n", resultado);
break;
case 'b':
printf ("Multiplico los dos números \n");
resultado = x * y;
printf ("resultado:%f\n", resultado);
break;
case 'c':
printf ("divide los dos números \n");
resultado = x / y;
printf ("resultado:%f\n", resultado);
break;
default:
printf ("ingresó una opción no válida \n");
break;
}
}
Determinar si un número es múltiplo de otro número con C
A veces es importante poder determinar si un número es múltiplo de otro número. Para poder determinarlo inmediatamente, C nos proporciona un método bastante inmediato.
Para determinar cuando x es múltiplo de y en “C”, se utiliza el símbolo de % . Si el número es múltiplo, por ejemplo 4% 2, la operación devuelve como resultado 0 de lo contrario 1.
Esto se debe a que realiza la división entre x e y y si la división no da resto (es decir, tiene resto 0) devuelve 0 en caso contrario devuelve 1.
#include <stdio.h>
int principal () {
intx = 6% 3;
printf (“%d \n“, x);
}
Con declaraciones condicionales, podemos comparar cualquier número.
#include <stdio.h>
int principal () {
intx;
int y;
printf (“insertar x:“);
scanf (“% d“, & x);
printf (“insertar y:“);
escanear (“% d“, & y);
if (x% y == 0) {
scanf (“% d es un múltiplo de% d \ n“, x, y);
}
}
Introducción a la programación en C (V)
La mayoría de las comprobaciones de una variable se realizan por comparación (si x es diferente de y, entonces realice una operación...). La transposición de una comparación a código se realiza mediante el uso de operadores, algunos tomados del léxico matemático, otros creados ad hoc.
Y si se verifica la igualdad, el programa enviará un mensaje numérico que identifica cuándo la operación fue exitosa o no.
El lenguaje C como mensaje de retorno de una operación lógica utiliza 1 para indicar que la operación es exitosa y 0 cuando es falsa. Esto quiere decir que: cuando escribimos 4 > 2 nuestro programa devolverá el entero 1 como si significara: <¡Sí! 4 es mayor que 2> .
Este sistema se aplica a todos los operadores lógicos y el mensaje devuelto por la operación será manejado a través de sentencias condicionales.
A continuación encontrarás todos los diversos operadores indicados por su simbología, encerrados entre paréntesis, utilizados en C.
Igualdad (==)
La igualdad, como ya se mencionó anteriormente, no se resuelve con el símbolo matemático = (les recuerdo que tiene la función de asignar algo a una variable) sino con el doble igual ==.
Imaginemos que tenemos dos variables x = 4 e y = 4. Decir que x es igual a y es equivalente a decir que x == y o viceversa.
Desigualdad (! =)
De manera similar a lo que vimos anteriormente, x = 5 e y = 3, si dos variables tienen valores diferentes escribiremos que x! = Y.
Mayor y menor (> y <) y Mayor igual y Menor que igual (> = y <=)
Al igual que las matemáticas> y <tienen la misma función en la programación.
Y, O y No (&&, || e!)
Comprenderá mejor estos tres símbolos cuando se traten las declaraciones condicionales. La utilidad de los dos primeros símbolos es para agrupar más operadores, es decir:
x = 5, y = 4 y z = 5 si necesitamos comparar las tres variables a la vez según nuestras necesidades podemos usar && o ||.
¿x es simultáneamente igual a y y z? En código esta expresión (independientemente de cómo preguntemos en c) ¿podemos escribirla como x == y && x == z? . Si una de las dos expresiones a la izquierda oa la derecha de && no coincide, la expresión completa será FALSA. De lo contrario, se deben verificar ambas expresiones.
¿Es x igual a y o a z? Como antes, el mecanismo es el mismo, solo cambia el símbolo.
x == y || x == z. En este caso, la veracidad de una de las dos expresiones es suficiente para completar la expresión completa.
martes, 2 de agosto de 2022
Introducción a la programación en C (IV)
Sentencias, expresiones y operadores
Sentencias
Una sentencia es una instrucción completa, que da instrucciones al equipo en el que se está ejecutando el programa, para realizar una tarea. Por norma general se escribirán en una sola línea y siempre terminaran con el símbolo “;”, a excepción de las directivas del preprocesador como #define y #include
Un ejemplo claro de sentencia son las sentencias de asignación que ya habíamos visto indirectamente cuando analizamos las variables:
x =x+1;
Una peculiaridad de las sentencias es que el compilador ignora los espacios en blanco:
x=x+1;
Es igual a:
x = x + 1;
Esta peculiaridad que hemos comentado anteriormente, debemos de usarla con cuidado ya que uno de nuestros objetivos como desarrolladores, siempre tiene que ser que el código fuente que desarrollemos sea legible.
Esta regla de que en C no se tengan en cuanta los espacios tiene además otra excepción y es que dentro de las constantes literales de cadenas de texto, los espacios no serán ignorados sino que son considerados parte de la cadena:
cad= “Los espacios dentro de la cadena si que se tienen en cuenta”;
Expresiones
En C una expresión es cualquier cosa que evalúa a un valor numérico y pueden ser simples o complejas.
- Expresiones simples:
La expresión mas simple que tenemos en C consiste en un solo concepto: Una simple variable, constante, literal o constante simbólica.
- Expresiones complejas
Las expresiones complejas consisten en expresiones simples conectadas por un operador, por ejemplo:
8 + 4;
Operadores
Un operador es un símbolo que le da instrucciones a C para que ejecute alguna operación o acción
Tabla de Operadores de C
Operadores aritméticos |
|
Nombre del operador |
Sintaxis |
Suma |
a + b |
Suma y asignación |
a += b |
Resta |
a - b |
Resta y asignación |
a -= b |
Multiplicación |
a * b |
Multiplicación y asignación |
a *= b |
División |
a / b |
División y asignación |
a /= b |
Módulo |
a % b |
Módulo y asignación |
a %= b |
Más unario (promoción entera) |
#NAME? |
Menos unario (opuesto) |
-a |
Incremento prefijo |
#NAME? |
Incremento postfijo |
a++ |
Decremento prefijo |
--a |
Decremento postfijo |
a-- |
Operadores de comparación |
|
Nombre del operador |
Sintaxis |
Menor que |
a < b |
Mayor que |
a > b |
Menor o igual que |
a <= b |
Mayor que o igual que |
a >= b |
Igual que |
a == b |
Diferente que / No igual que |
a != b |
Comparación a tres sentidos |
a <=> b |
Operadores lógicos |
|
Nombre del operador |
Sintaxis |
Negación lógica (NOT) |
!a |
Y lógico (AND) |
a && b |
O lógico (OR) |
a || b |
Operadores a nivel de bit |
|
Nombre del operador |
Sintaxis |
Desplazamiento a la izquierda |
a << b |
Asignación con desplazamiento a la izquierda |
a <<= b |
Desplazamiento a la derecha |
a >> b |
Asignación con desplazamiento a la derecha |
a >>= b |
Complemento a uno |
~a |
AND binario |
a & b |
Asignación con AND binario |
a &= b |
OR binario |
a | b |
Asignación con OR binario |
a |= b |
XOR binario |
a ^ b |
Asignación con XOR binario |
a ^= b |
Nos vemos en la parte V ^^
jueves, 28 de julio de 2022
GBDK-2020 (II)
Esqueleto básico de un juego en GBDK
Todos los juegos realizados con GBDK-2020 Utilizan un esqueleto común, con algunas variaciones a modo de template, por este motivo, vamos a analizar uno de estos, el que use yo para aprender esta tecnología y lo analizaremos para intentar entenderlo
//includes and imports
#include <gb/gb.h>
//Variables area
//functions declarations area
void checkInput();
void updateSwitches();
//Main function
void main() {
while(1) {
checkInput();
updateSwitches();
wait_vbl_done();
}
}
void updateSwitches() {
HIDE_WIN;
SHOW_SPRITES;
SHOW_BKG;
}
//Butons functions
void checkInput() {
// START
if (joypad() & J_START) {
}
}
Incluimos Vamos a analizar el código que hemos visto anteriormente para intentar entender como funciona:
#include <gb/gb.h>
Incluimos las librerias de gameboy en nuestro código, la librería gb.h es la que incluye la mayoria de las funnciones que necesitaremos para nuestros desarrollos
void checkInput();
void updateSwitches();
Declaramos las funciones que vamos a necesitar
void main() {
Funcion principal y de entrada del juego
while(1) {
Bucle principal del juego, este bucle se repite cíclica-mente para generar la sensación de animación y vida al juego, en cada ciclo se hacen los cambios necesarios en la pantalla y se muestran ademas de comprobar las pulsaciones de la botonera de la consola.
checkInput();
updateSwitches();
wait_vbl_done();
Llamadas a las funciones para comprobar que se a pulsado algún botón de la consola y refrescar la pantalla con los cambios
void updateSwitches() {
En el cuerpo de esta función especificaremos los refrescos de pantalla con constantes propias de la librería gb.h
HIDE_WIN;
SHOW_SPRITES;
SHOW_BKG;
Constantes de refresco de la libreira gb.h su funcion es mostrar los sprites y el fondo en cada ciclo de refresco.
void checkInput() {
En el cuerpo de esta función especificaremos los comportamientos de entrada de la consola por los botones
if (joypad() & J_START) {
Este condicional se ejecuta si se a pulsado el botón start de la consola, en este bloque añadiremos pues la lógica que queramos si el botón es pulsado
¿Qué opinas de esta entrada? ¿tienes dudas? espero tus comentarios.
-
El Romhack es una rama del homebrew un poco particular. Para empezar, ROM significa memoria de solo lectura , que proviene del chip dent...
-
Kirby es una de las últimas mascotas de Nintendo. De hecho, fue creado en 1992 por Masahiro Sakurai y viene, cronológicamente, despué...
-
No, no es un error ortográfico, La Lellenda de la Cerda es un buen ejemplo de juego ROMHack, una versión modificada del link’s awakening...