SEMANA 15

PROCESOS Y ALGORITMOS II
2DO. SEMESTRE

Programación en el Lenguaje C.

El lenguaje C, fue diseñado por Dennies Ritchie en 1970, en los laboratorios Bell de
Estados Unidos.

Este lenguaje presenta varias características, entre las cuales están:

1. Lenguaje de programación de propósitos generales.

2. Permite la Programación Estructurada .
3. Abundancia de Operadores y Tipos de Datos.
4. No está asociado a ningún sistema operativo ni a ninguna máquina.
5. Popular y Eficaz.
6. Permite el desarrollo de Sistemas Operativos y programas de aplicación.
7. Portabilidad.
8. Existen las librerías en las bibliotecas.
9. tiene sólo 32 palabras reservadas.

*Bibliotecas: es el archivo que contiene código objeto de una colección de rutinas o

funciones que realizan tareas determinadas y se pueden utilizar en los programas.

*Enlazador: Programa que convierte las funciones de la biblioteca estándar de C, con el

código que ha traducido el compilador.
Estructura de Un programa en C.

Ya estamos apunto de entrar a lo más interesante, a la programación en sí; pero es

necesario, primero; mencionar algunos de los errores típicos al programar, para que el
lector sepa como identificarlos y así los pueda corregir.

1. ERROR DE SINTAXIS: Estos errores son producidos, cuando se hace mal uso de
las reglas del lenguaje de programación, y se violan las normas de sintaxis, de ese
lenguaje (en nuestro caso C); estos errores son fáciles de detectar porque
generalmente es el compilador, que los identifica (Y hasta muestra la línea donde
se encuentra dicho error, pero eso depende de la versión del compilador que
estemos usando).

2. ERRORES DE EJECUCIÓN: Estos errores se producen , cuando le indicamos a

la computadora, realizar una determinada acción, y esta la comprende, pero no
puede ejecutarla. Por ejemplo, indicarle a la computadora una división entre cero,
sumar dos variables a las cuales no se les ha signado valor alguno, etc.

3. ERRORES DE LÓGICA: Muchas veces, cuando estamos programando, el

compilador no nos indica errores de sintaxis, ni de lógica; pero el resultado de
nuestro programa, esta fuera del rango esperado, esto es producto de un error de
lógica en el código de nuestro programa. Este tipo de errores son muy difíciles de
identificar y por supuesto de corregir, ya que generalmente hay que revisar línea
por línea de nuestro programa. Ejemplo: El sueldo negativo de un empleado, etc.

La estructura de un programa en C, consta de algunas partes esenciales: las cuales son

uno o más módulos llamadas funciones, siendo main() la primera función que es llamada
cuando empieza la ejecución del programa.

Cada función debe contener :

