Estructura de un programa en C

1.- Inclusión de bibliotecas, declaraciones de variables y tipos, y secuencia de funciones

2.- Una y sólo una función denominada main() (programa principal)
3.- Funciones del tipo <Retorno> Nombre (parámetros) {sentencias}.
4.- Las funciones están declaradas en las librerías <(Nombre).h>, si la librería no se agrega C no
reconocerá a la función y dará un error. Si la función la construimos nosotros se agrega a continuación
de la función main().

/* Los comentarios se realizan entre los símbolos barra/asteristo y asterisco/barra */

/* Los comentarios son ignorados por el compilador C, pero forman parte del código */
/* del programa como ayuda para explicar su funcionamiento */

/* ejemplo 1.- Escribe un mensaje en pantalla */

#include <stdio.h> /* Siempre se incluye la librería <stdio.h>*/

/* Aqui podría incluirse otras librerías o declarar variables de uso global*/

int main( ) {
/*Aquí se declaran las variables que se usan en el programa, asignándoles
un valor se así se requiere y luego se desarrolla el programa */

printf("\n Introducción a la programación en lenguaje C");

return 0; /* Siempre se deberá incluir el retorno 0 de la función main()*/

}
 Estructura del entorno IDE Zinjai para C
Al cargar el programa Zinjai se selecciona
“Crear un programa simple”

Se elije “Programa C en Blanco”

se tilda esta opción por defecto y
se hace click en “Crear”

Automáticamente Zinjai agrega la librería

<stdio.h> y crea la función mail().
Asi se comienza a escribir el programa C
 Estructura del entorno IDE Zinjai para C
Se puede crear, abrir o guardar el
código de un programa Tiene los comandos de edición
básicos de un editor de texto

Ejecuta o
Compila el
programa
Estructuras de Control en C
Asignación
Estructuras de Control en C
Entrada de Datos

scanf("cadena_de_control", &variables);

Usar el simbolo & ya que indica que el dato de

entrada se guarda como “el contenido” de la
variable. La excepción son los strings.
 Entrada formateada: Función scanf()
Es una función de entrada de propósito general con formato, que permite leer
datos de distintos tipos. El formato general es:

int scanf("cadena_de_control", lista_de_punteros_a_variables);

La función lee de la entrada estándar elementos que son convertidos, según las
especificaciones de conversión contenidas en la cadena_de_control, y asignados
a las variables cuyas direcciones se pasan en la lista.

La cadena_de_control es un mapa de la entrada que se espera, y puede contener:

