MANUAL C/C++

MANUAL C/C++

Laboratorio de Programación I

Laboratorio de Programación I

Docente: Elsner Boanerge Gonzáles

1.Introduccion a c/c++_______________________________________________________________________1

1.1 Lenguaje C++__________________________________________________________________________1

1.2 Programa____________________________________________________________________________1

1.3 Funciones____________________________________________________________________________1

1.3.1 La Funcion Main ()____________________________________________________________________1

1.4 Tipos de Variables_____________________________________________________________________3

1.5 Palabras reservadas de C++______________________________________________________________5

1.6 Conversion de variables_________________________________________________________________5

1.7 Operadores___________________________________________________________________________5

1.8 Lenguaje C____________________________________________________________________________81.8.1 Introducción________________________________________________________________________________________81.8.2 Estructura básica de un programa en C___________________________________________________________________8

2. Estructura de un Programa________________________________________________________________10

2.1 Sentencia IF__________________________________________________________________________11

2.2 Sentencia Switch_____________________________________________________________________11

2.3 Asignacion de variables________________________________________________________________12

2.4 Sentencia FOR________________________________________________________________________12

2.4 Arreglos_____________________________________________________________________________13

2.5 Estructuras__________________________________________________________________________14

3.Operadores de Entrada/Salida_____________________________________________________________15

3.1 Librerias____________________________________________________________________________15

3.2 Operadores__________________________________________________________________________15

3.2.1 Tipos de Valores____________________________________________________________________17

3.2.2 Editor de Texto_____________________________________________________________________17

4.Estructuras_____________________________________________________________________________18

4.1 Estructuras Anidadas__________________________________________________________________19

5. Ficheros C++____________________________________________________________________________20

5.1 El puntero a un archivo________________________________________________________________20

5.2 Declaracion__________________________________________________________________________20

5.3 Modos______________________________________________________________________________20

5.4 Funciones___________________________________________________________________________21

5.4.1 fseek ()____________________________________________________________________________21

MANUAL C/C++

5.4.2 fputc()____________________________________________________________________________21

5.4.3 Feof()_____________________________________________________________________________22

5.4.4 rewind();__________________________________________________________________________22

5.4.5 fputs()____________________________________________________________________________22

5.4.6 fgets ();____________________________________________________________________________23

5.4.7 fread();____________________________________________________________________________23

5.4.8 fwrite();___________________________________________________________________________24

5.4.9 fprintf();___________________________________________________________________________24

5.4.10 fscanf();__________________________________________________________________________24

5.4.11 fflush();___________________________________________________________________________24

5.4.12 ftell______________________________________________________________________________24

5.5 Archivos Secuenciales_________________________________________________________________25

6.Funciones______________________________________________________________________________26

6.1 Definición___________________________________________________________________________26

6.2 Ejemplo_____________________________________________________________________________26

MANUAL C/C++

1

1.INTRODUCCION A C/C++1.1 Lenguaje C++C++ es un lenguaje de programaci on, creado a mediados de 1980 por Bjarne Strousstrup, como extension del ́lenguaje C. Este lenguaje abarca tres paradigmas de la programaci on: ́1. Programaci on Estructurada ́2. Programaci on Gen erica ́ ́3. Programaci on Orientada a Objetos ́En la actualidad, C++ es un lenguaje versatil, potente y general. Su exito entre los programadores le ha llevado a ocupar el primer puesto como herramienta de desarrollo de aplicaciones, ya sea en Windows o GNU Linux.

1.2 ProgramaUn programa en sentido informático está constituido por un conjunto de instrucciones que se ejecutan ordinariamente de modo secuencial,es decir, cada una a continuación de la anterior.

1.3 FuncionesEl lenguaje C++ hace uso del concepto de función (function). Sea cual sea la nomenclatura, la idea es sin embargo siempre la misma: dividir un programa grande en un conjunto de subprogramas o funciones más pequeñas que son llamadas por el programa principal; éstas a su vez llaman a otras funciones más específicas y así sucesivamente.

1.3.1 La Funcion Main ()Todo programa C++, desde el más pequeño hasta el más complejo, tiene un programa principal que es con el que se comienza la ejecución del programa. Este programa principal es también una función, pero una función que está por encima de todas las demás.

Esta función se llama main() y tiene la forma siguiente:

int main(int argc, char *argv[])

{sentencia_1sentencia_2...}

Aunque el uso habitual es más simple:

void main(void){

MANUAL C/C++

...}

