Manual C - Laboratorio de Programacion 1, Universidad Centroamericana

1. Manual
Lenguaje
C/C++
Laboratorio de Programación 1
Elaborado Por:Leonardo Aquino

2. 1
CONTENIDO
Introducción.......................................................................................................................................................................2
Identificadoresy Tiposde Datos...........................................................................................................................................3
Operadoresen C.................................................................................................................................................................4
Size Of................................................................................................................................................................................6
Casting...............................................................................................................................................................................6
Arreglos(Arrays).................................................................................................................................................................7
ArreglosUnidimensionales.............................................................................................................................................7
ArreglosBidimensionales................................................................................................................................................7
Estructuras .........................................................................................................................................................................8
Estructuras anidadas.......................................................................................................................................................8
Uso de PrintF()y Scanf().......................................................................................................................................................9
printf.............................................................................................................................................................................9
scanf...........................................................................................................................................................................10
Manejo de archivos...........................................................................................................................................................12
Ficheros.......................................................................................................................................................................12
fopen..........................................................................................................................................................................12
fclose.......................................................................................................................................................................13
feof.........................................................................................................................................................................14
rewind.....................................................................................................................................................................14
Lectura........................................................................................................................................................................15
fgetc........................................................................................................................................................................15
fgets........................................................................................................................................................................16
fread.......................................................................................................................................................................18
fscanf......................................................................................................................................................................18
Escritura......................................................................................................................................................................19
fputc.......................................................................................................................................................................19
fputs........................................................................................................................................................................20
fwrite......................................................................................................................................................................21
fprintf......................................................................................................................................................................22
Funciones .........................................................................................................................................................................24
La sentencia return...................................................................................................................................................24
Argumentos .................................................................................................................................................................24
Variables Locales y Globales...........................................................................................................................................25
Instruccionesde control.....................................................................................................................................................25
La estructura condicional IF... else.........................................................................................................................25
Operadores de comparación......................................................................................................................................26
Operadores lógicos...................................................................................................................................................26
La estructura condicionalabierta y cerrada SWITCH... case.......................................................................................26
El bucledo...while..................................................................................................................................................27
El buclewhile............................................................................................................................................................27
El buclefor.................................................................................................................................................................28

3. 2
INTRODUCCIÓN
El lenguaje C es el resultado de un proceso de desarrollo que inició con un
lenguajedenominado BCPL. Este influenció a otro llamado B(inventado por
Ken Thompson). En los años 70; éste lenguajellevó a la aparición del C.
C es un lenguaje de programación de nivel medio ya que combina los
elementos del lenguaje de alto nivel con la funcionalidad del ensamblador.
Su característica principal es ser portable, es decir, es posible adaptar los
programas escritos para un tipo de computadora en otra.
Otra de sus características principales es el ser estructurado, es decir, el
programa sedivide en módulos (funciones) independientes entre sí.
El lenguaje C inicialmente fue creado para la programación de:
-Sistemas operativos
-Intérpretes
-Editores
-Ensambladores
-Compiladores
-Administradores debases de datos.
Actualmente, debido a sus características, puede ser utilizado para todo
tipo de programas.

4. 3
IDENTIFICADORES Y TIPOS DE DATOS
Los identificadores se reconocen como palabras que definen un tipo de
dato de un lenguaje, estos son tomados como palabras reservadas y cada
uno tiene un significado o función.
Los identificadores más comunes en un algoritmo son:
char: Palabra reservada que se usa para clasificar un dato como carácter o
cadena. Un ejemplo de su uso: char[6]=“Aquino”; (Aquí este está
declarando que “Aquino” es de tipo Carácter.)
int: Palabra reservada que se usa para clasificar un dato como numero
entero. Un ejemplo de su uso: int x = 98; Aquí está declarando que “x” es
de tipo entero y seinicializa con el valor de 98.
float: Palabra reservada que se usa para clasificar un tipo de dato como
número real o decimal. Ejemplo: float y = 12.34. Aquí se está declarando
que y es de tipo real o decimal y se inicializa con el valor de 98.
double: Se usa como la palabra reservada float, pero con doble precisión
(Para números elevados y con exponentes precisos).