>Directivas de pre-procesador (instrucciones que se le dan al compilador
#include antes de compilar)
#define

ejemplo:
#include <stdio.h>

Lo que se le está indicando, es que de las librerías, “Incluya” en nuestro programa la

directiva stdio.h, la cual contiene las funciones de entrada y salida de datos (standar input
output, en inglés). Si necesitamos las funciones matemáticas, debemos especificarlo con
la declaratoria:
#include <math.h>
Si necesitamos las funciones de cadenas:
#inlcude <stlib.h>
Es necesario aclarar que esto se hace al inicio del programa, y las declaratorias deben
llevar el símbolo de numeral (#) seguido de la sentencia “include”, y entre signos de
mayor y menor que (<>) el nombre de la directiva.

>Declaraciones Globales
pueden ser:

*Prototipos de Funciones: También llamadas declaraciones de funciones, lo cual se

tratará más adelante.

*Declaraciones de Variables
cabe destacar, que esto se hace seguido de los #include y los #define.

>Función Principal main()

Esta es la función principal de nuestro programa, su cuerpo, por ello NUNCA debe faltar,
ya que en ella van contenidas todas las instrucciones de nuestro programa.

la función main() va al inicio, luego abrimos llaves y dentro de ellas van las declaraciones
de variables, las sentencias de lectura, cálculos, asignaciones e impresiones, y con la
última llave ( } ), le indicamos el final del programa.

Ejemplo 1.

Programa que, a partir del radio, calcula el área de un circulo.

Explicación:

Le indicamos al compilador, que usaremos las bibliotecas <stdio.h> y <conio.h>, ¿por qué
<conio.h>?, porque esta biblioteca, contiene las funciones getche(), getch(), etc, y de una
de ellas hacemos uso en este pequeño ejemplo.

Luego, le indicamos el inicio a nuestro programa (función main() ). Declaramos, como

valores reales, las variables radio y área (de esto se hablará más adelante). Luego, con la
instrucción printf(), mostramos en pantalla el mensaje (Radio=) y scanf se encarga de leer
el valor digitado por el usuario. Posteriormente área, es igual a la multiplicación de pi
(3.14159), el radio al cuadrado. Se muestra en pantalla ese resultado, luego el programa
espera que se presiones cualquier tecla (getch() ) y no retorna ningún valor (return 0).

Indique que tipo de error (Error de sintaxis, error de ejecución o error lógico), en cada uno
de los siguientes enunciados.

1. Utilizar una variable antes de asignarle un valor:____________________

2. asignarle un valor real a una variable declarada como entero:______
3. al cometer este error, los resultados arrojados por el programa no son los que se
esperaban:______________________________________________
4. Un programa no puede ser ejecutado por el computador, mientras tenga este tipo
de errores:__________________________________________
5. estos errores no son detectados por el compilador, ni tampoco son errores de
ejecución:_______________________________________________

Mencione y Explique, la estructura general de un programa en C:

Lenguaje de Programación Estructurado C.

¿Por qué programación estructurada?

Si hacemos memoria, hablamos de las características del lenguaje C, y en una de ellas

se decía que, el Lenguaje de Programación C, permite la programación estructurada.
Esto implica que, haremos uso de una técnica llamada Lógica Estructurada, y esto no
es más ni menos que una de las técnicas básicas y fundamentales de la programación,
su objetivo es diseñar soluciones “correctas” y confiables a los problemas, ignorando al
principio consideraciones de eficiencia como la minimización del uso de memoria y el
tiempo de su respuesta.

Lo que significa que, haremos uso de esa técnica para crear programas correctos; esta
es una técnica que ayuda al programador (un tanto a la fuerza), a ser ordenado, al
momento de programar.

Los frutos de ésta técnica se reflejan cuando, queremos darle mantenimiento al

programa, es más fácil hacerlo ya que hemos programado de una manera lógica y
ordenada. Al igual que al momento de corregir errores de sintaxis y lógica, esta técnica
nos facilita el trabajo.

Sintaxis de Algunos Elementos de Un Programa en C.

a) identificadores: Como su nombre lo indica, estos son los nombres, con los que
identificamos las variables, constantes, funciones, vectores, etc, de nuestro programa.
Para ello debemos tener presente algunas reglas:

>pueden tener de 1 hasta un máximo de 31 caracteres

>Debe de iniciar con una letra o subrayado
Ejemplo:
(Correctos)
c2
_c2

(Incorrectos)
2c
2c
>No es lo mismo una minúscula que una mayúscula, ya que c distingue de entre ellas.
Ejemplo: BETA  Beta  beta  BeTa

>No son válidos los identificadores de palabras reservadas. En un inicio hablamos que
c posee 32 palabras reservadas, entre ellas están:
float char while
int else return
Estas palabras no pueden ser utilizadas para identificar variables, constantes,
funciones etc.

b) Comentarios: En todo programa que estemos diseñando en C (o en cualquier otro

lenguaje de programación); es necesario insertar ciertos comentarios en el código,
para que en posteriores modificaciones y cuando se realice el mantenimiento,
podamos recordar cosas importantes ya que, en los comentarios, podemos incluir
aspectos importantes del programas, explicaciones del funcionamiento de las
sentencias, etc.

El formato de los comentarios en C, es el siguiente:

c) La Directiva #include: Permite que, el pre-procesador, incluya funciones

proporcionadas por el fabricante, a nuestro programa. Ejemplo:

#include <stdio.h> /* le decimos al compilador que incluya la librería

stdio.h */
d) La directiva #define: Permite definir constantes simbólicas. Las variables pueden
cambiar de valor, durante la ejecución del programa, por eso es que se llaman
variables. Y las constantes como su nombre lo indica, son valores que permanecen
constantes durante toda la ejecución del programa, un ejemplo de ello, es el valor de
 (pi) que equivale a 3.14159....