MANUAL C/C++

1.4 Tipos de VariablesEl C++, como cualquier otro lenguaje de programación, tiene posibilidad de trabajar con datos de distinta naturaleza: texto formado por caracteres alfanuméricos, números enteros, números reales con parte entera y parte fraccionaria, etc. Además, algunos de estos tipos de datos admiten distintos números de cifras (rango y/o precisión), posibilidad de ser sólo positivos o de ser positivos y negativos, etc.

La palabra char hace referencia a que se trata de un carácter (una letra mayúscula o minúscula, un dígito, un carácter especial, ...). La palabra int indica que se trata de un número entero, mientras que float se refiere a un número real (también llamado de punto o coma flotante). Los números enteros pueden ser positivos o negativos (signed), o bien esencialmente no negativos (unsigned); los caracteres tienen un tratamiento muy similar a los enteros y admiten estos mismos cualificadores. En los datos enteros, las palabras short y long hacen referencia al número de cifras o rango de dichos números. En los datos reales las palabras double y long apuntan en esta misma dirección, aunque con un significado ligeramente diferente, como más adelante se verá.

MANUAL C/C++

1.5 Palabras reservadas de C++En C++, como en cualquier otro lenguaje, existen una serie de palabras clave (keywords) que el usuario no puede utilizar como identificadores (nombres de variables y/o de funciones). Estas palabras sirven para indicar al computador que realice una tarea muy determinada (desde evaluar una comparación, hasta definir el tipo de una variable) y tienen un especial significado para el compilador. El C++ es un lenguaje muy conciso, con muchas menos palabras clave que otros lenguajes.

1.6 Conversion de variablesCuando nuestro programa contiene operaciones binarias con operandos de distintos tipos,estos se convierten a un tipo en comun, en general para conversiones expl´ıcitas C++ hace uso del casting, lo que nos permite tener m´as presici´on en aquellos casos en los que el resultado de la operacion no es un int y la variable receptora si lo es.

Algunas reglas que controlan estas conversiones son las siguientes:

1. Cualquier tipo entero pequeño como char o short sera convertido a int o unsigned int.

2. Si algun operando es de tipo long double, el otro se convertira a long double.

3. Si algun operando es de tipo double, el otro se convertira a double.

4. Si algun operando es de tipo float, el otro se convertira a float.

5. Si algun operando es de tipo unsigned long long, el otro se convertira a unsigned long

long.

6. Si algun operando es de tipo long long, el otro se convertira a long long.

7. Si algun operando es de tipo unsigned long, el otro se convertir´a a unsigned long.

8. Si algun operando es de tipo long, el otro se convertira a long.

9. Si algun operando es de tipo unsigned int, el otro se convertira a unsigned int.

1.7 OperadoresLos operadores son signos especiales a veces, conjuntos de dos caracteres que indican determinadas operaciones a realizar con las variables y/o constantes sobre las que actúan en el programa. El

MANUAL C/C++

lenguaje C++ es particularmente rico en distintos tipos de operadores: aritméticos(+, -, *, /, %), de asignación (=, +=, -=, ++, --, *=, /=), relacionales(==, <, >, <=, >=, !=), lógicos (&&, ||, !) y otros.

MANUAL C/C++

Los distintos operadores permiten formar expresiones tanto aritméticas como lógicas. Los operadores aritméticos y lógicos son:

+, - suma, resta

++, -- incremento, decremento

*, /, % multiplicación, división, módulo

>>, << rotación de bits a la derecha, izquierda.

& AND booleano

| OR booleano

^ EXOR booleano

~ complemento a 1

! complemento a 2, NOT lógico

==, != igualdad, desigualdad

&&, || AND, OR lógico

<, <= menor, menor o igual

>, >= mayor, mayor o igual

En estos operadores deben tenerse en cuenta la precedencia de operadores y las reglas de asociatividad, que son las normales en la mayoría de lenguajes. Se debe consultar el manual de referencia para obtener una explicación detallada. Además hay toda una serie de operadores aritméticos con asignación, como pueden ser += y ^=.

En la evaluación de expresiones lógicas, los compiladores normalmente utilizan técnicas de evaluación rápida. Para decidir si una expresión lógica es cierta o falsa muchas veces no es necesario evaluarla completamente. Por ejemplo una expresión formada <exp1> || <exp2>, el compilador evalúa primero <exp1> y si es cierta, no evalúa <exp2>. Por ello se deben evitar construcciones en las que se modifiquen valores de datos en la propia expresión, pues su comportamiento puede depender de la implementación del compilador o de la optimización utilizada en una compilación o en otra. Estos son errores que se pueden cometer fácilmente en C ya que una asignación es también una expresión.