5. 4
OPERADORES EN C
*Los operadores son distintos en casi todos los lenguajes, las tablas de valores antes
vistos son de operadores solamente de C, en C++ cambian algunos.*

6. 5

7. 6
SIZE OF
Esta función u operador se usa para mostrar el tamaño de una cadena, por
lo generalcuando cuenta la cadena empieza desde“0” hasta el tamaño que
tenga.
Ejemplo:
Con el comando Size of medimos cuanto espacio en memoria ocuparía la
variable, y como se observa nos dio resultado 4 bytes siendo un entero.
CASTING
El casting se utiliza para castear o cambiar valores, pasar deun tipo de
dato a otro.
Aquí una tabla de casting entre tipo de datos:

8. 7
ARREGLOS (ARRAYS)
Los arrays, arreglos o vectores forman parte de la amplia variedad de
estructuras de datos que nos ofrece C++, siendo además una de las
principales y más útiles estructuras quepodremos tener como herramienta
de programación. Los arrays, arregloso vectores (como los quieras llamar),
son utilizados para almacenar múltiples valores en una única variable.
ARREGLOS UNIDIMENSIONALES
Un arreglo unidimensional es un conjunto de n elementos del mismo tipo
almacenadosen memoria continua en un vector o lista. Paraacceder a cada
elemento del arreglo se requiere de un solo índice o subíndice, el cual
representa la posición en la que se encuentra.
Aquí se declaró un arreglo unidimensional de10 caracteres.
ARREGLOS BIDIMENSIONALES
Un arreglo bidimensional es un conjunto de n elementos del mismo tipo
almacenados en memoria contigua en una matriz o tabla. A diferencia de
los arreglos unidimensionales que solo requieren de un subíndice, los
arreglos bidimensionales para acceder a cada elemento del arreglo
requieren dedosíndices o subíndicesdeclaradosen dosparesdecorchetes,
donde el primer corchete se refiere al tamaño de filas y el segundo al
tamaño de columnas.
Aquí se declaró un arreglo bidimensional de10 filas y 4 columnas.

9. 8
ESTRUCTURAS
En la creación de soluciones para algunos problemas surgela necesidad de
agrupar datos de diferente tipo o de manejar datos que serían muy difícil
de describir en los tipos de datos primitivos, esta es la situación en la que
debemos aprovecharnos de las características que hacen al lenguaje C
especial, o sea el uso de estructuras.
Una estructura contiene varios datos. La forma de definir una estructura es
haciendo uso de la palabra clave struct. Aquíun ejemplo deuna estructura:
ESTRUCTURAS ANIDADAS
Una estructura puede estar dentro de otra
estructura a esto se le conoce como
anidamiento o estructuras anidadas. Ya que
se trabajan con datos en estructuras si
definimos un tipo de dato en una estructura
y necesitamos definir ese dato dentro de otra
estructura solamente se llama el dato de la
estructura anterior.
Ejemplo:

10. 9
USO DE PRINTF() Y SCANF()
PRINTF
La función PRINTF() se usa para la salida; en forma similar, la función
SCANF() se usa para la entrada. En sentido técnico, estas funciones no son
parte del lenguajeC, sino del sistema C; residen en una biblioteca estándar
y están disponibles para usarlas donde quiera que haya un sistema C.
Ambas funciones tienen una lista de parámetros con dos partes:
string_de_control y lista_de_argumentos
La primera es un String y puede contener especificaciones de conversión o
formatos. Una especificación de conversión se inicia con un carácter % y
termina con un carácter de conversión; por ejemplo, en el formato %d la
letra d es el carácter de conversión y permite imprimir el valor de una
expresión como un entero decimal. Para imprimir las letras ABC en la
pantalla, podría usarsela proposición:
printf("ABC");
Otra manera de hacer esto es mediante la proposición:
printf("%s", "ABC");
El formato %s hace que el argumento "ABC" se imprima en el formato de
un string de caracteres. Esto mismo puede realizarse también con la
proposición:
printf("%c%c%c", 'A', 'B', 'C');
Los apóstrofos que encierran cada letra se emplean para designar
constantes de caracteres; de acuerdo con esto, `A` es la constante de
carácter que correspondea la letra A mayúscula. El formato %c imprime el
valor de una expresión como un carácter.