En C existen diferentes tipos de variables, entre ellas tenemos:

1. Constates Numéricas:
Son valores numéricos, enteros o de reales (de punto flotante). Se permiten también
constantes octales y hexadecimales.

2. Constantes Simbólicas:
Las constantes simbólicas tiene un nombre (identificador), y en esto se parecen las
variables. Sin embargo, no pueden cambiar de valor a lo largo de la ejecución del
programa. En C, se pueden definir mediante el preprocesador.

Ejemplo:

Esta directiva (#define) va, inmediatamente después de los #include. Se escribe la

directiva, se deja un espacio y se escribe el identificador de la constante, otro espacio y
su valor.

e) Signos de Puntuación y de Separación

/  % ^ & * () - + {} [] \ ; : <> ¿ .

f) Todas las Instrucciones o sentencias del programa terminan con un punto y

coma (;)
Al momento de programar en C, esta es una regla de oro, y la causa por la cual nuestro
programa puede darnos muchos errores de sintaxis, cuando se omite, al final de cada
sentencia un punto y coma (;). Ya que con ello le indicamos al compilador que ha
finalizado una sentencia. Las directivas: #include, #define. Main(), no llevan punto y
coma, porque no son sentencias.

Recordemos el ejemplo 1.1, y vea que al final de cada sentencia lleva su correspondiente
punto y coma:
g) Todo Bloque de Instrucciones debe ir entre llaves.
Esta consideración toma mayor auge, cuando veamos las instrucciones anidadas en
condiciones, ciclos, etc.

Ejemplo:

h) En una línea se pueden escribir más de una instrucción separada por un punto y
coma.
Esto es posible, porque con el punto y coma, le estamos indicando al compilador el fin de
una sentencia o instrucción.

Ejemplo:

Declaración de Variables.
Una Variable, como su nombre lo indica, es capaz de almacenar diferentes valores
durante la ejecución del programa, su valor varía. Es un lugar en la memoria el cual,
posee un nombre (identificador), y un valor asociado.

La declaración de variables en C, se hace en minúsculas.

Formato:
Tipo_de_dato nombre_de_la_variable;

Ejemplos:
*Declare una variable de tipo entero y otra de tipo real, una con el nombre de “x” y otra
con el identificador “y”:
int x;
float y;
*Declare una variable de tipo entero llamada moon, e inicialícela con un valor de 20
int moon=20;

*Declare una variable de tipo real, llamada Pi, e inicialícela con una valor de 3.1415
float pi=3.1415;

*Declare una variable de tipo carácter y asígnele el valor de “M”

char car = ’M’;

*Declare una variable llamada nombre, que contenga su nombre:

char nombre[7]=”Manuel”;

Explicación:
En C, no tiene el tipo de dato llamado string, o mejor conocido como cadenas de texto,
pero nosotros podemos hacer uso de ellas, por medio de un arreglo, (de lo cual
hablaremos con más detalle, posteriormente); pero para declarar este tipo de datos
colocamos el tipo de datos, es decir la palabra reservada char luego el nombre, e
inmediatamente abrimos, entre corchetes, va el número de letras, que contendrá dicha
variable. Es muy importante que al momento de declarar el tamaño, sea un número
mayor, al verdadero número de letras; por ejemplo, la palabra “Manuel”, solo tiene 6
letras, pero debemos declararlo para 7 letras ¿Por qué?.

Veámoslo gráficamente, en la memoria, C crea un variable llamada nombre y esta posee

la palabra Manuel, así:

en realidad, hay 7 espacios, pero la cuenta llega hasta 6, porque c, toma la primera
posición como la posición cero, y para indicar el final de la cadena lo hace con un espacio
en blanco.

Declaración de Constantes.

Las constantes, como su nombre lo indica, son valores que se mantiene invariables
durante la ejecución del programa.

Su formato es el siguiente:

const tipo_de_dato nombre= valor;

donde const, es una palabra reservada, para indicarle al compilador que se está
declarando una constante.
Ejemplo:
const int dia=7;
const float pi=3.14159;
const char caracter= ‘m’;
const char fecha[]=”25 de diciembre”;
Caso Especial Constantes Simbólicas.
Las constantes simbólicas, se declaran mediante la directiva #define. Funcionan de la
siguiente manera, cuando C, encuentra el símbolo que representa a la constante, lo
sustituye por su respectivo valor.