MANUAL C/C++

1.8 Lenguaje C1.8.1 Introducción C es un lenguaje de programación de propósito general que ofrece economía sintáctica, control de flujo y estructuras sencillas y un buen conjunto de operadores. No es un lenguaje de muy alto nivel y más bien un lenguaje pequeño, sencillo y no está especializado en ningún tipo de aplicación. Esto lo hace un lenguaje potente, con un campo de aplicación ilimitado y sobre todo, se aprende rápidamente. En poco tiempo, un programador puede utilizar la totalidad del lenguaje.

Este lenguaje ha sido estrechamente ligado al sistema operativo UNIX, puesto que fueron desarrollados conjuntamente. Sin embargo, este lenguaje no está ligado a ningún sistema operativo ni a ninguna máquina concreta. Se le suele llamar lenguaje de programación de sistemas debido a su utilidad para escribir compiladores y sistemas operativos, aunque de igual forma se puede desarrollar cualquier tipo de aplicación.

1.8.2 Estructura básica de un programa en CLa mejor forma de aprender un lenguaje es programando con él. El programa más sencillo que se puede escribir en C es el siguiente:

main( )

{

}

Como nos podemos imaginar, este programa no hace nada, pero contiene la parte más importante de cualquier programa C y además, es el más pequeño que se puede escribir y que se compile correctamente. En el se define la función main, que es la que ejecuta el sistema operativo al llamar a un programa C. El nombre de una función C siempre va seguida de paréntesis, tanto si tiene argumentos como si no. La definición de la función está formada por un bloque de sentencias, que esta encerrado entre llaves {}.

Un programa algo más complicado es el siguiente:

#include <stdio.h>

main( )

{

printf("Hola amigos!\n");

}

Con el visualizamos el mensaje Hola amigos! en el terminal. En la primera línea indica que se tengan en cuenta las funciones y tipos definidos en la librería stdio (standard input/output). Estas definiciones se encuentran en el fichero header stdio.h. Ahora, en la función main se incluye una única sentencia que llama a la función printf. Esta toma como argumento una cadena de caracteres, que se imprimen van encerradas entre dobles comillas " ". El símbolo \n indica un cambio de línea.

MANUAL C/C++

Hay un grupo de símbolos, que son tratados como caracteres individuales, que especifican algunos caracteres especiales del código ASCII. Los más importantes son:

\a Alerta

\b Espacio atrás

\f Salto de página

\n Salto de línea

\r Retorno de carro

\t Tabulación horizontal

\v Tabulación vertical

Un programa C puede estar formado por diferentes módulos o fuentes. Es conveniente mantener los fuentes de un tamaño no muy grande, para que la compilación sea rápida. También, al dividirse un programa en partes, puede facilitar la legibilidad del programa y su estructuración. Los diferentes fuentes son compilados de forma separada, únicamente los fuentes que han sido modificados desde la última compilación, y después combinados con las librerías necesarias para formar el programa en su versión ejecutable.

MANUAL C/C++

2. ESTRUCTURA DE UN PROGRAMA

# include <iostream>

Las lıneas que comienza con un s´ımbolo de sostenido # son directivas para el preprocesador.En este caso, la directiva #include <iostream>le dice al preprocesador que incluya el iostream est´andar de archivo. Este archivo espec´ıfico (iostream) incluye las declaraciones de la norma b´asica de entrada y salida de la biblioteca de C++.

using namespace std;

Todos los elementos del modelo de libreria de C++ se declaran dentro de lo que se denomina un espacio de nombres. Por lo tanto, para poder acceder a su funcionalidad declaramos con esta expresi´on que vamos a utilizar estas entidades. Esta l´ınea es muy frecuente en losprogramas que utilizan la biblioteca est´andar, y de hecho ser´a incluido en la mayorıa de los codigos.

int main ()

{

}

Esta linea se corresponde con el comienzo de la definici´on de la funcion principal. Lafuncion principal es el punto por donde todos los programas inician su ejecuci´on, independientemente de su ubicaci´on dentro del c´odigo fuente. No importa si hay otras funciones con otros nombres definidos antes o despu´es de las instrucciones que figuran dentro de esta funcion, ya que por definici´on ser´a siempre la primera en ser ejecutada. Por esa misma razon, es esencial que todos los programas tengan una funci´on principal. Lo que se contiene dentro de las llaves que delimitan la funci´on es lo que hace cuando se ejecuta.