• Espacios en blanco: Uno o más espacios en blanco en la cadena_de_control
encajan con uno o más espacios en blanco de la entrada.
• Otros caracteres no blancos, no contenidos tampoco en las especificaciones
de conversión (por ejemplo, el de cambio de línea (\n), deben encajar
exactamente con la entrada, o de lo contrario la operación fallará.
• Las especificaciones de conversión, que constan obligatoriamente del
símbolo “%”, por el que comienzan, y de la operación de conversión, pero
pueden incluir adicionalmente otros campos opcionales.
 Entrada formateada: Función scanf()
Las especificaciones de conversión tienen otros campos opcionales. El orden y
función es el siguiente:

◦ Símbolo “%” (obligatorio).

◦ Símbolo de supresión, “*” (opcional).
◦ Campo de longitud (opcional): En el caso de ir precedido por “*”,
indica cuántos caracteres de la entrada se deben saltar. En caso contrario
indica cuántos se deben leer como máximo. De no existir, se leerán todos
hasta el próximo blanco o hasta el último carácter válido (por ejemplo, si
se trata de una operación d no se leerá un carácter ’a’).
◦ Modificador de tamaño (opcional): Indica el tamaño del tipo
involucrado en la operación de conversión. Puede ser h (short) o l (long)
para conversión decimal, y l (double) o L (long double) para conversión
en coma flotante. De no existir, se usan por defecto int y float.
◦ Operación de conversión (obligatorio) Según Tabla
 Estructura de un programa

Elementos del programa

●
Inclusión de bibliotecas, declaraciones de variables y tipos, y secuencia de funciones
●
Una y sólo una función denominada main (programa principal)
●
Función.- tipo Retorno Nombre (parámetros) {sentencias}

/* ejemplo 1.- Escribe un mensaje en pantalla */

#include <stdio.h> /* incluye biblioteca donde se define E/S */

int main( ) {

/*Este comentario es ignorado por el compilador y */

/* no genera código */

printf("\n Introducción a la programación en lenguaje C");

return 0;
}
 Entrada formateada: Función scanf()
La Operación de conversión
 Entrada formateada: Función scanf()
Ejemplo de uso de la Operación de conversión
 La función scanf
/* Ejemplo 9.- Introducción de datos por teclado */

#include <stdio.h>

int main () {
int i;
float x;

printf("\n\n teclee el número entero i /n");

scanf("%d", &i);

printf("\n teclee el número real x /n");

scanf("%f", &x);

printf(“\n\n Se ingreso i= %d x= %f”, i,x);

return 0;
}
Estructuras de Control en C
Salida de Datos

printf("cadena_de_control", argumentos);

La cadena_de_control puede contener,

ademas de los caracteres de control, texto.
 Salida formateada: Función printf()
Es una función de salida de propósito general, que permite escribir datos de
distintos tipos con formato. El formato general es:

int printf("cadena_de_control", lista_de_argumentos);

cadena_de_control es una lista de caracteres que puede contener:

●
Una especificación de conversión, a la que precede el símbolo “%”, y que
indica adicionalmente el formato de visualización de un argumento.
●
Caracteres normales que no forman parte de una especificación de
conversión, y que se copian tal cuál a la salida. Para provocar un cambio de
línea se usa el carácter “\n”.

En cadena_de_control existirán tantas especificaciones como argumentos,

correspondiendo cada una a un argumento, por lo que deberán colocarse en el
mismo orden. Los argumentos pueden ser variables, constantes o cualquier
expresión. La función devuelve el número de caracteres escritos, y EOF en
caso de error.
 Las especificaciones de conversión usan el símbolo “%” y la
operación de conversión, según la siguiente tabla:

printf("%s %c %d","es una cadena", ’C’, 100); /* Sale → es una cadena C 100*/
printf("esto es una cadena %d", 100); /* Sale->esto es una cadena 100*/
printf("el %d es decimal, %f es real", 10, 5.23); /* Sale->el 10 es decimal, 5.23 es
real*/
Existe una serie de caracteres no imprimibles que el editor los toma como comandos, por lo que
la manera de acceder a ellos es mediante una secuencia de escape
 La función printf
/* ejemplo 8.- Ilustra formatos con reales y enteros */

#include <stdio.h>
#define va_int 805
#define va_float 332.41e-1

int main () {
printf(" %f ", va_float);

printf(" %.1f ", va_float);

printf(" %.4f ", va_float);

printf(" %1.4e ", va_float);

printf(" %d ", va_int);

printf(" %10f", va_float);

return 0;
}
 Estructuras de Control en C
Secuencia de instrucciones

Los bloques de sentencias, pueden

{ encerrarse entre llaves { }

{
scanf(“%d”,&B);
a=2;
T=”texto”;
c=a*B;
printf(“%d”,c);
}

}
 Control de flujo en C
En adelante, cuando nos refiramos a sentencias, debe entenderse
que estas pueden ser:
●
simples (terminadas en “;” )
●
compuestas (un bloque de sentencias simples encerradas entre
llaves { }).
Estructuras de Control en C
Decisión

if (expresión)
sentencia_1;
else
sentencia_2;

Si la expresión es verdadera (SI ) se

ejecuta la sentencia_1, si es falsa (NO )
se ejecuta la sentencia_2.
 Sentencia condicional: if
Estructura general:

if (expresión)
sentencia_1;
else /* Opcional */
sentencia_2;

Si la expresión es distinta de cero (TRUE), se ejecuta la

sentencia_1. En cambio, si es cero (FALSE), no se ejecutará, a
menos que exista un bloque else, en cuyo caso se ejecutará¡ la la
sentencia_2.

Para evitar ambigüedades en el caso de sentencias if-else

anidadas, el compilador asociará el else con el if más próximo
sin resolver
En C existe un operador especial, denominado operador
condicional, que se halla estrechamente ligado a la
sentencia if-else. Su formato es:

condición ? expresión_true : expresión_false

El valor devuelto por este operador depende de la

condición: si esta es cierta devolverá expresión_true, y si
es falsa expresión_false.

Por ejemplo:

maximo = a > b ? a : b
Estructuras de Control en C
Decisión

if (a>b)
printf(“%d”,a);
else
printf(“%d”,b);

if (a==b)
printf(“Son iguales”);

if (Resp==bien)
{ Nota++;
printf(“%d”,Nota);
}
else
{ Nota++;
printf(“%d”,Nota);
}
Estructuras de Control en C
Repetición (Para)
Desde

for (i=1 ; i<=10 ; i=i+1)

Printf(“%d”,i);

En pasos de

Hasta
Estructuras de Control en C
Repetición (Para)

for (i=1; i<=10 ; i++)

{
a=a+1;
printf(“%d”,i);
printf(“%d”,a);
}
Estructuras de Control en C
Repetición (Para)

for (i=1; i<=10 ; i++)

{
if (i%2==0)
{
p=p+1;
printf(“%d”,p);
}
printf(“%d”,i);
}
Estructuras de Control en C
Repetición (Mientras)

while (condición)
{
sentencia;
{

while (a!=0)
scanf(“5d”,&a);
 Bucle while
Estructura general:

while (condición_de_continuación)
sentencia;

La condición_de_continuación se evalúa antes de entrar

al bucle en cada iteración, incluso antes de la primera
vez, continuando el bucle, o sea ejecutándose la
sentencia, mientras la condición sea verdadera.
 Ejemplo 14: Instrucción while
/* ejemplo 14.- Lee una palabra y lo escribe al reves */

#include <stdio.h>
int main () {
char c, palabra[21];
int i;
printf("Teclee una palabra de menos de 20 letras:");
scanf("%s", palabra);
i = 0;
while(palabra[i++] != '\0');
printf("%s tiene %d letras.", palabra, i);
printf("%s escrita al revés es: ", palabra);
while (i > 0)
printf("%c", palabra[--i]);
return 0;
}
 Estructuras de Control en C
Repetición (Hacer .. Mientras)

do
{
scanf(“%d”,&a);
}while (a!=0);
 Sentencia do-while

Estructura general:

do
sentencia;
while (condición_de_continuación);

Es muy similar al bucle while salvo que, al

comprobarse la condición_de_continuación al final,
siempre tendrá una iteración, siendo el único bucle en
C con esta característica.
 Ejemplo 15: Do-While
/* ejemplo 15.- Suma de n números introducidos por teclado
(valor <0 para terminar) */

#include <stdio.h>
int main() {
int num=0,suma=0;
do {
suma=suma+num;
printf("un número: ");
scanf("%d",&num);
} while(num>=0);
printf("suma es: %d",suma);
return 0;
}
Estructuras de Control en C
Selección Múltiple

1: 2: 3: 4: Sino:

switch (a)
{
case 1: printf(“Uno”);
case 2: printf(“Dos”);
case 3: printf(“Tres”);
case 4: printf(“Cuatro”);
default: printf(“El número no esta entre Uno yCuatro”);
}
 Sentencia switch
Es una solución más elegante para múltiples sentencias if anidadas.
switch (expresión)
{
case cte_1: sentencia_11; sentencia_12;
...
case cte_2: sentencia_21; sentencia_22;
...
...
...
case cte_n: sentencia_n1; sentencia_n2;
...
default: sentencia_default1; sentencia_default2;
...
}
Si coincide el valor de expresión (que debe ser de un tipo entero) con las
constantes de tipo entero que siguen a case, denominadas etiquetas, y que no
pueden hallarse duplicadas, se ejecuta el bloque de sentencias correspondiente,
y se continua con todas las sentencias hasta el final del switch.
Si se desea finalizar la ejecución del switch, debe añadirse al final del bloque
de sentencias la sentencia break,
Ejemplos:
int n=2;
switch(n) {
case 1: printf("Uno\n");
case 2 : printf("Dos\n");
case 3 : printf("Tres\n");
default : printf("default\n");
}
Introduciendo el break
int n=2;
switch(n) {
case 1 : printf("Uno\n");
break;
case 2 : printf("Dos\n");
break;
case 3 : printf("Tres\n");
break;
default : printf("Default\n");
}
 Ejemplo 11: La instrucción switch
#include <stdio.h>
int main() {
int nota;
printf(" Inserte una nota: "); scanf("%d",&nota);
switch(nota) {
Case 0: printf(”\nSuspenso"); break;
Case 1: printf("\nSuspenso"); break;
Case 2: printf("\nSuspenso"); break;
Case 3: printf("\nSuspenso"); break;
Case 4: printf("\nSuspenso"); break;
Case 5: printf("\nAprobado"); break;
Case 6: printf(”\nBien"); break;
Case 7: printf(”\nNotable"); break;
Case 8: printf("\nNotable"); break;
Case 9: printf("\nSobresaliente"); break;
Case 10: printf(”\nSobresaliente"); break;
default: printf(”esa nota es incorrecta");
}
return 0;
}
 Ejemplo 12: La instrucción switch

#include <stdio.h>
int main() {
int nota;
printf(" Inserte una nota: "); scanf("%d",&nota);
switch(nota) {
case 0: case 1: case 2: case 3: case 4:break;
case 5: printf("\nAprobado"); break;
case 6: printf(”\nBien"); break;
case 7: printf(”\nBien"); break;
case 8: printf("\nNotable"); break;
case 9: printf("\nNotable"); break;
case 10: printf(”\nSobresaliente"); break;
default: printf(”esa nota es incorrecta");
}
return 0;
}
 Ejemplo 13: La instrucción switch
/* ejemplo 12.- Conversión entre euros y pesos */

#include <stdio.h>
#define euro 14.6386
int main() {
float n,x; int opcion;
printf("la cantidad: ");
scanf("%f",&n);
printf(”1-Pesos a Euros 2-Euros a pesos"); scanf("%d",&opcion);
switch(opcion) {
case 1: x=n/euro;
printf("%f Pesos son %f Euros",n,x); break;
case 2: x=n*euro;
printf("%f Euros son %f Pesos",n,x); break;
default: printf("incorrecta");
}
return 0;
}
 Estructuras de Control en C
Otras Formas de Entrada de Datos

Los dispositivos estándar en C son, por defecto, el teclado y la

pantalla. No obstante, estos son tratados como si fuesen ficheros
con los nombres stdin y stdout, respectivamente.

int getchar(void)

Devuelve un carácter de la entrada estándar. Si hay algún error, o

se alcanza el final del fichero, devuelve EOF

int putchar(int ch)

Imprime el carácter ch por la salida estándar. Si hay error devuelve

EOF, sino devuelve el carácter.
 Estructuras de Control en C
Otras Formas de Entrada de Datos
Las funciones anteriores pueden operan con cadenas de caracteres, dando
lugar a las funciones gets() y puts().
char *gets(char *string)
Lee la cadena de caracteres string desde la entrada estándar, devolviendo
un puntero a la cadena. La orden de final de lectura es el retorno de carro,
pero la cadena devuelta tendrá el carácter nulo (“\0”) al final, sin incluir el
(“\n”)
int puts(const char *string)
Imprime la cadena de caracteres string por la salida estándar, devolviendo
el último carácter escrito, y EOF si hubiese error.
Ejemplo:
int puts(char *s) {
int i;
for(i=0;s[i];++i)
putchar(s[i]);
}