Ejemplo:
#define N 150
#define PI 3.1416
#define P 50

Entrada y Salida Por Consola.

Entrada y Salida por consola: se refiere a las operaciones que se producen en el teclado
y en la pantalla de la computadora. En C no hay palabras claves para realizar las
acciones de Entrada/Salida, estas se hacen mediante el uso de las funciones de la
biblioteca estándar (stadio.h).

Para utilizar las funciones de E / S debemos incluir en el programa el archivo de cabecera

stdio.h, mediante la declaratoria:

#include <stdio.h>

Las Funciones de E / S más simples son getchar() que lee un carácter del teclado, espera
un retorno de carro (), es decir un enter y el eco aparece. Es decir la tecla presionada.

*putchar(): Imprime un carácter en la pantalla, en la posición actual del cursor.

Algunas variaciones:
*getche(): Aparece el Eco
*getch(): No aparece el eco

Entrada / Salida de Cadenas.

Una Cadena, es una frase, compuesta por varias palabras. En C, podemos hacer uso de
las cadenas, mediante, la sentencia:
*gets(): Lee una cadena de carácter introducido por el teclado. Se puede introducir
caracteres hasta que se dé un retorno de carro, (enter); el cual no es parte de la cadena;
en su lugar se coloca un terminador nulo \0.
*puts(): Imprime en pantalla, el argumento guardado en la variable que se manda a
impresión.

Ejemplo 2.3

Diseñe un programa en C, que lea su nombre; lo salude y mande a impresión su nombre,

usando gets e y puts.
#include <stdio.h>
#include <conio.h>
main()
{
char nombre[40];
puts("digite su nombre:");
gets(nombre);
puts("BIENVENIDO:");
puts(nombre);
getch();
return 0;
}

No se hace mucho énfasis en estas instrucciones, ya que más adelante, veremos las
instrucciones scanf() y printf(), que son mucho más completas.

Entrada / Salida Por Consola con Formato.

Las funciones gets, puts, getch, etc; son utilizadas, en una forma un poco rudimentaria,
sin embargo; C posee otra serie de funciones, que son más completas, las cuales nos
permiten leer e imprimir (en pantalla), datos con un formato determinado, el cual ha sido
definido por el programador.

Salida Hacia Pantalla [printf()]

Se utiliza para imprimir en pantalla cadenas de texto solas, o mandar a pantalla el valor
de alguna variable, o constante, o una combinación de las anteriores. Cadena de control:
contiene códigos de formato que se asocian con los tipos de datos contenidos en las
variables.

Código Formato
%d Un entero
%i Un entero
%c Una caracter
%s Una cadena
%f Un real
%ld Entero largo
%u Decimal sin signo
%lf Doble posición
%h Entero corto
%o Octal
%x Hexadecimal
%e Notación Científica
%p Puntero
%% Imprime Porcentaje

Printf(“cadena de control”, nombre_de_variables); El número de argumentos que tendrá

la función printf() es indefinido, por lo que se puede transmitir cuantos datos sean
necesarios.
Ejemplo:
#include <stdio.h> /* Necesario para la función printf() */

int main(void) /* Función principal del programa */

{
char resultado;

resultado=5+2;
printf("Resultado de la suma: %i\n",resultado);
resultado=5-2;
printf("Resultado de la resta:%i\n",resultado);
resultado=5*2;
printf("Resultado de la multiplicación: %i\n",resultado);
resultado=5/2;
printf("Resultado de la división:%i\n",resultado);

return(0);

}
$ ./ejemploc
Resultado de la suma: 7
Resultado de la resta: 3
Resultado de la multiplicación: 10
Resultado de la división: 2
$

#include <stdio.h>

void acceso(unsigned char edad)

{
if (edad < 18)
printf("No puedes acceder.\n");
else
printf("Bienvenido.\n");
return;
}

int main(void)
{
acceso(18);
acceso(17);
return(0);
}

$ ./acceso
Bienvenido.
No puedes acceder.
$
Secuencias de Escapes
Indica que debe ejecutar algo extraordinario.

