Ediciones ENI Editorial | líder en informática
Lenguaje C - Algoritmíca: iniciación
Objetivos del capítulo
Los objetivos de este capítulo son presentar la sintaxis del lenguaje, los tipos de datos utilizables, algunas funciones, los operadores y las estructuras lógicas.
Al final de este capítulo, el lector será capaz de desarrollar algunas aplicaciones estructuradas.
Todos los programas están escritos en lenguaje C y se compilan y ejecutan usando el software Code::Blocks.
Primer programa
1. Programa completo
El siguiente programa presenta las principales características del lenguaje C:
/* ========================================================================== */
/* Proyecto: initInt -- Introducir dos números, visualización de la suma */
/* -------------------------------------------------------------------------- */
/* Autor: M. Gineste */
/* ========================================================================== */
#include <stdio.h>
int main()
{
int a, b, sum;
printf("Introduzca dos números: ");
scanf("%d %d", &a, &b);
sum = a + b;
printf("La suma es %d\n\n", sum);
return 0;
} A continuación se muestra el resultado de la ejecución de este programa:
2. Explicaciones detalladas del programa
a. Los comentarios
En lenguaje C, un comentario empieza por /* y termina por */.
El programa empieza con cinco líneas de comentarios:
/* ========================================================================== */
/* Proyecto: initInt -- Introducir dos números, visualización de la suma */
/* -------------------------------------------------------------------------- */
/* Autor: M. Gineste */
/* ========================================================================== */ Un comentario se puede escribir en varias líneas. Podemos escribir:
/* ========================================================================= ...Los tipos básicos
1. Tipos enteros
Hay tres tipos de entero: int, short (short int), long (long int).
Ejemplos
int i;
short s; /* o short int s; */
long l; /* o long int l; */
i = 10;
s = 10;
l = 10L; /* Constante de tipo long */ Los tres tipos se diferencian por su tamaño en número de bytes; por lo tanto, por el ámbito de los valores que podemos almacenar.
Una variable de tipo int ocupa cuatro bytes. Un short debería ser más pequeño, un long más grande. Pero estos tamaños pueden ser diferentes de una máquina a otra.
El tipo char también es un tipo entero en un byte. Es perfecto para almacenar el código ASCII de un carácter, de ahí su nombre.
Todos estos tipos se pueden declarar sin signo: unsigned, lo que limita su utilización a los números enteros positivos. Esto cambia el ámbito de los valores que podemos almacenar.
Ejemplo
Una variable char puede contener los valores incluidos entre -128 y +127.
Una variable unsigned char puede contener los valores incluidos entre 0 y +255.
2. Tipos flotantes
Hay dos tipos flotantes (números con «coma»): float, double.
Ejemplo
float f;
double d; ...Ejemplos de formatos numéricos para la función printf()
|
Formato |
Variable que se va a mostrar |
|
%d |
Entero (int, short, char) |
|
%ld |
Entero (long) |
|
%6d |
Entero justificado a la derecha en 6 columnas |
|
%-6d |
Entero justificado a la izquierda en 6 columnas |
|
%f |
Real (float, double) |
|
%17.3f |
Real justificado a la derecha en 17 columnas, con 3 cifras después de la coma |
|
%-17.3f |
Real justificado a la izquierda en 17 columnas, con 3 cifras después de la coma |
El siguiente programa muestra algunas posibilidades de la función printf() para la presentación de datos numéricos:
int main()
{
int a;
float b;
a = 17;
b = 17.0;
printf("%%d : %d\n", a);
printf("%%6d : %6d\n", a);
printf("%%-6d: %-6d\n\n", a);
printf("%%f : %f\n", b);
printf("%%17.3f : %17.3f\n", b);
printf("%%-17.3f : %-17.3f\n\n", b);
return 0;
} El resultado de la ejecución es el siguiente:
Principales códigos de formato de la función scanf()
|
Formato |
Entrada esperada |
Tipo del argumento |
|
%c |
un único carácter |
char* |
|
%s |
una cadena de caracteres |
char* |
|
%d |
un entero |
int* |
|
%ld |
un entero de tipo long |
float* |
|
%f |
un real (número con coma) |
float* |
|
%lf |
un real de tipo double |
double* |
La estrella junto al tipo de argumento (ejemplo: int*) significa que el argumento debe ser una dirección de variable.
Ejemplo
double a;
printf("Escribir el valor de a:");
scanf("%lf", &a); a es una variable de tipo double, el formato es %lf, &a es la dirección de a.
Algunos operadores
1. Operadores aritméticos
|
Operador |
Efecto |
|
+ |
Suma |
|
- |
Resta |
|
* |
Multiplicación |
|
/ |
División |
|
% |
Módulo |
Los paréntesis ( y ) son operadores que permiten indicar el orden de ejecución de los operadores.
Ejemplo
La expresión (a + b) % c suma las variables a y b, y después calcula el resto de la división (módulo) de este total por c.
2. Operadores de comparación
|
Operador |
Efecto |
|
> |
El operando situado a la izquierda es superior al operando situado a la derecha. |
|
< |
El operando situado a la izquierda es inferior al operando situado a la derecha. |
|
>= |
El operando situado a la izquierda es superior o igual al operando situado a la derecha. |
|
<= |
El operando situado a la izquierda es inferior o igual al operando situado a la derecha. |
|
== |
El operando situado a la izquierda es igual al operando situado a la derecha. |
|
!= |
El operando situado a la izquierda es diferente del operando situado a la derecha. |
Ejemplo
if (a == b)
{
Instrucciones;
} Las instrucciones se ejecutan si a y b contienen el mismo valor. Preste atención al doble signo «igual».
3. Operadores de asignación
|
Operador |
Efecto |
|
= |
Vuelve a copiar el operando situado a la derecha en la variable situada a la izquierda. |
|
+= |
Añade el operando situado a la derecha en la variable situada a la izquierda. |
|
-= |
Resta el operando situado a la derecha, de la variable situada a la izquierda. |
Ejemplos
a = b;
Copia el contenido de b en a.
a += b;
Añade el contenido de b al de a.
4. Operadores lógicos
|
Operador |
Significado |
|
&& |
Y |
|
| | |
O (inclusivo) |
|
! |
No |
Ejemplo
if ((a == b) && (b!= c))
{
Instrucciones;
} Las instrucciones se ejecutan si a y b contienen el mismo valor Y si b y c contienen valores diferentes....
Estructuras lógicas
if
Instrucción de comprobación.
Si la expresión es verdadera, el programa ejecuta el conjunto de instrucciones 1. En caso contrario, el conjunto de instrucciones 2.
if(expresión)
{
instrucciones 1
}
else
{
instrucciones 2
} switch
Instrucción de comprobación de opción múltiple.
switch (expresión)
{
case constante 1: instrucciones 1
case constante 2: instrucciones 2
. . . .
case constante n: instrucciones n
default : instrucciones
} while
Bucle repetitivo.
Las instrucciones se ejecutan mientras la expresión sea verdadera. La comprobación se realiza al inicio del bucle.
while(expresión)
{
instrucciones
} for
Bucle repetitivo.
-
Expresión 1 se ejecuta una vez antes del inicio del bucle.
-
El bucle se ejecuta mientras expresión 2 sea verdadera.
-
Expresión 3 se ejecuta al final de cada bucle.
for (expresión 1; expresión 2; expresión 3)
{
instrucciones
} do while
Bucle repetitivo.
Las instrucciones se ejecutan mientras la expresión sea verdadera. La comprobación se realiza al final del bucle.
do
{
instrucciones
}
while(expresión); break
Se sitúa al final de un bloque de instrucciones de una estructura switch o de un bucle (do...while, while, for). El programa continúa su ejecución por la instrucción siguiente a la llave que cierra el bloque.
La utilización del break es indispensable en la estructura switch. Su utilización en un bucle implica en general una mala elección de estructura. Solo se utilizará en el switch.
1. La estructura alternativa
a. Organigrama
El esquema anterior es un organigrama.
-
Los rectángulos representan los bloques de instrucciones. Un bloque es una sucesión de instrucciones incluidas entre { y }.
-
Los rombos representan las condiciones que se van a comprobar. En C, una expresión...
Trabajo práctico: estructuras lógicas
1. Tema
Ejercicio 1
Mostrar la lista de los 10 primeros números con su raíz cuadrada (*) y el acumulado de las raíces cuadradas.
Ejercicio 2
Mostrar la lista de los primeros números con su raíz cuadrada (*), el acumulado de las raíces cuadradas, hasta este que el acumulado sea > 30.
Ejercicio 3
Introducir números hasta que su suma sea mayor que 100.
Ejercicio 4
Introducir un número (n).
Si este número es primo, mostrar: «n es un número primo», en caso contrario, mostrar: «n es divisible por div» (div: valor del primer divisor encontrado).
Volver a comenzar esta operación cinco veces.
Ejercicio 5
Introducir un número (n).
Si este número es primo, mostrar: «n es un número primo», en caso contrario, mostrar: «n es divisible por div» (div: valor del primer divisor encontrado).
Volver a comenzar esta operación hasta que se hayan introducido tres números primos.
Indicación útil: la función sqrt()
-
El cálculo de la raíz cuadrada se obtiene llamando a la función sqrt() de la librería de funciones matemáticas.
-
Se describe en el archivo math.h, que hay que incluir en nuestro programa: #include math.h
-
La descripción de la función es: double sqrt(double): recibe un argumento de tipo double y devuelve un double.
2. Estructuras lógicas: proposición de corrección
a. Ejercicio 1
La visualización de los diez primeros números es un bucle repetitivo. Sabemos que habrá que mostrar diez filas. El bucle for se adapta perfectamente:
#include <stdio.h>
#include <math.h>
int main()
{
int i;
double raiz, acumulado;
acumulado= 0;
printf("\nNúmero Raíz Acumulado\n\n");
for (i = 1; i <=...