count <<"hello World";

Esta linea es una declaracion de C++, en terminos simples es una expresion que produce algun efecto. De hecho, esta declaraci´on lleva a cabo la unica accion que genera un efecto visible en nuestro programa. Representa el flujo de salida y su objetivo es insertar una secuencia de caracteres ( ”hello World”) en el flujo de salida estandar (pantalla).

Cin>>a;

Esta declaracion es de entrada, permite alojar un dato o expresion en una variable que luego pasará a ocupar un espacio en memoria según el tipo de valor qu ele hayamos asignado.

return 0;

Esta declaracion hace que la funci´on pricipal termine. Un c´odigo de retorno es 0, cuando la funcion principal interpreta de manera general que el programa trabaj´o como se esperaba, sin ningun error durante su ejecuci´on. Esta es la forma mas habitual para poner fin a un programa C++ en la consola.

MANUAL C/C++

2.1 Sentencia IFLa sentencia de control básica es if (<e>) then <s> else <t>. En ella se evalúa una expresión condicional y si se cumple, se ejecuta la sentencia s; si no, se ejecuta la sentencia t. La segunda parte de la condición, else <t>, es opcional.

Sintaxis:

if( <expresion booleana>)

<bloque a ejecutar cuando la expresíon es verdadera>

else

<bloque a ejecutar cuando la expresion es falsa>

La sentencia else es opcional, puede utilizarse o no. En el caso de no utilizarlo, cuando la expresion evaluada sea falsa la ejecucion continuara con la sentencia inmediatamente posterior al if.

2.2 Sentencia SwitchSe puede programar con un grupo de sentencias if then else anidadas, aunque ello puede ser farragoso y de complicada lectura. Para evitarlo nos puede ayudar la sentencia switch.

Su utilización es:

switch (valor) {

case valor1: <sentencias>

case valor2: <sentencias>

...

default: <sentencias>

}

MANUAL C/C++

Cuando se encuentra una sentencia case que concuerda con el valor del switch se ejecutan las sentencias que le siguen y todas las demás a partir de ahí, a no ser que se introduzca una sentencia break para salir de la sentencia switch. Por ejemplo:

ver_opcion ( char c )

{

switch(c){

case 'a': printf("Op A\n");

break;

case 'b': printf("Op B\n");

break;

case 'c':

case 'd': printf("Op C o D\n");

break;

default: printf("Op ?\n");

}

}

2.3 Asignacion de variablesEn las asignaciones se debe evitar la conversion explıcita de tipos de datos. Se aconseja no hacer asignaciones multiples, ya que estas dan a lugar a actuaciones err´oneas. En general las sentencias de asignaci´on tienen la forma:

tipo variable;variable = expresion;

2.4 Sentencia FORLa sentencia for se usara para definir un ciblo en el que una variable se incrementa de manera constante en cada iteraci´on y la finalizaci´on del ciblo se determina mediante una expresion constante. Como contador en for se utilizar´an preferiblemente variables de un solo caracter como i, j, k, declarandolas dentro del mismo ciclo. Su formato general es:

for (inicializacion; condicion; incremento){ instruccion(es); };

MANUAL C/C++

2.5 Sentencia WHILE

Otras sentencias de control de flujo son las que nos permiten realizar iteraciones sobre un conjunto de sentencias. En C tenemos tres formas principales de realizar iteraciones. La sentencia while (<e>) <s> es seguramente la más utilizada. La sentencia, o grupo de sentencias <s> se ejecuta mientras la evaluación de la expresión <e> sea verdadera.

long raiz ( long valor )

{

long r = 1;

while ( r * r <= valor )

r++;

return r;

}

Una variación de la sentencia while es: do <s> while ( <e> ); En ella la sentencia se ejecuta al menos una vez, antes de que se evalúe la expresión condicional.

2.4 ArreglosArreglo: Coleccion ordenada de elementos de un mismo tipo. Ordenada significa que cada elemento tiene una ubicacion determinada dentro del arreglo y debemos conocerla para poder acceder a el.

Se definen de la siguiente manera:

<tipo>nombre variable [longitud];

Con esto diremos que nombre variable es un arreglo de longitud elementos del tipo <tipo>. Cabe destacar que longitud debe ser cualquier expresi´on entera constante mayor que cero. Un arreglo se asigna de la siguiente manera:

nombre variable[ındice] = expresi´on del tipo <tipo >

MANUAL C/C++

2.5 EstructurasUna estructura es un grupo de variables relacionadas de manera l´ogica, las cuales pueden ser de diferentes tipos y declaradas en una sola unidad, donde la unidad es la estructura.

En C++ se forma una estructura utilizando la palabra reservada struct, seguida por un campo etiqueta opcional, y luego una lista de miembros dentro de la estructura. La etiqueta opcional se utiliza para crear otras variables del tipo particular de la estructura.

struct campo_etiqueta

{

tipo_miembro miembro_1;

tipo_miembro miembro_2;

tipo_miembro miembro_n;

};

Un punto y coma finaliza la definicion de una estructura puesto que esta es realmente una sentencia C++ .

MANUAL C/C++

3.OPERADORES DE ENTRADA/SALIDA3.1 LibreriasLas Librerias cabecera C terminan en “.h” y en la librería C++ mantienen los mismos nombres.

Comillas, “ ” el procesador incluye en el mismo directorio que el archivo se esta compilando.

Corchete <>, se utilizan para los archivos de cabecera estandar de biblioteca.

Numeral #, se utiliza para mandar a llamar la librería seguido de la palabra “include”.

3.2 OperadoresLas Operaciones E/S no forman parte de C/C++ funciones de biblioteca de C las encontramos en el archivo cabecera “stdio.h” (standard input-output header).

-Putchar(): Imprime un carácter en la pantalla.

Putchar (variable_caracter);char c;…putchar (c);

-gets(): Lee una cadena de caracteres introducida por el teclado.

-puts(): Imprime una cadena en la pantalla, seguida de un carácter de salto de linea.

#include <stdio.h>main(){

char linea [80];gets(linea);puts(linea);

}

Fflush (stdin)Limpia el buffer (memoria intermedia) utilizanda por la entrada estandar del sistema, generalmente el teclado.

Fflush (stdout)La funcion printf no imprime directamente en la pantalla sino, era en una memoria intermedia (buffer).

Scanf ()Lee los valores a asignar en las variables introducidos por el teclado, no es necesario el “&” cuando el dato es una cadena de caracteres

Scanf(“%s”,cad); ó scanf (“%s”,&cad);

Printf ()Es similar a scanf, pero se usa para las salidas, permite escribir textos y datos en la pantalla.

Print (“El total a pagar es %d”,total);

MANUAL C/C++

MANUAL C/C++

3.2.1 Tipos de Valores

C Carácterd Entero Decimale Valor en coma flotantef Valor en coma flotanteg Valor en coma flotanteh Entero cortoi Entero decimal, octa o hexadecimalO Entero octalS Cadena de caracteres con espaciadoU Entero decimal sin signoX Entero Hexadecimal

[…] Cadena de caracteres con espaciado%[^\n] Mas de un espacio

3.2.2 Editor de Texto\b Espacio atrás\f Salto de página\n Salto de linea\r Retorno de carro\t Tabulacion Horizontal\v Tabulacion Vertical\\ Barra Invertida\´ Código Simple\´´ Código Doble

MANUAL C/C++

4.ESTRUCTURASLas estructuras son el segundo tipo de datos estructurados que veremos (valga la redundancia).

Al contrario que los arrays, las estructuras nos permiten agrupar varios datos, que mantengan algún tipo de relación, aunque sean de distinto tipo, permitiendo manipularlos todos juntos, usando un mismo identificador, o cada uno por separado.

Las estructuras son llamadas también muy a menudo registros, o en inglés records. Tienen muchos aspectos en común con los registros usados en bases de datos. Y siguiendo la misma analogía, cada objeto de una estructura se denomina a menudo campo, o field.

struct [<identificador>]