11. 10
Por ejemplo:
char c1, c2,c3;
c1 = 'A';
c2 = 'B';
c3 = 'C';
printf("%c%c%c", c1,
c2, c3);
Imprimirá de nuevo las letras ABC en la pantalla.
Ahora veamos los caracteres de conversión:
c: carácter
d: decimal
e: número de punto flotante en notación científica
f : número de punto flotante
g : en el formato-e o el formato-f, el que sea más corto
s : string
SCANF
La función scanf() es análoga a la función printf(), pero se usa para la
entrada. Su primer argumento es un string de control con formatos que
corresponden a las diferentes formas en que pueden interpretarse los
caracteresen la entrada como valorespara losdiferentes tipos de variables.
La lista de argumentos está formada por DIRECCIONES de variables. El
símbolo & representaal operadordedirección; porejemplo, la proposición:
scanf("%d", &x);
Contiene el formato %d, el cual provoca que scanf() interprete los
caracteres de entrada como un entero decimal y que coloque el valor en la
dirección x. La función scanf() puede usarse para convertir cadenas de
dígitos decimales en valores enteros y almacenarlos en el lugar apropiado.

12. 11
Ahora veamos los caracteres de conversión:
c: carácter
d: decimal
f: número de punto flotante (float)
lf: número de punto flotante (double)
s: cadena de caracteres (string)
Veamos un ejemplo.
#include <stdio.h>
main() {
int x;
char c;
float y;
double z;
printf("nIngrese
un caracter : ");
scanf("%c", &c);
printf("nIngreseun int : ");
scanf("%d", &x);
printf("nIngreseun float: ");
scanf("%f", &y);
printf("nIngreseun double: ");
scanf("%lf", &z);
printf("nnLos datos queud. ingreso fueron :n");
printf("%c %d %e %enn", c, x, y, z);
}

13. 12
MANEJO DE ARCHIVOS
Así como hemos revisado la salida y entrada por pantalla y teclado
respectivamente, veremos ahora la entrada y/o salida de datos utilizando
ficheros, lo cual será imprescindible para un gran número de aplicaciones
que deseemos desarrollar.
FICHEROS
El estándar de C contiene varias funciones para la edición de ficheros, éstas
están definidas en la cabecera stdio.h y por lo generalempiezan con la letra
f, haciendo referencia a file. Adicionalmente se agrega un tipo FILE, el cual
se usará como apuntador a la información del fichero. La secuencia que
usaremos para realizar operaciones será la siguiente:
 Crear un apuntador del tipo FILE *
 Abrir el archivo utilizando la función fopen y asignándole el resultado de la
llamada a nuestro apuntador.
 Hacer las diversas operaciones (lectura, escritura, etc).
 Cerrar el archivo utilizando la función fclose.
FOPEN
Esta función sirvepara abrir y crear ficheros en disco.
El prototipo correspondientede fopen es:
FILE * fopen (const char *filename, const char *opentype);
Los parámetros de entrada de fopen son:
filename: una cadena quecontiene un nombrede fichero válido. opentype:
especifica el tipo de fichero que se abrirá o se creará.

14. 13
Una lista de parámetros opentypepara la función fopen es:
 "r”: abrir un archivo para lectura, el fichero debe existir.
 "w”: abrir un archivo para escritura, se crea si no existe o se sobrescribe si
existe.
 "a”: abrir un archivo para escritura al final del contenido, si no existe se crea.
 "r+”: abrir un archivo para lectura y escritura, el fichero debe existir.
 "w+”: crear un archivo para lectura y escritura, se crea si no existe o se
sobrescribe si existe.
 "r+b ó rb+”: Abre un archivo en modo binario para actualización (lectura y
escritura).
 "rb”: Abre un archivo en modo binario para lectura.