Carácter de Explicación
Escape
\n Simula un Enter. Se utiliza para dejar una línea de por medio
\t Tabulador horizontal. Mueve el cursor al próximo tabulador
\v Tabulador vertical.
\a Hace sonar la alarma del sistema
\\ Imprime un carácter de diagonal invertida
\? Imprime el carácter del signo de interrogación
\” Imprime una doble comilla

Ejemplo:
1) printf("Manuel\nAntonio\nOrtiz");

Entrada Desde Teclado.

Se realiza mediante la función scanf(), su formato es:

scanf(“Cadena de control”, Dirección y nombre de la variable);

Ejemplo.
Diseñe un programa que guarde y muestre la nota del examen final de 3 alumnos
#include <stdio.h>
#include <conio.h>
main()
{
float n1, n2, n3;
char nom1[10], nom2[10], nom3[10];
printf("Introduzca el Nombre del Primer alumno:\n");
scanf("%s", nom1);
printf("Introduzca la nota de este alumno:\n");
scanf("%f", &n1);
printf("Digite el nombre del segundo alumno:\n");
scanf("%s", nom2);
printf("Su nota es:\n");
scanf("%f", &n2);
printf("Finalmente el ultimo alumno es:\n");
scanf("%s", nom3);
printf("Y su nota es:\n");
scanf("%f", &n3);
getch();
return 0;
}
Explicación:
Primero, iniciamos con las directivas del preprocesador:
#include <stdio.h>
#include <conio.h>
Con la cual le indicamos al compilador, que de su librería añada a nuestro programa las
funciones estándar de entrada y salida; así como las entradas y salidas por consola
(stadio.h y conio.h, respectivamente).
Luego declaramos la variables, que contendrán las notas como reales (o de punto
flotante:
float n1, n2, n3;

Ya que, las notas pueden ser decimales, por ejemplo 9.6, 8.5; etc.
Luego declaramos las variables, que contendrán las notas, cabe aclarar que al momento
de las declaraciones las podemos hacer en el orden que deseemos, pueden ser primeros
los tipo char y luego los float, o viceversa, pero teniendo el cuidado que las variables que
contendrán las nombres lleven la longitud máxima entre corchetes, para nuestro caso, 10.
( [10] ).

Posteriormente, mostramos en pantalla, un mensaje con el cual le indicamos al usuario

que introduzca los datos respectivos:
printf("Introduzca el Nombre del Primer alumno:\n");
A continuación, va la función scanf, primero y entre comillas el tipo de dato que va a leer:
scanf("%s", nom1);
como puede notarse, va a leer la cadena de texto que contendrá la variable nom1. cabe
aclarar, que cuando se van a leer cadenas de texto, no es necesario colocar la dirección
(&), lo cual no sucede con los otros tipos de datos:
scanf("%f", &n1);
Después de haber leído los datos, espera a que se presiones cualquier tecla para finalizar
la ejecución del programa.

Ejemplo.
Programa que imprime dos veces, la cadena de texto que se ha introducido:
#include <stdio.h>
#include <conio.h>
main()
{
char cadena[15];
printf("Digite la cadena:\n\n");
scanf("%s", cadena);
printf("\n\t LA CADENA ES LA SIGUIENTE:\n\n");
printf("***********************************************\n");
printf("%s\n", cadena);
printf("%s\n", cadena);
printf("%s\n", cadena);
printf("***********************************************\n");
getch();
return 0;
}
Es importante, que intente correr, en su máquina estos ejemplos, para que comprenda
con mayor facilidad.

Cuestionario.

1. Mencione y Explique que es la lógica estructurada:

2. Para que sirven las funciones getch() y putchar():
3. Menciones las diferencias fundamentales entre las funciones de entrada y
salida por consola, con las funciones de entrada y salida por consola con
formato:
4. Escriba algunas restricciones que deben cumplir los Identificadores:
5. ¿Cuál es la diferencia entre el tipo de dato %c, y el tipo de dato %s?:
6. Para que sirve la directiva <stdio.h>:
7. ¿Y la directiva <conio.h>?
8. ¿Para qué sirve a declaratoria #define?:
9. Para que sirve el punto y coma (;) en C:
10. En C, no existe el tipo de dato string; sin embargo, podemos hacer uso de las
cadenas de texto, ¿Por qué?. Explique: