manualito c/c++ - leonardo aquino
TRANSCRIPT
Manual Lenguaje C/C++
Laboratorio de Programación 1
Elaborado Por: Leonardo Aquino
1
CONTENIDO
Introducción.............................................................................................................................................................................................2
Identificadores y Tipos de Datos.............................................................................................................................................................3
Operadores en C......................................................................................................................................................................................4
Size Of......................................................................................................................................................................................................6
Casting......................................................................................................................................................................................................6
Arreglos (Arrays)......................................................................................................................................................................................7
Arreglos Unidimensionales................................................................................................................................................................7
Arreglos Bidimensionales..................................................................................................................................................................8
Estructuras...............................................................................................................................................................................................8
Estructuras anidadas...........................................................................................................................................................................9
Uso de PrintF() y Scanf()..........................................................................................................................................................................9
printf...................................................................................................................................................................................................9
scanf..................................................................................................................................................................................................11
Manejo de archivos...............................................................................................................................................................................12
Ficheros............................................................................................................................................................................................12
fopen.................................................................................................................................................................................................13
fclose............................................................................................................................................................................................13
feof...............................................................................................................................................................................................15
rewind..........................................................................................................................................................................................15
Lectura..............................................................................................................................................................................................15
fgetc..............................................................................................................................................................................................16
fgets..............................................................................................................................................................................................17
fread.............................................................................................................................................................................................18
fscanf............................................................................................................................................................................................19
Escritura............................................................................................................................................................................................20
fputc.............................................................................................................................................................................................20
fputs.............................................................................................................................................................................................21
fwrite............................................................................................................................................................................................22
fprintf............................................................................................................................................................................................23
Funciones...............................................................................................................................................................................................24
La sentencia return.......................................................................................................................................................................25
Argumentos......................................................................................................................................................................................25
Variables Locales y Globales.............................................................................................................................................................25
Instrucciones de control........................................................................................................................................................................26
La estructura condicional IF... else.........................................................................................................................................26
Operadores de comparación........................................................................................................................................................26
Operadores lógicos.......................................................................................................................................................................27
La estructura condicional abierta y cerrada SWITCH... case..................................................................................................27
El bucle do...while.....................................................................................................................................................................28
El bucle while.................................................................................................................................................................................28
El bucle for......................................................................................................................................................................................28
2
INTRODUCCIÓN
El lenguaje C es el resultado de un proceso de desarrollo que inició con un lenguaje denominado BCPL. Este influenció a otro llamado B (inventado por Ken Thompson). En los años 70; éste lenguaje llevó 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 se divide 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 de bases de datos.
Actualmente, debido a sus características, puede ser utilizado para todo tipo de programas.
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 se inicializa 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).
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.*
5
6
SIZE OF
Esta función u operador se usa para mostrar el tamaño de una cadena, por lo general cuando 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 de un tipo de dato a otro.
Aquí una tabla de casting entre tipo de datos:
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 que podremos tener como herramienta de programación. Los arrays, arreglos o 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 almacenados en memoria continua en un vector o lista. Para acceder 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 de 10 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 de dos índices o subíndices declarados en dos pares de corchetes, 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 de 10 filas y 4 columnas.
8
ESTRUCTURAS
En la creación de soluciones para algunos problemas surge la 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 de una 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:
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 lenguaje C, 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 usarse la 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 corresponde a la letra A mayúscula. El formato %c imprime el valor de una expresión como un carácter.
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 caracteres en la entrada como valores para los diferentes tipos de variables. La lista de argumentos está formada por DIRECCIONES de variables. El símbolo & representa al operador de dirección; por ejemplo, la proposición:
scanf("%d", &x);
11
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.
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("\nIngrese un int : "); scanf("%d", &x); printf("\nIngrese un float : "); scanf("%f", &y); printf("\nIngrese un double : "); scanf("%lf", &z); printf("\n\nLos datos que ud. ingreso fueron :\n");
12
printf("%c %d %e %e\n\n", c, x, y, z); }
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 general empiezan 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 sirve para abrir y crear ficheros en disco.
El prototipo correspondiente de fopen es:
FILE * fopen (const char *filename, const char *opentype);
Los parámetros de entrada de fopen son:
13
filename: una cadena que contiene un nombre de fichero válido. opentype: especifica el tipo de fichero que se abrirá o se creará.
Una lista de parámetros opentype para 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 sirve para poder cerrar un fichero que se ha abierto.
El prototipo correspondiente de 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 constante EOF.
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;
14
}
Como vemos, en el ejemplo se utilizó el opentype "r", que es para la lectura.
Otra cosa importante es que el lenguaje C no tiene dentro de si una estructura para el manejo de excepciones o de errores, por eso 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 sirve para señalar que el programa termino por un error.
FEOF
Esta función sirve para 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 que trae 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) si no es encontrado EOF en el archivo, de lo contrario regresará un valor distinto de cero (Verdadero).
El prototipo correspondiente de feof es:
int feof(FILE *fichero);
REWIND
Literalmente significa "rebobinar", sitúa el cursor de lectura/escritura al principio del archivo.
El prototipo correspondiente de rewind es:
void rewind(FILE *fichero);
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 correspondiente de 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.
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. \n\n");
}else{
printf("\nEl contenido del archivo de prueba es \n\n");
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
17
EOF. En este último caso, el carácter de cambio de línea '\n' también es leído.
El prototipo correspondiente de 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). El segundo parámetro es tamaño que es el límite en cantidad de caracteres a leer para la función fgets. Y por último el puntero del archivo por 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 \n\n");
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
18
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.
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 bloque de 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, que especifica 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 correspondiente de fscanf es:
19
int fscanf(FILE *fichero, const char *formato, argumento, ...);
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
20
escrito, si la operación fue completada con éxito, en caso contrario será EOF.
El prototipo correspondiente de fputc es:
int fputc(int carácter, FILE *archivo);
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 escribe una cadena en un fichero. la ejecución de la misma no añade el 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 donde se realizará la escritura.
El prototipo correspondiente de fputs es:
21
int fputs(const char *buffer, FILE *archivo)
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á pensada para trabajar con registros de longitud 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 donde se 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 correspondiente de fwrite es:
size_t fwrite(void *puntero, size_t tamano, size_t cantidad, FILE *archivo);
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, ...);
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;
}
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. De hecho, 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.
25
ARGUMENTOS
Las funciones también pueden recibir argumentos o parámetros, para modificar su comportamiento.
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 declarados dentro 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 sobre qué acciones realizar. Esas decisiones pueden depender de los datos que introduzca el usuario, de si 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...si no", es decir, "si se cumple la condición, haz esto, y si no, haz esto otro".
26
Un ejemplo sencillo sería el siguiente:
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 de comparació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.
27
EL BUCLE DO...WHILE
El bucle do...while es un bucle que, por lo menos, se ejecuta una vez. Do significa literalmente "hacer", y while significa "mientras”
EL BUCLE WHILE
El bucle while sirve para ejecutar código reiteradas veces.
La condición debe de ser una expresión lógica, similar a la de la sentencia if. Primero se evalúa la condición. Si el resultado es verdadero, se ejecuta el bloque de código. Luego se vuelve a evaluar la condición, y en caso de dar verdadero se vuelve a ejecutar el bloque. El bucle se corta cuando la condición da falso.
Ejemplo: imprimir los números de 0 a 99:
EL BUCLE FOR
EJEMPLO
28
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 se necesita al principio del bucle.
Expresión condicional: al igual que en el bucle while, esta expresión determina si el bucle continuará ejecutándose o 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í.
Fuentes:
29
- Clase de Laboratorio de Programación 1, Universidad Centroamericana
- Programación en C, es.wikilibros.org