FCLOSE
Esta función sirvepara poder cerrar un fichero que seha abierto.
El prototipo correspondientede fclose es:
int fclose (FILE *stream);
Un valor de retorno cero indica que el fichero ha sido correctamente
cerrado, si ha habido algún error, el valor de retorno es la constanteEOF.
Un ejemplo pequeño para abrir y cerrar el archivo llamado fichero.in en
modo lectura:
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char** argv)
{
FILE *fp;
fp = fopen ( "fichero.in", "r" );
if (fp==NULL) {fputs ("File error",stderr); exit (1);}
fclose ( fp );
return 0;
}

15. 14
Como vemos,en el ejemplo seutilizó el opentype"r",quees para la lectura.
Otra cosa importante es que el lenguaje C no tiene dentro de si una
estructurapara elmanejo de excepciones o deerrores,poreso es necesario
comprobar que el archivo fue abierto con éxito "if (fp == NULL)". Si fopen
pudo abrir el archivo con éxito devuelve la referencia al archivo (FILE*), de
lo contrario devuelve NULL y en este caso se debera revisar la direccion del
archivo o los permisos del mismo. En estos ejemplos solo vamos a dar una
salida con un retorno de 1 que sirvepara señalar que el programa termino
por un error.
FEOF
Esta función sirvepara determinar si el cursor dentro del archivo encontró
el final (end of file). Existe otra forma de verificar el final del archivo que es
comparar el caracter quetrae fgetc del archivo con el macro EOF declarado
dentro de stdio.h, pero este método no ofrece la misma seguridad (en
especial al tratar con los archivos "binarios"). La función feof siempre
devolverácero (Falso) sino es encontrado EOF en el archivo,de lo contrario
regresará un valor distinto de cero (Verdadero).
El prototipo correspondientede feof es:
int feof(FILE*fichero);
REWIND
Literalmente significa "rebobinar", sitúa el cursor de lectura/escritura al
principio del archivo.
El prototipo correspondientede rewind es:
void rewind(FILE*fichero);

16. 15
LECTURA
Un archivo generalmente debe verse como un string (una cadena de
caracteres) que esta guardado en el disco duro. Para trabajar con los
archivos existen diferentes formas y diferentes funciones. Las funciones
que podríamos usar para leer un archivo son:
 char fgetc(FILE *archivo)
 char *fgets(char *buffer, int tamano, FILE *archivo)
 size_t fread(void *puntero, size_t tamano, size_t cantidad, FILE *archivo);
 int fscanf(FILE *fichero, const char *formato, argumento, ...);
Las primeras dos de estas funciones son muy parecidas entre sí. Pero la
tercera, por el número y el tipo de parámetros, nos podemos dar cuenta de
que es muy diferente, por eso la trataremos aparte junto al fwrite que es
su contraparte para escritura.
FGETC
Esta función lee un caracter a la vez del archivo que esta siendo señalado
con el puntero *archivo. En caso de que la lectura sea exitosa devuelve el
caracter leído y en caso de que no lo sea o de encontrar el final del archivo
devuelve EOF.
El prototipo correspondientede fgetc es:
char fgetc(FILE *archivo);
Esta función se usa generalmente para recorrer archivos de texto. A manera
de ejemplo vamos a suponer que tenemos un archivo de texto llamado
"prueba.txt" en el mismo directorio en que se encuentra la fuente de nuestro
programa.

17. 16
Un pequeño programa que lea ese archivo será:
#include <stdio.h>
#include <stdlib.h>
int main()
{
FILE *archivo;
char caracter;
archivo = fopen("prueba.txt","r");
if (archivo == NULL){
printf("nError de apertura del archivo. nn");
}else{
printf("nEl contenido del archivo de prueba es nn");
while (feof(archivo) == 0)
{
caracter = fgetc(archivo);
printf("%c",caracter);
}
}
fclose(archivo);
return 0;
}
FGETS
Esta función está diseñada para leer cadenas de caracteres. Leerá hasta n-
1 caracteres o hasta que lea un cambio de línea 'n' o un final de archivo
EOF. En este último caso, el carácter de cambio de línea 'n' también es
leído.
El prototipo correspondientede fgets es:
char *fgets(char *buffer, int tamaño, FILE *archivo);
El primer parámetro buffer lo hemos llamado así porque es un puntero a
un espacio de memoria del tipo char (podríamos usar un arreglo de char).