{

[<tipo> <nombre_objeto>[,<nombre_objeto>,...]];

[<objeto_estructura>[,<objeto_estructura>,...]

};

Una vez definida una estructura, es decir, si hemos especificado un nombre para ella, se puede usar igual que cualquier otro tipo de C++. Esto significa que se pueden declarar más objetos del tipo de estructura en cualquier parte del programa. Para ello usaremos la forma normal de declaración de objetos, es decir:

[struct] <identificador> <objeto_estructura>

[,<objeto_estructura>...];

En C++ la palabra struct es opcional en la declaración de objetos, al contrario de lo que sucede en C, en el que es obligatorio usarla.

Ejemplo:

struct Persona {

char Nombre[65];

char Direccion[65];

int AnyoNacimiento;

} Fulanito;

Este ejemplo define la estructura Persona y declara a Fulanito como un objeto de ese tipo. Para acceder al nombre de Fulanito, por ejemplo para visualizarlo, usaremos la forma:

cout << Fulanito.Nombre; ó printf(“%s”,Fulanito.Nombre);

MANUAL C/C++

4.1 Estructuras AnidadasTambién está permitido anidar estructuras, con lo cual se pueden conseguir superestructuras muy elaboradas.

struct stDireccion {

char Calle[64];

int Portal;

int Piso;

char Puerta[3];

char CodigoPostal[6];

char Poblacion[32];

};

struct stPersona {

struct stNombre {

char Nombre[32];

char Apellidos[64];

} NombreCompleto;

stDireccion Direccion;

char Telefono[10];

};

En general, no es una práctica corriente definir estructuras dentro de estructuras, ya que tienen un ámbito local, y para acceder a ellas se necesita hacer referencia a la estructura más externa.

Por ejemplo para declarar un objeto del tipo stNombre hay que utilizar el operador de acceso (::):

stPersona::stNombre NombreAuxiliar;

Sin embargo para declarar un objeto de tipo stDireccion basta con declararla:

stDireccion DireccionAuxiliar;

MANUAL C/C++

5. FICHEROS C++Un archivo es identificado por un nombre y la descripcion de la carpeta o directorio que lo contiene.

Hay dos tipos de archivos, archivos de texto y archivos binarios.

Un archivo binario es una secuencia de bytes que tienen una correspondencia uno a otro con un dispositivo externo. Asi no tendra lugar ninguna traduccion de caracteres.

En C, un archivo es un concepto lógico que puede aplicarse a muchas cosas desde archivos de discos hasta terminales o una impresión.

Para trabajar con un archivo se asocia con una estructura de tipo FILE.

5.1 El puntero a un archivo Es un tipo especial que opera como hilo común que unifica el sistema de E/S con buffer.

Un puntero a un archivo es un puntero a una informacion que define varias cosas sobre él.

5.2 Declaracion

FILE*F

La funcion fopen() abre una secuencia para que pueda ser utilizada y la asocia a un archivo. Su prototipo es FILE*.

FILE*fopen (const char nombre_archivo, const char modo);

5.3 Modosr Abre un archivo de texto para lectura (read)w Abre un archivo para escritura (write)a Abre un archivo de texto para escritura al final

(append)r+ Lectura y escritura (si existe) al principio.w+ Lectura y escritura (crear)a+ Lectura y escritura (al final) (lo crea y lo abre)

MANUAL C/C++

5.4 FuncionesLa funcion fopen() devuelve un puntero al archivo. Un programa nunca debe alterar el valor de ese puntero.Fgets ()Fputs ()Feof()rewind()fgets()fputs()fread()fwrite()Fprintf ()Fscanf ()fflush()ftell()

5.4.1 fseek ()Esta funcion situa el puntero sobre un archivo.

fseek(fichero, posicion, origen);

Que coloca el puntero a tantos bytes del origen como indica posicion contando a partir del origen.

Seek_Set o 0 : Pricipio del ficheroSeek_Cur o 1 : Posicion actualSeek_END o 2 : Final del Fichero

“(Fseek devuelve 0 si no ha devuelto ningun error).”

Para saber cual es la posicion en la uqe está el puntero de fichero C se usa: Ftell (fich);

Devuelve la posicion actual en bytes.

Length -> len = ftell(fp)

5.4.2 fputc()Esta función escribe un carácter a un fichero.

int fputc(int caracter, FILE *fichero);

El valor de retorno es el carácter escrito, si la operación fue completada con éxito, en caso contrario será EOF. Los parámetros de entrada son el carácter a escribir, convertido a int y un puntero a una estructura FILE del fichero en el que se hará la escritura.

MANUAL C/C++

5.4.3 Feof()Esta función sirve para comprobar si se ha alcanzado el final del fichero. Muy frecuentemente deberemos trabajar con todos los valores almacenados en un archivo de forma secuencial, la forma que suelen tener los bucles para leer todos los datos de un archivo es permanecer leyendo mientras no se detecte el fin de fichero. Esta función suele usarse como prueba para verificar si se ha alcanzado o no ese punto.

int feof(FILE *fichero);

El valor de retorno es distinto de cero sólo si no se ha alcanzado el fin de fichero. El parámetro es un puntero a la estructura FILE del fichero que queremos verificar.

5.4.4 rewind();Es una función heredada de los tiempos de las cintas magnéticas. Literalmente significa "rebobinar", y hace referencia a que para volver al principio de un archivo almacenado en cinta, había que rebobinarla. Eso es lo que hace ésta función, sitúa el cursor de lectura/escritura al principio del archivo.

void rewind(FILE *fichero)

El parámetro es un puntero a la estructura FILE del fichero que queremos rebobinar.

5.4.5 fputs()La función fputs escribe una cadena en un fichero. No se añade el carácter de retorno de línea ni el carácter nulo final.

int fputs(const char *cadena, FILE *stream);

El valor de retorno es el número de registros leídos, no el número de bytes. Los parámetros son: un puntero a la zona de memoria donde se almacenarán los datos leídos, el tamaño de cada registro, el número de registros a leer y un puntero a la estructura FILE del fichero del que se hará la lectura.

MANUAL C/C++

Ejemplo:

#include <stdio.h>

int main()

{

FILE *fichero;

fichero = fopen("ejemplo1.c", "r");

while(!feof(fichero)) fputc(fgetc(fichero), stdout);

rewind(fichero);

while(!feof(fichero)) fputc(fgetc(fichero), stdout);

fclose(fichero);

getchar();

return 0;

}

5.4.6 fgets ();Esta función está diseñada para leer cadenas de caracteres. Leerá hasta n-1 caracteres o hasta que lea un retorno de línea. En este último caso, el carácter de retorno de línea también es leído.

char *fgets(char *cadena, int n, FILE *fichero);

El parámetro n nos permite limitar la lectura para evitar derbordar el espacio disponible en la cadena.

El valor de retorno es un puntero a la cadena leída, si se leyó con éxito, y es NULL si se detecta el final del fichero o si hay un error. Los parámetros son: la cadena a leer, el número de caracteres máximo a leer y un puntero a una estructura FILE del fichero del que se leerá.

5.4.7 fread();Esta función está pensada para trabajar con registros de longitud constante. Es capaz de leer desde un fichero uno o varios registros de la misma longitud y a partir de una dirección de memoria determinada. El usuario es responsable de asegurarse de que hay espacio suficiente para contener la información leída.

size_t fread(void *puntero, size_t tamaño, size_t nregistros, FILE *fichero);

El valor de retorno es el número de registros leídos, no el número de bytes. Los parámetros son: un puntero a la zona de memoria donde se almacenarán los datos leídos, el tamaño de cada registro, el número de registros a leer y un puntero a la estructura FILE del fichero del que se hará la lectura.

MANUAL C/C++

5.4.8 fwrite();Esta función tambié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.

size_t fwrite(void *puntero, size_t tamaño, size_t nregistros, FILE *fichero);

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 donde se almacenarán los datos leídos, el tamaño de cada registro, el número de registros a leer y un puntero a la estructura FILE del fichero del que se hará la lectura.

5.4.9 fprintf();La función fprintf funciona igual que printf en cuanto a parámetros, pero la salida se dirige a un fichero en lugar de a la pantalla.

int fprintf(FILE *fichero, const char *formato, ...);

5.4.10 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.

int fscanf(FILE *fichero, const char *formato, ...);

5.4.11 fflush();Esta función fuerza la salida de los datos acumulados en el buffer de salida del fichero. Para mejorar las prestaciones del manejo de ficheros se utilizan buffers, almacenes temporales de datos en memoria, las operaciones de salida se hacen a través del buffer, y sólo cuando el buffer se llena se realiza la escritura en el disco y se vacía el buffer. En ocasiones nos hace falta vaciar ese buffer de un modo manual, para eso sirve ésta función.

int fflush(FILE *fichero);

El valor de retorno es cero si la función se ejecutó con éxito, y EOF si hubo algún error. El parámetro de entrada es un puntero a la estructura FILE del fichero del que se quiere vaciar el buffer. Si es NULL se hará el vaciado de todos los ficheros abiertos.

5.4.12 ftellLa función ftell sirve para averiguar la posición actual del cursor de lectura/excritura de un fichero.

El valor de retorno será esa posición, o -1 si hay algún error.

long int ftell(FILE *fichero);

El parámetro de entrada es un puntero a una estructura FILE del fichero del que queremos leer la posición del cursor de lectura/escritura.

MANUAL C/C++

5.5 Archivos SecuencialesEn estos archivos, la información sólo puede leerse y escribirse empezando desde el principio del archivo.

Los archivos secuenciales tienen algunas características que hay que tener en cuenta:

1. La escritura de nuevos datos siempre se hace al final del archivo.

2. Para leer una zona concreta del archivo hay que avanzar siempre, si la zona está antes de la zona actual de lectura, será necesario "rebobinar" el archivo.

3. Los ficheros sólo se pueden abrir para lectura o para escritura, nunca de los dos modos a la vez.

Esto es en teoría, por supuesto, en realidad C no distingue si los archivos que usamos son secuenciales o no, es el tratamiento que hagamos de ellos lo que los clasifica como de uno u otro tipo.

Pero hay archivos que se comportan siempre como secuenciales, por ejemplo los ficheros de entrada y salida estándar: stdin, stdout, stderr y stdaux.

Tomemos el caso de stdin, que suele ser el teclado. Nuestro programa sólo podrá abrir ese fichero como de lectura, y sólo podrá leer los caracteres a medida que estén disponibles, y en el mismo orden en que fueron tecleados.

Lo mismo se aplica para stdout y stderr, que es la pantalla, en estos casos sólo se pueden usar para escritura, y el orden en que se muestra la información es el mismo en que se envía.

Un caso especial es stdaux, que suele ser el puerto serie. También es un archivo secuencial, con respecto al modo en que se leen y escriben los datos. Sin embargo se un fichero de entrada y salida.

Trabajar con archivos secuenciales tiene algunos inconvenientes. Por ejemplo, imagina que tienes un archivo de este tipo en una cinta magnética. Por las características físicas de este soporte, es eviente que sólo podemos tener un fichero abierto en cada unidad de cinta. Cada fichero puede ser leído, y también sobrescrito, pero en general, los archivos que haya a continuación del que escribimos se perderán, o bien serán sobreescritos al crecer el archivo, o quedará un espacio vacío entre el final del archivo y el principio del siguiente.

MANUAL C/C++

6.FUNCIONES6.1 DefiniciónLos programas sencillos, como los ejemplo planteados hasta ahora, normalmente no necesitan un nivel de estructuración elevado. Pero cuando éstos crecen un poco necesitamos estructurarlos adecuadamente para mantenerlos legibles, facilitar su mantenimiento y para poder reutilizar ciertas porciones de código. El mecanismo C que nos permite esto son las funciones. Con los compiladores, los fabricantes nos proporcionan un conjunto importante de funciones de librería. A veces, nos puede interesar construir nuestras propias librerías. Ya hemos utilizado funciones, pero veamos cómo debemos definirlas.

6.2 EjemploLos prototipos de funciones son una característica clave de la recomendación ANSI del C. Un prototipo es una declaración que toma la forma:

tipo_resultado nombre_función ( tipo_parámetro nombre_parámetro ... );

int fact_i ( int v );

int mayor ( int a, int b );

int cero ( double a );

long raiz ( long valor );

void final_countdown ( void );

int main ( int argc, char **argv );

Observando el prototipo de una función podemos decir exactamente que tipo de parámetros necesita y que resultado devuelve. Si una función tiene como argumento void, quiere decir que no tiene argumentos, al igual que si el resultado es void, no devuelve ningún valor. Caso contrario si este tiene parámetros para regresar un valor, las demás funciones deben tener el la misma variable en sus parámetros para que esta pueda moverse en todo el programa, si no lo tiene el valor se queda en la funcion que se declara o se pasa.

void menuCompr(int inv[],int salida,int c,int op,int ns,int in,FILE *O,FILE *I,FILE *P); void menuCont(int inv[],int salida,int c,int op,int ns,int in,FILE *O,FILE *I,FILE *P); void menu_principal(int inv[],int salida,int op,int ns,int in,FILE *I,FILE *O,int c,FILE *P);

Los programas complejos se escriben normalmente usando varios ficheros fuente. Estos ficheros se compilan separadamente y se enlazan todos juntos. Esto es una gran ventaja durante el desarrollo y depuración de grandes programas, ya que las modificaciones en un fichero fuente sólo nos obligarán a compilar ese fichero fuente, y no el resto, con el consiguiente ahorro de tiempo.

La definición de las funciones y clases puede hacerse dentro de los ficheros fuente o también pueden enlazarse desde bibliotecas compiladas previamente.

En C++ es obligatorio el uso funciones prototipo, y aunque en C no lo es, resulta altamente recomendable.

MANUAL C/C++

7. ANEXOSMANUAL C/C++