18. 17
El segundo parámetro es tamaño que es el límite en cantidad de caracteres
a leer para la función fgets.Ypor último el punterodel archivopor supuesto
que es la forma en que fgets sabrá a que archivo debe leer.
#include <stdio.h>
#include <stdlib.h>
int main()
{
FILE *archivo;
char caracteres[100];
archivo = fopen("prueba.txt","r");
if (archivo == NULL)
exit(1);
printf("nEl contenido del archivo de prueba es nn");
while (feof(archivo) == 0)
{
fgets(caracteres,100,archivo);
printf("%s",caracteres);
}
system("PAUSE");
fclose(archivo);
return 0;
}
Este es el mismo ejemplo de antes con la diferencia de que este hace uso
de fgets en lugar de fgetc. La función fgets se comporta de la siguiente
manera, leerá del archivo apuntado por archivo los caracteres que
encuentre y a ponerlos en buffer hasta que lea un caracter menos que la
cantidad de caracteres especificada en tamaño o hasta que encuentre el
final de una linea (n) o hasta que encuentre el final del archivo (EOF).
El beneficio de esta función es que se puede obtener una linea completa a
la vez. Y resulta muy útil para algunos fines como la construcción de un
parser de algún tipo de archivo de texto.

19. 18
FREAD
size_t fread ( void * ptr, size_t size, size_t count, FILE * stream );
Esta función lee un bloque de una "stream" de datos. Efectúa la lectura de
un arreglo de elementos "count", cada uno de los cuales tiene un tamaño
definido por "size". Luego los guarda en el bloquede memoria especificado
por "ptr". El indicador de posición de la cadena de caracteres avanza hasta
leer la totalidad de bytes. Si esto es exitoso la cantidad de bytes leídos es
(size*count).
PARAMETROS:
ptr : Puntero a un bloque de memoria con un tamaño mínimo de
(size*count) bytes.
size : Tamaño en bytes de cada elemento (de los que voy a leer).
count : Número de elementos, los cuales tienen un tamaño "size".
stream: Puntero a objetos FILE, queespecifica la cadena de entrada.
FSCANF
La función fscanf funciona igual que scanf en cuanto a parámetros, pero la
entrada se toma de un fichero en lugar del teclado.
El prototipo correspondientede fscanf es:
int fscanf(FILE *fichero, const char *formato, argumento, ...);

20. 19
Podemos ver un ejemplo de su uso, abrimos el documento "fichero.txt" en
modo lectura y leyendo dentro de él.
#include <stdio.h>
int main ( int argc, char **argv )
{
FILE *fp;
char buffer[100];
fp = fopen ( "fichero.txt", "r" );
fscanf(fp, "%s" ,buffer);
printf("%s",buffer);
fclose ( fp );
return 0;
}
ESCRITURA
Así como podemos leer datos desde un fichero, también se pueden crear y
escribir ficheros con la información que deseamos almacenar, Para trabajar
con los archivos existen diferentes formas y diferentes funciones. Las
funciones que podríamos usar para escribir dentro de un archivo son:
 int fputc(int caracter, FILE *archivo)
 int fputs(const char *buffer, FILE *archivo)
 size_t fwrite(void *puntero, size_t tamano, size_t cantidad, FILE *archivo);
 int fprintf(FILE *archivo, const char *formato, argumento, ...);
FPUTC
Esta función escribe un carácter a la vez del archivo que está siendo
señalado con el puntero *archivo. El valor de retorno es el carácter escrito,
si la operación fue completada con éxito, en caso contrario será EOF.
El prototipo correspondientede fputc es:
int fputc(int carácter, FILE *archivo);

21. 20
Mostramos un ejemplo del uso de fputc en un "fichero.txt", se escribirá
dentro del fichero hasta que presionemos la tecla enter.
#include <stdio.h>
int main ( int argc, char **argv )
{
FILE *fp;
char caracter;
fp = fopen ( "fichero.txt", "a+t" ); //parametro para escritura
al final y para file tipo texto
printf("nIntroduce un texto al fichero: ");
while((caracter = getchar()) != 'n')
{
printf("%c", fputc(caracter, fp));
}
fclose ( fp );
return 0;
}
FPUTS
La función fputs escribeuna cadena en un fichero. la ejecución de la misma
no añadeel carácter de retorno de línea ni el carácter nulo final. El valor de
retorno es un número no negativo o EOF en caso de error. Los parámetros
de entrada son la cadena a escribir y un puntero a la estructura FILE del
fichero dondese realizará la escritura.
El prototipo correspondientede fputs es:
int fputs(const char *buffer, FILE *archivo)

22. 21
Para ver su funcionamiento mostramos el siguiente ejemplo:
#include <stdio.h>
int main ( int argc, char **argv )
{
FILE *fp;
char cadena[] = "Mostrando el uso de fputs en un fichero.n";
fp = fopen ( "fichero.txt", "r+" );
fputs( cadena, fp );
fclose ( fp );
return 0;
}
FWRITE
Esta función está pensadapara trabajarcon registrosdelongitud constante
y forma pareja con fread. Es capaz de escribir hacia un fichero uno o varios
registros de la misma longitud almacenados a partir de una dirección de
memoria determinada. El valor de retorno es el número de registros
escritos, no el número de bytes. Los parámetros son: un puntero a la zona
de memoria de dondese obtendrán los datos a escribir, el tamaño de cada
registro, el número de registros a escribir y un puntero a la estructura FILE
del fichero al que se hará la escritura.
El prototipo correspondientede fwrite es:
size_t fwrite(void *puntero, size_t tamano, size_t cantidad,
FILE *archivo);

23. 22
Un ejemplo concreto del uso de fwrite con su contraparte fread y usando
funciones es:
#include <stdio.h>
int main ( int argc, char **argv )
{
FILE *fp;
char cadena[] = "Mostrando el uso de fwrite en un fichero.n";
fp = fopen ( "fichero.txt", "r+" );
fwrite( cadena, sizeof(char), sizeof(cadena), fp ); //char
cadena[]... cada posición es de tamaño 'char'
fclose ( fp );
return 0;
}
FPRINTF
La función fprintf funciona igual que printf en cuanto a parámetros, pero la
salida se dirige a un archivo en lugar de a la pantalla.
El prototipo correspondiente de fprintf es:
int fprintf(FILE *archivo, const char *formato, argumento, ...);

24. 23
Podemos ver un ejemplo de su uso, abrimos el documento "fichero.txt" en
modo lectura/escritura y escribimos dentro de él.
#include <stdio.h>
int main ( int argc, char **argv )
{
FILE *fp;
char buffer[100] = "Esto es un texto dentro del fichero.";
fp = fopen ( "fichero.txt", "r+" );
fprintf(fp, buffer);
fprintf(fp, "%s", "nEsto es otro texto dentro del fichero.");
fclose ( fp );
return 0;
}

25. 24
FUNCIONES
Como vimos anteriormente C tiene como bloque básico la función main() ,
también hemos visto la sentencia printf() que es otra función, y de igual
forma hay muchas más funciones predefinidas, pero nosotros mismos
también podemos definir nuestras propias funciones. Dehecho, es
fundamental hacerlo.
Podemos definir una función cualquiera de la misma manera en que
definimos la función main(). Basta con poner su tipo, su nombre, sus
argumentos entre paréntesis y luego, entre llaves, su código:
LA SENTENCIA RETURN
La sentencia return puede utilizarse dentro de una función para terminar
su ejecución.
ARGUMENTOS
Las funciones también pueden recibir argumentos o parámetros, para
modificar su comportamiento.

26. 25
VARIABLES LOCALES Y GLOBALES
Además de pasar valores a una función, también se pueden declarar tipos
de datos dentro de las funciones,estos tipos de datos declaradosdentro de
una función solo son accesibles dentro de esta misma función y se les
conocen como variables locales, así pues podemos definir los mismos
nombres de variables en diferentes funciones, ya que estas variables solo
son accesibles dentro de esas funciones.
INSTRUCCIONES DE CONTROL
C es un ejemplo de programación estructurada. En este tipo de
programación, es necesario contar con ciertas estructuras que permitan
controlar el flujo del programa, es decir, tomar decisiones y repetir
acciones.
LA ESTRUCTURA CONDICIONAL IF... ELSE
En la gran mayoría de los programas será necesario tomar decisiones
sobrequé acciones realizar. Esas decisiones pueden depender de los datos
que introduzcael usuario, desi se ha producido algún error o de cualquier
otra cosa.
La estructura condicional if... else es la que nos permite tomar ese tipo de
decisiones. Traducida literalmente del inglés, se la podría llamar la
estructura "si...sino", es decir, "si secumple la condición, haz esto, y si no,
haz esto otro".
Un ejemplo sencillo sería el siguiente:

27. 26
OPERADORES DE COMPARACIÓN
El símbolo > visto en el último ejemplo es un operador, que en este caso
compara dos números enteros y devuelve verdadero si el primero es
mayor, falso en caso contrario.
A continuación un listado de los posibles operadores decomparación en C
y su significado.
Operadores de Comparación
Operador Significado
< estrictamente menor que
> estrictamente mayor que
<= menor o igual que
>= mayor o igual que
== igual a
!= distinto de
OPERADORES LÓGICOS
Los operadores && ("y"), || ("o") y ! ("no") son operadores lógicos.
Permiten operar con expresiones lógicas para generar expresiones más
complejas.
LA ESTRUCTURA CONDICIONAL ABIERTA Y CERRADA SWITCH... CASE
La estructura condicional switch... case se utiliza cuando queremos
evitarnos las llamadas escaleras de decisiones. La estructura if nos puede
proporcionar, únicamente, dos resultados, uno para verdadero y otro para
falso. Una estructura switch... case, por su parte, nos permite elegir entre
muchas opciones.

28. 27
EL BUCLE DO...WHILE
El bucle do...whilees un bucle que, por lo
menos, se ejecuta una vez. Do significa literalmente "hacer", y while
significa "mientras”
EL BUCLE WHILE
El bucle while sirvepara ejecutar código reiteradas veces.
La condición debe de ser una expresión lógica, similar a la de la sentencia
if. Primero seevalúa la condición. Si el resultado es verdadero, se
ejecuta el bloque de código. Luego sevuelve a evaluar la condición, y en
caso de dar verdadero se vuelvea ejecutar el bloque. El bucle se corta
cuando la condición da falso.
Ejemplo: imprimir los números de 0 a 99:
EJEMPLO

29. 28
EL BUCLE FOR
El bucle for es un bucle muy flexible y a la vez muy potente ya que tiene
varias formas interesantes de implementarlo, su forma más tradicional es
la siguiente:
for (/* inicialización */; /* condición */; /* incremento */) {
/* código a ejecutar */
}
Inicialización: en esta parte se inicia la variable que controla el bucle y es
la primera sentencia que ejecuta el bucle. Sólo se ejecuta una vez ya que
solo senecesita al principio del bucle.
Expresióncondicional: al igual que en el bucle while, esta expresión
determina si el bucle continuará ejecutándoseo no.
Incremento: es una sentencia que ejecuta al final de cada iteración del
bucle. Por lo general, se utiliza para incrementar la variable con que se
inició el ciclo. Luego de ejecutar el incremento, el bucle revisa
nuevamente la condición, si es verdadera tiene lugar una ejecución más
del cuerpo del ciclo, si es falsa se termina el ciclo y así.

30. 29
Fuentes:
- Clase de Laboratorio de Programación 1, Universidad
Centroamericana
- Programación en C, es.wikilibros.org