Your SlideShare is downloading. ×
  • Like
Webcd
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×

Now you can save presentations on your phone or tablet

Available for both IPhone and Android

Text the download link to your phone

Standard text messaging rates apply
Published

 

Published in Business , Technology
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
No Downloads

Views

Total Views
2,753
On SlideShare
0
From Embeds
0
Number of Embeds
0

Actions

Shares
Downloads
107
Comments
0
Likes
4

Embeds 0

No embeds

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1. c++
  • 2. Lenguaje C
    • Características:
    • Lenguaje de Alto Nivel
    • Compilado
    • Estructurado
    • Es case sensitive
    • Hace uso del concepto de función
    • Portabilidad de los archivos fuente
  • 3. Lenguaje C
    • Características:
    • C está constituido por tres elementos:
      • Compilador: Traduce código fuente a código máquina
      • Preprocesador: Facilita la tarea del compilador, permite sustituir constantes simbólicas e incluir archivos
      • Librería Estándar: Funciones preprogramadas agrupadas en un conjunto de librerías de código objeto
  • 4. Lenguaje C .c Fichero Fuente Preprocesamiento .c Paso a Ensamblador .s .o Ensamblar Compilación .o .o .o .o EXE Enlazado .a Librerías Fichero Ejecutable
  • 5. Lenguaje C
    • Estructura básica de un programa:
    • Inclusión de librerías
    • Declaraciones globales
    • main ( ) {
    • variables locales
    • bloque de instrucciones
    • }
    • funcion1 ( ) {
    • variables locales
    • bloque de instrucciones
    • }
    Un programa es un conjunto de instrucciones que -generalmente- se ejecutan de manera secuencial Una función es un subprograma, que es llamado por el programa principal
  • 6. Lenguaje C
    • Comentarios:
    • Para poner comentarios en un programa escrito en C se usan los símbolos: /* y */ o //
    • /* Este es un ejemplo de comentario */
    • /* Un comentario también puede
    • estar escrito en varias líneas */
    • variable_1 = variable_2; // En esta línea se asigna a
    • // variable_1 el valor
    • // contenido en variable_2
  • 7. Lenguaje C
    • Palabras Claves:
    • Representan un conjunto de identificadores reservados
    • auto double int struct
    • break else long switch
    • case enum register typedef
    • char extern return union
    • const float short unsigned
    • continue for signed void
    • default goto sizeof volatile
    • do if static while
  • 8. Lenguaje C
    • Identificadores:
    • Nombre dado a las variables o funciones.
    • Un identificador se forma con una secuencia de letras (minúsculas de la a a la z; mayúsculas de la A a la Z; y dígitos del 0 al 9)
    • El carácter subrayado o underscore (_) se considera como una letra más
    • Un identificador no puede contener espacios en blanco, ni otros caracteres distintos de los citados (*, ; . : - +)
  • 9. Lenguaje C
    • Identificadores:
    • El primer carácter de un identificador debe ser siempre una letra o un (_)
    • Se hace distinción entre letras mayúsculas y minúsculas
    • ANSI C permite definir identificadores de hasta 31 caracteres de longitud
  • 10. Lenguaje C
    • Identificadores
    • Ejemplo:
    • CI_v velocidad_de_la_luz
    • Distancia1 un_valor
    • caso_A PI
    • _num Tiempo
    Es aconsejable elegir los nombres de las funciones y variables de acuerdo a lo que representan
  • 11. Lenguaje C
    • Constantes:
    • Mantienen su valor a lo largo de todo el programa
    • Constantes numéricas . Son valores numéricos, enteros o de punto flotante. Se permiten también constantes octales y hexadecimales
    • Constantes carácter . Cualquier carácter individual encerrado entre apóstrofos ('a' 'Y' ')' '+')
    • Cadenas de caracteres . Un conjunto de caracteres alfanuméricos encerrados entre comillas
  • 12. Lenguaje C
    • Constantes:
    • Constantes simbólicas . Poseen un identificador y se definen mediante la palabra clave const
    • 23484 Constante tipo int
    • 011 Constante octal (9 en base 10)
    • 1.23 Constante tipo double
    • 23.963f Constante tipo float
    • '7' Constante carácter. Valor ASCII 55
    • "Informática I" Constante de carácteres
    • const int i = 10; Constante simbólica
  • 13. Lenguaje C
    • Constantes:
    • Para indicar al compilador que se trata de una constante, se usa la directiva #define :
    • #define <identificador> <valor>
  • 14. Lenguaje C
    • Constantes de Tipo Enumeración
    • Define los posibles valores de un identificador o variable.
    • Ejemplo:
    • enum dia = { lunes, martes, miercoles, jueves , viernes, sabado, domindo};
    • enum dia dia1, dia2;
    • dia1 = martes;
    • enum cartas {oros, copas, espadas, bastos} carta1, carta2;
    Estos valores representan constantes de tipo int: lunes es 0 , martes es 1 , miercoles e 2 , y así sucesivamente
  • 15. Lenguaje C
    • Tipos de Datos:
    Tipo Tama ñ o Rango de valores char 1 byte -128 a 127 int 2 bytes -32768 a 32767 float 4 bytes 3.4 E-38 a 3.4 E+38 double 8 bytes 1.7 E-308 a 1.7 E+308
  • 16. Lenguaje C
    • Calificadores de Tipo:
    • Modifican el rango de valores de un determinado tipo
    • Signed: La variable lleva signo
    Tama ñ o Rango de valores signed char 1 byte -128 a 127 signed int 2 bytes -32768 a 32767
  • 17. Lenguaje C
    • Calificadores de Tipo:
    • Unsigned: La variable no lleva signo
    • Short: Rango de valores en formato corto
    Tamaño Rango de valores unsigned char 1 byte 0 a 255 unsigned int 2 bytes 0 a 65535 Tamaño Rango de valores short char 1 byte -128 a 127 short int 2 bytes -32768 a 32767
  • 18. Lenguaje C
    • Calificadores de Tipo:
    • Long: Rango de valores en formato largo
    • También es posible combinar calificadores entre sí:
    • signed long int = long int = long
    • unsigned long int = unsigned long
    • 4 bytes 0 a 4.294.967.295 (El mayor entero de C)
    Tamaño Rango de valores long char 4 bytes -2.147.483.648 a 2.147.483.647 long int 10 bytes -3.36 E-4932 a 1.18 E+4932
  • 19. Lenguaje C
    • Variables:
    • Una variable es una posición de memoria referenciada por un identificador. Su valor puede cambiar durante la ejecución del programa.
    • Declaración e Inicialización:
    • <tipo> <identificador> = valor;
    • <tipo> <identificador1>, <identificador2>, <identificador3>;
    Toda variable debe ser declarada antes de utilizarse en el programa
  • 20. Lenguaje C
    • Variables - Ejemplo:
    • /* Uso de las variables para la suma de dos valores */
    • main()
    • {
    • int num1 = 4, num2 = 6, num3;
    • num3 = num1 + num2;
    • }
  • 21. Lenguaje C
    • Variables - ¿Dónde se declaran?
    • Pueden ser declaradas antes de la función principal: Variables Globales
    • Pueden ser declaradas dentro de una función: Variables Locales
    • int a; /* variable global */
    • main()
    • {
    • int b = 4; /* variable local */
    • }
    Pueden ser utilizadas en cualquier parte del programa y viven durante toda la ejecución del mismo. Sólo pueden ser utilizadas por la función que la declara. Se crean cuando se llama a la función y se destruye cuando ésta finaliza.
  • 22. Lenguaje C
    • Variables - Duración y Visibilidad:
    • Se refiere al modo de almacenamiento, el cual determina cuándo se crea una variable , cuándo deja de existir y desde dónde se puede acceder a ella
    • auto: Son variables locales. Sólo son visibles en el bloque donde están declaradas, se crean cuando comienza a ejecutarse el bloque y se destruyen cuando éste finaliza su ejecución. No son inicializadas por defecto.
  • 23. Lenguaje C
    • Variables Auto - Ejemplo:
    • {
    • int i = 1, j = 2; //se declaran e inicializan i y j
    • ...
    • {
    • float a = 7, j = 3; // se declara una nueva variable j
    • ...
    • j = j + a; // aquí j es float
    • ... // la variable int j es invisible
    • ... // la variable i es visible
    • }
    • ... // fuera del bloque, a ya no existe
    • ... // la variable j = 2 existe y es entera
    • }
  • 24. Lenguaje C
    • Variables - Duración y Visibilidad:
    • extern: Son variables globales. Son visibles por todas las funciones que están entre la definición y el fin del fichero. Existen durante toda la ejecución del programa.
  • 25. Lenguaje C
    • Variables Extern - Ejemplo:
    • int i = 1, j, k; // se declaran antes de main()
    • int func1(int, int);
    • main()
    • {
    • int i = 3; // i = 1 se hace invisible
    • ... // j, k son visibles
    • }
    • int func1(int i, int m)
    • {
    • int k = 3; // k = 0 se hace invisible
    • ... // i = 1 es invisible
    • }
  • 26. Lenguaje C
    • Variables - Duración y Visibilidad:
    • static: Las variables declaradas static dentro de un bloque conservan su valor en las llamadas sucesivas a dicho bloque. La inicialización sólo se realiza la primera vez.
  • 27. Lenguaje C
    • Variables Static - Ejemplo:
    • int Series()
    • {
    • static int contador;
    • contador = contador +10;
    • return contador;
    • }
  • 28. Lenguaje C
    • Variables - Conversiones
    • Casting (Conversión Explicita): Mecanismo usado para cambiar de tipo expresiones y variables.
    • int a;
    • float b;
    • char c;
    • b = 65.0;
    • a = (int)b; /*a vale 65 */
    • c = (char)a; /* c vale 65 (Código ASCII de ‘A’) */
  • 29. Lenguaje C
    • Variables - Conversiones
    • Conversión Implícita: Ocurre cuando en una expresión se combinan variables de diferentes tipos.
    • int a;
    • float b;
    • long double > double > float > unsigned long > long
    • > unsigned int > int > char
    • int x;
    • double i = 2.5, j = 5.3;
    • x = ((i * j) – j) + 1;
    a + b Ocurre una promoción : a es promovida al tipo de b Conversión por asignación
  • 30. Lenguaje C
    • Sentencias de Escape:
    • Para definir las constantes de tipo carácter asociadas a caracteres especiales se usan secuencias de escape:
  • 31. Lenguaje C
    • Inclusión de Archivos:
    • La directiva #include permite añadir librerías o funciones que se encuentran en otros archivos.
      • Indicando al compilador la ruta donde se encuentra el archivo
      • #include &quot;C:includesfuncion.h&quot;
      • Indicando que se encuentran en el directorio por defecto del compilador
      • #include <funcion.h>
  • 32. Lenguaje C - Operadores
    • Operadores:
    • Son signos especiales que asocian variables y/o constantes para realizar una determinada operación
    • Operadores Aritméticos (+, -, *, /, %)
    • Operadores de Asignación (=, +=, -=, *=, /=)
    • Operadores Relacionales (==, <, >,<=, >=, !=)
    • Operadores Lógicos (&&, ||, !)
    • espacio = espacio_inicial + 0.5 * aceleracion * tiempo;
  • 33. Lenguaje C - Operadores
    • Operadores Aritméticos:
    • En C se utilizan cinco operadores aritméticos:
    • Suma: +
    • Resta: -
    • Multiplicación: *
    • División: /
    • Resto: %
    • Su sintaxis es:
    • <variable1> <operador> <variable2>
    Estos operadores se consideran binarios % (resto de la división entera) sólo se aplica a variables enteras
  • 34. Lenguaje C - Operadores
    • Operadores Aritméticos:
    • Incremento: ++
    • Decremento: --
    • Cambio de signo: -
    • Su sintaxis es:
    • <variable> <operador>
    • <operador> <variable>
    Estos operadores se consideran unarios
  • 35. Lenguaje C - Operadores
    • Aritméticos - Ejemplo:
    • /* Uso de los operadores aritméticos */
    • main( )
    • {
    • int a = 1, b = 2, c = 3, r1, r2;
    • r1 = a + b;
    • r2 = c - a;
    • b++;
    • }
  • 36. Lenguaje C - Operadores
    • Aritméticos - Ejemplo:
    • int i = 2, k = 4, m, n;
    • m = i++; // después de ejecutarse esta
    • // sentencia m = 2 e i = 3
    • n = ++k; // después de ejecutarse esta
    • // sentencia n = 5 y k = 5
  • 37. Lenguaje C - Operadores
    • Operadores de Asignación
    • Atribuyen a una variable -depositan en la zona de memoria correspondiente a dicha variable- el resultado de una expresión o el valor de otra variable
    • Operador de Igualdad:
    • nombre_variable = expresión;
    • a + b = c; // Esta asignación es incorrecto
    Se evalúa expresión y el resultado se copia en nombre_variable
  • 38. Lenguaje C - Operadores
    • Otros Operadores de Asignación:
    • variable op= expresion; // op = +, -, *, /, %
    • variable = variable op expresión;
    += Suma -= Resta *= Multiplicación /= División %= Resto (Módulo)
  • 39. Lenguaje C - Operadores
    • De Asignación - Ejemplo:
    • /* Uso de los operadores de asignación */
    • main( )
    • {
    • int a = 1, b = 2, c = 3;
    • float x = 1.3;
    • a += 5;
    • c -= 1;
    • b *= 3;
    • x *= 3.0 * b - 1.0;
    • }
  • 40. Lenguaje C - Operadores
    • Operadores Relacionales:
    • Permiten estudiar si se cumplen una o más condiciones.
    • Sintaxis:
    • expresion1 op expresion2
    Son operadores binarios Se evalúan expresion1 y expresion2 , y se comparan los valores resultantes. Si la condición representada por el operador relacional se cumple, el resultado es 1 ; en caso contrario será 0 > Mayor que < Menor que >= Mayor o igual que <= Menor o igual que == Igual que != Distinto que
  • 41. Lenguaje C - Operadores
    • Operadores Relacionales:
    • En el lenguaje natural, existen varias palabras o formas de indicar si se cumple o no una determinada condición:
    • (yes o no), (on off), (true, false)
    • E C 0 representa la condición false , y cualquier número distinto de 0 equivale a la condición true (por defecto 1 )
  • 42. Lenguaje C - Operadores
    • Relacionales - Ejemplo:
    • (2 == 1) // resultado = 0 porque la condición no se cumple
    • (3 <= 3) // resultado = 1 porque la condición se cumple
    • (3 < 3) // resultado = 0 porque la condición no se cumple
    • (1 != 1) // resultado = 0 porque la condición no se cumple
  • 43. Lenguaje C - Operadores
    • Operadores Lógicos:
    • Permiten combinar los resultados de los operadores relacionales, comprobando que se cumplen simultáneamente varias condiciones,
    • expresion1 op expresion2
    Son operadores binarios && AND || OR ! NOT
  • 44. Lenguaje C - Operadores
    • Lógicos - Ejemplo:
    • (2 == 1) || (-1 == -1)
    • (2 == 2) && (3 == -1)
    • ((2 == 2) && (3 == 3)) || (4 == 0)
    • ((6 == 6) || (8 == 0)) && ((5 == 5) && (3 == 2))
  • 45. Lenguaje C - Operadores
    • Jerarquía de Operadores
    Las operaciones con mayor precedencia se realizan antes que las de menor precedencia. Si en una operación encontramos signos del mismo nivel de precedencia, dicha operación se realiza de izquierda a derecha ( ) Mayor precedencia ++ -- * / % + - Menor precedencia
  • 46. Lenguaje C - Operadores
    • Jerarquía de Operadores
    Precedencia Asociatividad ( ) [ ] izda dcha ++ -- ! +(unario) -(unario) dcha a izda * / % izda dcha + - izda dcha < <= > >= izda dcha == != izda dcha && izda dcha || izda dcha = += -= *= /= dcha a izda
  • 47. Lenguaje C - Expresiones
    • Una expresión es una combinación de variables (constantes) y operadores.
    • Una expresión es equivalente al resultado que proporciona el aplicar sus operadores a sus operandos
    • Una expresión puede estar formada por otras expresiones más sencillas , y puede contener paréntesis de varios niveles agrupando distintos términos
  • 48. Lenguaje C - Expresiones Expresiones - Ejemplo:
  • 49. Salida y Entrada por Consola
    • Salida por Consola:
    • Función printf( )
    • Imprime en pantalla valores numéricos, constantes, caracteres o cadenas de texto. Su prototipo es:
    • int printf(&quot;cadena_de_control&quot;, arg1, arg2, ...)
    • int i = 1;
    • double tiempo = 20;
    • float masa = 25.67;
    • printf(&quot;Resultado %d: tiempo= %lf - Masa = %f &quot;, i, tiempo, masa);
    imprime el texto contenido en cadena_de_control junto con el valor de los otros argumentos, de acuerdo con los formatos incluidos en cadena_de_control . arg1 comienza con % y termina con el carácter de conversión
  • 50. Salida y Entrada por Consola
    • Salida por Consola:
    • Función printf( ): Caracteres de Conversión
    %c Un ú nico car á cter %d, i% Un entero con signo, en base decimal %u Un entero sin signo, en base decimal %o Un entero en base octal %x, %X Un entero en base hexadecimal %e, %g Un n ú mero real en coma flotante, con exponente %f Un n ú mero real en coma flotante, sin exponente %s Una cadena de caracteres %p Un puntero o direcci ó n de memoria
  • 51. Salida y Entrada por Consola
    • Función printf( ):
    • Entre el signo de % y el carácter de conversión pueden haber uno o más elementos:
    • % [signo] [longitud] [.precisión] [l/L] conversión
      • Un signo (-), que indica alineamiento por la izquierda
      • Un número entero positivo, que indica la anchura mínima del campo en caracteres
  • 52. Salida y Entrada por Consola
    • Función printf( ):
    • % [signo] [longitud] [.precisión] [l/L] conversión
      • Un punto (.), que separa la anchura de la precisión
      • Un número entero positivo, la precisión , nº máximo de caracteres a imprimir en una cadena, el nº de decimales de un float o double
      • Un cualificador : una (h) para short o una (l) para long y double.
  • 53. Entrada y Salida por Consola
    • Entrada por Consola:
    • Función scanf( )
    • Permite leer datos de la entrada estándar (teclado). Su prototipo es:
    • int scanf(“cadena_de_control&quot;, &arg1, &arg2, ...);
    • int n;
    • double distancia;
    • char nombre[20];
    • scanf(&quot;%d%lf%s&quot;, &n, &distancia, nombre);
    Caracteres de conversión &arg1: representa la posición de memoria en la que se encuentra la variable arg
  • 54. Salida y Entrada por Consola
    • Entrada por Consola:
    • Función scanf( ): Caracteres de Conversión
    %c Un ú nico car á cter %d, i% Un entero con signo, en base decimal %u Un entero sin signo, en base decimal %o Un entero en base octal %x, %X Un entero en base hexadecimal %e, %E, %f, %g, %G Un n ú mero real en coma flotante, con exponente %s Una cadena de caracteres h, l Para short, long y double L Para long double
  • 55. Salida y Entrada por Consola
    • Función scanf( ) - Ejemplo:
    • #include <stdio.h>
    • main( )
    • {
    • char nombre[15];
    • int edad;
    • printf(&quot;Introduce tu nombre: &quot;);
    • scanf(&quot;%s&quot;,nombre);
    • printf(&quot;Introduce tu edad: &quot;);
    • scanf(&quot;%d&quot;,&edad);
    • }
  • 56. Salida y Entrada por Consola
    • Entrada por Consola:
    • Función scanf( )
    • En la cadena de control de scanf() pueden introducirse corchetes [] para detectar ciertos caracteres
    • char s[30];
    • scanf(&quot;%[AB ]&quot;, s); /* Lee sólo los caracteres indicados */
    • scanf(&quot; %[^ ]&quot;, s); /* Lee todos los caracteres distintos a */
  • 57. Salida y Entrada por Consola
    • Funciones putchar( ) y getchar( )
    • Permiten respectivamente imprimir y leer un sólo carácter cada vez, en la salida o entrada estándar
    • Prototipos:
    • int putchar(int ch);
    • int getchar(void);
    • putchar( 'a' ); /* Escribe el carácter a . Equivale a printf(&quot;a&quot;); */
    • char c = getchar(); /* Lee un carácter y lo asigna a c .
    • Equivale a scanf(&quot;%c&quot;, &c); */
    Lo convierte en unsigned int Lee como unsigned int
  • 58. Salida y Entrada por Consola
    • Funciones putchar( ) y getchar( ) - Ejemplo:
      • main( ) main( )
      • { {
      • char ch; putchar( 'A' );
      • do putchar( ' ' );
      • { putchar( 'B' );
      • ch = getchar( ); }
      • putchar( '-' );
      • }while(ch != ' ' )
      • }
  • 59. Salida y Entrada por Consola
    • Funciones getche( ) y getch( ):
    • Proporciona entrada interactiva de caracteres
    • Prototipos: int getche(void);
    • int getch(void);
    • Funciones gets( ) y puts( ):
    • char *gets(char *str); /* Lee caracteres de la entrada estándar hasta que se introduce retorno de carro */
    • int puts(char*str); /* Muestra en pantalla la cadena a la
    • que apunta str */
    Lee como unsigned int y lo transforma en int Utilizan el archivo de cabecera conio.h
  • 60. Salida y Entrada por Consola
    • Funciones getche( ) y getch( ) - Ejemplo:
          • #include <stdio.h>
          • #include <conio.h>
          • #include <ctype.h>
          • void main()
          • {
          • char ch;
          • do
          • {
          • ch = getch( );
          • putchar(toupper(ch));
          • }while(ch != 'q' );
          • }
  • 61. Salida y Entrada por Consola
    • Funciones gets( ) y puts( ) - Ejemplo:
    • #include <stdio.h> #include <stdio.h>
    • void main( ) void main( )
    • { {
    • char *p, str[80]; puts(“uno”);
    • printf(“Introduzca una cadena: ”); puts(“dos”);
    • p = gets(str); puts(“tres”);
    • if(p) /* si no es nulo*/ }
    • printf(“p: %s cadena: %s”, p, str);
    • }
  • 62. Estructuras Condicionales
    • Permiten variar el flujo del programa de acuerdo a la evaluación de ciertas condiciones
    • Estructura IF
    • if (condición)
    • sentencia;
    • Estructura IF … ELSE
    • if (condición)
    • sentencia1;
    • else
    • sentencia2;
    La sentencia se ejecuta sólo si se cumple la condición Si se cumple la condición se ejecuta sentencia1 , en caso contrario se ejecuta sentencia2
  • 63. Estructuras Condicionales
    • Estructura IF … ELSE - Ejemplo:
        • #include <stdio.h>
        • main()
        • {
        • int usuario, clave = 18276;
        • printf(&quot;Introduce tu clave: &quot;);
        • scanf(&quot;%d&quot;,&usuario);
        • if (usuario == clave)
        • printf(&quot;Acceso permitido&quot;);
        • else
        • printf(&quot;Acceso denegado&quot;);
        • }
  • 64. Estructuras Condicionales
    • Estructura IF … ELSE - Múltiples:
        • if (condición)
        • sentencia1;
        • else if (condición)
        • sentencia2;
        • else if (condición)
        • sentencia3;
        • else
        • sentencia4;
    Si una condición se cumple, se ejecuta la sentencia correspondiente y salta hasta el final de la estructura para continuar con el programa Es posible utilizar llaves para ejecutar más de una sentencia si se cumple una condición Realiza una ramificación múltiple, ejecutando una entre varias partes del programa según se cumpla una entre n condiciones
  • 65. Estructuras Condicionales
    • Estructura IF … ELSE - Múltiples - Ejemplo:
        • main( )
        • {
        • float monto;
        • printf(“Indique el monto total de la compra: &quot;);
        • scanf(&quot;%f&quot;, &monto);
        • if (monto < 10000)
        • printf(&quot;Lo siento, no tiene descuento.&quot;);
        • else if (monto < 20000)
        • printf(“ Descuento de 5%&quot;);
        • else if (monto < 30000)
        • printf(“Descuento de 10%&quot;);
        • else
        • printf(“Descuento de 20%&quot;);
        • }
  • 66. Estructuras Condicionales
    • Estructura IF Anidadas:
    • Una sentencia if puede incluir otros if dentro de la parte correspondiente a su sentencia , A estas sentencias se les llama sentencias anidadas
          • if (a >= b) if (a >= b)
          • if (b != 0.0) if (b != 0.0)
          • c = a/b; c = a/b;
          • else
          • c = 0.0;
    Regla: Un else pertenece al if más cercano if (a >= b) { if (b != 0.0) c = a/b; } else c = 0.0;
  • 67. Estructuras Condicionales
    • Sentencia SWITCH
    • switch (expresion)
    • {
    • case expresion_cte_1:
    • sentencias;
    • break;
    • case expresion_cte_2:
    • sentencias;
    • break;
    • default:
    • sentencias;
    • }
    Cada case puede incluir una o más sentencias sin necesidad de ir entre llaves, se ejecutan todas hasta que se encuentra la sentencia break La constante evaluada sólo puede ser de tipo entero o carácter default ejecutará sus sentencias en caso de que la opción seleccionada no corresponda a ningún case
  • 68. Expresiones Condicionales
    • Sentencia SWITCH - Variaciones:
    • switch (expresion) {
    • case expresion_cte_1:
    • sentencia_1;
    • break;
    • case expresion_cte_2: case expresion_cte_3:
    • sentencia_2;
    • break;
    • default:
    • sentencia_3;
    • }
    • Sentencia SWITCH - Variaciones:
    • switch (expresion)
    • {
    • case expresion_cte_1:
    • sentencia_1;
    • case expresion_cte_2:
    • sentencia_2;
    • ...
    • case expresion_cte_n:
    • sentencia_n;
    • default:
    • sentencia;
    • }
  • 69. Estructuras Condicionales
    • Sentecia SWITCH - Ejemplo:
          • #include <stdio.h>
          • main( )
          • {
          • int dia;
          • printf(&quot;Introduce el día: &quot;);
          • scanf(&quot;%d&quot;, &dia);
          • switch(dia)
          • {
          • case 1: printf(&quot; Lunes &quot;); break;
          • case 2: printf(&quot; Martes &quot;); break;
          • case 6: printf(&quot; Sábado &quot;); break;
          • case 7: printf(&quot;Domingo&quot;); break;
          • default: printf(“Día incorrecto ”); break;
          • }
          • }
  • 70. Estructuras Cíclicas
    • Estructura WHILE
    • Su sintaxis es:
    • while (condición)
    • sentencia;
    • Con esta sentencia se controla la condición antes de entrar en el bucle
    Si en el interior del bucle hay más de una sentencia, deberán ir entre llaves para que se ejecuten como un bloque Si la condición se cumple entra al ciclo
  • 71. Estructura Cíclicas
    • Estructura WHILE - Ejemplo:
            • #include <stdio.h>
            • main()
            • {
            • int numero = 1;
            • while(numero<=10)
            • {
            • printf(&quot;%d &quot;,numero);
            • numero++;
            • }
            • }
  • 72. Estructuras Cíclicas
    • Estructura DO … WHILE
    • Su sintaxis es:
    • do{
    • sentencia1;
    • sentencia2;
    • }while (condición);
    • Con esta sentencia se controla la condición al final del bucle 
    Si la condición se cumple, el programa vuelve a ejecutar las sentencias del bucle DO … WHILE ejecutará el bucle por lo menos una vez
  • 73. Estructuras Cíclicas
    • Estructura FOR
    • Su sintaxis es:
    • for (inicialización; condición; actualización)
    • {
    • sentencia1;
    • sentencia2;
    • }
    • for (a=1, b=100; a!=b; a++, b- -)
    La inicialización indica una variable que condiciona la repetición del bucle Si existe más de una variable de inicialización, se separan por comas incremento decremento
  • 74. Estructuras Cíclicas
    • Estructura FOR
    • El flujo del bucle FOR transcurre de la siguiente forma:
  • 75. Estructuras Cíclicas
    • Estructura FOR
    • La construcción WHILE equivalente al FOR es:
            • inicialización;
            • while (condición)
            • {
            • sentencia;
            • actualización;
            • }
  • 76. Estructuras Cíclicas
    • Estructura FOR
    • Es posible dejar una expresión vacía en el bucle FOR:
    • #include<stdio.h>
    • main()
    • {
    • int i;
    • printf(“Introduzca un entero: ”);
    • scanf(“%d”, &i);
    • for(; i; i--)
    • printf(“%d”, i);
    • }
  • 77. Estructuras Cíclicas
    • Estructura FOR
    • C permite sentencias nulas:
            • #include<stdio.h>
            • #include<conio.h>
            • main()
            • {
            • char ch;
            • for (ch = getche(); ch != ‘q’; ch = getche());
            • printf (“ Encontrada la q ”);
            • }
    El objetivo del for está vacío
  • 78. Estructuras Cíclicas
    • Estructura FOR
    • Es posible alterar el valor de la variable de control del ciclo FOR fuera de la sección de actualización:
            • int i;
            • for (i = 0; i<10;)
            • {
            • printf(“%d”, i);
            • i++;
    • }
    • Utilizando FOR es posible crear un ciclo infinito:
    • for ( ; ;)
  • 79. Estructuras Cíclicas
    • Estructura FOR - Ejemplo:
        • #include <stdio.h>
        • main()
        • {
        • int num, x, result;
        • printf(&quot;Introduce un número entero: &quot;); scanf(&quot;%d&quot;,&num);
        • for (x=0; x<=10; x++)
        • {
        • result=num*x;
        • printf(&quot; %d por %d = %d &quot;, num, x, result);
        • }
        • }
  • 80. Arreglos
    • Un arreglo es un identificador que referencia un conjunto de datos del mismo tipo
    • . . .
    • 0 1 2 n-2 n-1 n
    • En C los arreglos comienzan por la posición 0
    • El acceso es directo, a través de un índice, que representa un valor entero y positivo
  • 81. Arreglos Unidimensionales
    • Vectores: Sólo utilizan un índice para referenciar cada uno de los elementos
    • Su declaración se realiza así:
    • tipo nombre [tamaño];
    Indica la cantidad de elementos del vector Cualquiera de los tipos primitivos, o un tipo definido por el usuario
  • 82. Arreglos Unidimensionales
    • Vectores - Ejemplo:
    • #include <stdio.h>
    • main()
    • {
    • int vector[10], i;
    • for (i=0; i<10; i++)
    • vector[i] = i*i;
    • for (i=0; i<10; i++)
    • printf(&quot; %d&quot;, vector[i]);
    • }
  • 83. Arreglos Unidimensionales
    • Un vector puede inicializarse al momento de su declaración:
    • tipo nombre[ ] = { valor1, valor2, ... }
    • Ejemplos:
    • int vector[ ] = {1, 2, 3, 4, 5, 6, 7, 8};
    • char vector[ ] = &quot;programador&quot;;
    • char vector[ ] = {'p', 'r', 'o', 'g', 'r', 'a', 'm', 'a', 'd', 'o', 'r'};
    No es necesario especificar el tamaño
  • 84. Arreglos Unidimensionales
    • Vectores:
    • C no realiza ninguna comprobación de los límites de los arreglos
    • Ejemplo:
    • int A[5]; /* A[0], A[1], …, A[4] elemento válidos*/
    • A[8] = 25; /* A[8] elemento inexistente*/
  • 85. Arreglos Unidimensionales
    • Vectores:
    • En C no se puede asignar un arreglo completo a otro en una sola sentencia.
    • char A[10], B[10];
    • .
    • .
    • .
    • B = A; /* Esto no se puede hacer */
    Para hacerlo correctamente debe copiarse elemento por elemento, cada uno por separado
  • 86. Arreglos Unidimensionales
    • Cadenas:
    • Una cadena se define como un arreglo unidimensional de caracteres, con un carácter de terminación nulo ‘’
    • char cad[80];
    • int i;
    • printf(“Introduzca una cadena: ”);
    • gets(cad);
    • for(i=0; cad[i]; i++)
    • printf(“%c”, cad[i]);
  • 87. Arreglos Unidimensionales
    • Cadenas:
    • La biblioteca estándar de C suministra funciones para el manejo de cadenas. Entre las más importantes están:
    • strcpy(), strcat(), strcmp() y strlen()
    Estas funciones requieren el archivo de cabecera string.h
  • 88. Arreglos Unidimensionales
    • Cadenas:
    • strcpy(destino, origen);
    • Copia la cadena origen en destino
    • char str[20];
    • strcpy(str, “hola”);
    • printf(str);
    Copia la cadena “hola” en str strcpy() no realiza comprobación de límites
  • 89. Arreglos Unidimensionales
    • Cadenas:
    • strcat(uno, dos);
    • Concatena la cadena dos a uno.
    • char str[20];
    • strcpy(str, “Buenos”);
    • strcat(str, “Dias”);
    • printf(str);
    No realiza comprobación de límites
  • 90. Arreglos Unidimensionales
    • Cadenas:
    • strcmp(cad1, cad2);
    • Compara las cadenas cad1 y cad2 .
    • Devuelve un valor negativo si cad1 es menor que cad2, y un valor positivo si cad1 es mayor que cad2.
    Devuelve cero si las cadenas son iguales Las cadenas se comparan por orden lexicográfico
  • 91. Arreglos Unidimensionales
    • Cadenas:
    • strlen(str);
    • Devuelve la longitud en caracteres de la cadena str
    • char cadena[] = “programador”;
    • int longi = strlen(cadena);
    • printf(“%d”, longi);
    No toma en cuenta el carácter de terminación nulo
  • 92. Arreglos Multidimensionales
    • Matrices: Representan un arreglo de dos o más dimensiones.
    • Su declaración se realiza así:
    • tipo nombre [tamaño 1][tamaño 2] ... ;
    • Una matriz bidimensional, se podría representar gráficamente como una tabla con filas y columnas
  • 93. Arreglos Multidimensionales
    • Matrices
    • Una matriz también puede ser inicializada al momento de su declaración
    • int numeros[4][3]={1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
    • numeros[0][0]=1 numeros[0][1]=2 numeros[0][2]=3
    • numeros[1][0]=4 numeros[1][1]=5 numeros[1][2]=6 numeros[2][0]=7 numeros[2][1]=8 numeros[2][2]=9
    • numeros[3][0]=10 numeros[3][1]=11 numeros[3][2]=12
  • 94. Arreglos Multidimensionales
    • Matrices:
    • También se pueden inicializar cadenas de texto:
    • char dias[7][10] = { &quot;lunes&quot;, &quot;martes&quot;, …, &quot;viernes&quot;,
    • &quot;sábado&quot;, &quot;domingo&quot; };
    • Para referenciar cada palabra basta con el primer índice:
    • printf(&quot;%s&quot;, dias[i]);
  • 95. Arreglos Multidimensionales
    • Cadenas:
    • C permite crear una tabla de cadenas bidimensional
    • char nombres[10][40];
    • gets(nombres[2]); /* Para leer una cadena */
    • printf(nombres[4]); /* Para mostrar una cadena */
    Especifica una tabla que puede contener 10 cadenas , cada una de hasta 40 caracteres Para acceder a una cadena sólo debe especificarse el primer índice
  • 96. Registros
    • Un registro es un conjunto de una o más variables, del mismo tipo de dato o diferente, agrupadas bajo un mismo nombre
    • La sintaxis de su declaración es la siguiente:
    • struct tipo_estructura
    • {
    • tipo variable1;
    • tipo variable2;
    • tipo variable3;
    • };
    Nombre del nuevo tipo Variables del registro
  • 97. Registros
    • Definición de variables tipo registro:
    • struct trabajador
    • {
    • char nombre[20];
    • char apellidos[40];
    • int edad;
    • char puesto[10];
    • };
    • struct trabajador fijo, temporal;
    Definición de las variables fijo y temporal
  • 98. Registros
    • Definición de variables tipo registro:
    • struct trabajador
    • {
    • char nombre[20];
    • char apellidos[40];
    • int edad;
    • char puesto[10];
    • } fijo, temporal;
    Definición de las variables fijo y temporal
  • 99. Registros
    • Declaración e inicialización de registros:
    • struct estudiante
    • {
    • char nombre[20];
    • int edad;
    • };
    • struct estudiante est1;
    • est1.nombre = “Victor”;
    • est1.edad = 24;
    Los registros deben declararse antes de la función principal Inicialización de registros
  • 100. Registros
    • Inicialización de registros:
    • struct trabajador fijo = {&quot;Pedro&quot;, &quot;Hernández Suárez&quot;, 32, &quot;gerente&quot;};
    • struct notas
    • {
    • char nombre[30];
    • int notas[3];
    • };
    • struct notas alumno = {&quot;Carlos Pérez&quot;, {9, 6, 10} };
    Si uno de los campos es un arreglo de números, los valores de la inicialización deberán ir entre llaves
  • 101. Arreglos de Registros
    • Es posible agrupar un conjunto de elementos de tipo registro en un arreglo:
    • struct trabajador
    • {
    • char nombre[20];
    • char apellidos[40];
    • int edad;
    • };
    • struct trabajador fijo[20];
    Aquí podremos almacenar los datos de hasta 20 trabajadores
  • 102. Arreglo de Registros
    • Acceso a los campos:
    • struct trabajador fijo[20];
    • fijo[3].nombre = “Maria”;
    • printf(“%s”, fijo[3].nombre);
    • struct trabajador fijo[20] = { {&quot;José&quot;, &quot;Herrero
    • Martínez&quot;, 29}, {&quot;Luis&quot;, &quot;García Sánchez&quot;, 46} };
    Declaración e inicialización
  • 103. Definición de Tipos
    • C dispone de una declaración llamada typedef que permite la creación de nuevos tipos de datos
    • typedef int entero;
    • entero a, b = 3;
    • struct trabajador
    • {
    • char nombre[20];
    • int edad;
    • };
    • typedef struct trabajador datos;
    • datos fijo, temporal;
    Creación del tipo de dato entero Creación del tipo de dato datos
  • 104. Funciones
    • Las funciones son bloques de código utilizados para dividir un programa en partes más pequeñas, cada una con una tarea determinada
    • Su sintaxis es:
    • tipo nombre_función (lista_de_parámetros)
    • {
    • bloque de sentencias
    • }
    tipo especifica el tipo de valor que devuelve la función conjunto de sentencias que serán ejecutadas cuando se realice la llamada a la función
  • 105. Funciones
    • Tipo de una Función:
    • Una función puede devolver cualquier tipo de datos, excepto un array
    • El tipo de dato por defecto de un función es int
    • Si una función no devuelve ningún valor puede declararse void
    • double volumen (double s1, double s2, double s3)
    • {
    • return s1 * s2 * s3;
    • }
  • 106. Funciones
    • Funciones - Ejemplo:
    • #include<stdio.h>
    • #include<math.h>
    • void main()
    • {
    • float answer, numero:
    • printf(“Introduzca un numero real: ”);
    • scanf(“%f”, &numero);
    • answer = sqrt(numero);
    • printf(“La raiz cuadrada de %.2f es: %.2f”, numero, answer);
    • }
  • 107. Funciones
    • Lista de Parámetros de una Función:
    • Parámetros Formales: Lista de declaraciones de variables, con su tipo correspondiente, que aparece en la declaración de la función
    • Parámetros Actuales: Lista de variables que recibe la función al momento de su llamada (se corresponden a los parámetros formales)
    Existen funciones que no reciben argumentos
  • 108. Funciones
    • Prototipos de una Función:
    • Para informar al compilador sobre el valor de retorno de una función, ésta debe declararse utilizando un prototipo
    • La forma general de definición de un prototipo es:
    • tipo nombre_función (tipo param1, tipo param2, …, tipo nombre_paramN)
    Un prototipo permite al compilador validar la cantidad de parámetros y la correspondencia de tipos en los argumentos
  • 109. Funciones
    • Prototipos - Ejemplo:
    • double volumen (double s1, double s2, double s3)
    • int obtenerNumero(void);
    Prototipo de una función sin parámetros Prototipo de una función con parámetros La declaración de los prototipos suele hacerse al comienzo del fichero, después de los #include y #define
  • 110. Funciones
    • Llamada a una Función:
    • Es llamada incluyendo su nombre seguido de los argumentos actuales en una expresión aritmética o de otro tipo
    • a = d * sin(alpha) / 2.0;
    • Es llamada mediante una sentencia que contiene el nombre de la función seguido por los argumentos actuales entre paréntesis, finaliza con un carácter (;)
    • productoMatriz(n, A, B, C);
    La función calcula un valor de retorno a partir de uno o más argumentos No existe valor de retorno
  • 111. Funciones
    • Paso de Parámetros a una Función:
    • Llamada por Valor
    • Copia el valor de un argumento en el parámetro formal de la función
    • Los cambios hechos en los parámetros de la función no tienen efecto sobre que se utilizan para llamarla
    C utiliza por defecto la llamada por valor para pasar argumentos
  • 112. Funciones
    • Paso de Parámetros a una Función:
    • Llamada por Referencia:
    • Se copia la dirección de un argumento en el parámetro formal de la función
    • Los cambios hechos en el parámetro afectarán a la variable utilizada para llamara a la función
    Para hacer esta llamada debe pasarse un puntero a un argumento
  • 113. Funciones
    • Llamada por Referencia - Ejemplo:
    • void intercambia (int *x, int *y)
    • {
    • int temp;
    • temp = *x;
    • *x = *y;
    • *y = temp;
    • }
  • 114. Funciones
    • Llamada por referencia - Ejemplo:
    • #include<stdio.h>
    • void intercambia (int *x, int *y)
    • ………… ..
    • main()
    • {
    • int num1, num2;
    • num1 = 100;
    • num2 = 200;
    • printf(“num1 es: %d y num2 es: %d ”, num1, num2);
    • intercambia(&num1, &num2);
    • printf(“num1 es: %d y num2 es: %d ”, num1, num2);
    • }
  • 115. Definición de Archivos
    • Definición de Archivo:
    • Un archivo o fichero informático es una entidad lógica compuesta por una secuencia finita de bytes, almacenada en un sistema de archivos ubicada en la memoria secundaria del computador e identificados por un nombre único
  • 116. Manejo de Archivos
    • Definición de Archivo:
    • Un archivo es un conjunto de datos estructurados en una colección de entidades elementales denominadas registros que son de igual tipo y constan a su vez de diferentes entidades de nivel más bajo denominadas campos
    Colecciones de datos almacenados en memoria secundaria
  • 117. Manejo de Archivos
    • Tipos de Archivo:
    • De Texto: Secuencia de caracteres organizadas en líneas terminadas por un carácter de nueva línea. Se caracterizan por ser planos, es decir, todas las letras tienen el mismo formato y no hay palabras subrayadas, en negrita, o letras de distinto tamaño o ancho
    • En estos archivos se pueden almacenar canciones, fuentes de programas, base de datos simples
  • 118. Manejo de Archivos
    • Tipos de Archivo:
    • Binarios: Secuencia de bytes que tienen una correspondencia uno a uno con un dispositivo externo. El número de bytes escritos (leídos) será el mismo que los encontrados en el dispositivo externo
    • Ejemplo de estos archivos son fotografías, imágenes, texto con formatos y archivos ejecutables (aplicaciones)
  • 119. Manejo de Archivos
    • Apertura de Archivos:
    • Antes de abrir un fichero es necesario declarar un puntero de tipo FILE
    • Para abrir el fichero se utiliza la función fopen( )
    • Su sintaxis es:
    • FILE *p;
    • p = fopen (nombre-fichero,&quot;modo-apertura&quot;);
    Debe ir entre comillas. Es posible especificar la ruta del archivo
  • 120. Manejo de Archivos
    • Modo Texto
    • w Crea un archivo de escritura.
    • Si ya existe lo crea de nuevo.
    • w+ Crea un archivo de lectura y escritura.
    • Si ya existe lo crea de nuevo.
    • a Abre o crea un archivo para añadir datos al final del mismo.
    • a+ Abre o crea un archivo para leer y añadir datos al final del mismo.
    • r Abre un archivo de lectura.
    • r+ Abre un archivo de lectura y escritura.
    Un archivo puede ser abierto en dos modos diferentes: modo texto o modo binario
  • 121. Manejo de Archivos
    • Modo Binario
    • wb Crea un archivo de escritura.
    • Si ya existe lo crea de nuevo.
    • w+b Crea un archivo de lectura y escritura.
    • Si ya existe lo crea de nuevo.
    • ab Abre o crea un archivo para añadir datos al final del mismo.
    • a+b Abre o crea un archivo para leer y añadir datos al final del mismo.
    • rb Abre un archivo de lectura.
    • r+b Abre un archivo de lectura y escritura.
    Un archivo puede ser abierto en dos modos diferentes: modo texto o modo binario
  • 122. Manejo de Archivos
    • Apertura de Archivos - Ejemplo:
    • FILE *puntero;
    • puntero = fopen(“datos.in&quot;,&quot;r&quot;);
    • puntero = fopen(&quot;C:rchivossaludo.txt&quot;,&quot;w&quot;);
    Abre el archivo en modo lectura Abre el archivo en modo escritura
  • 123. Manejo de Archivos
    • Apertura de Archivos:
    • Si se produce un error al intentar abrir un archivo la función fopen devolverá NULL
    • FILE *pf;
    • pf = fopen(&quot;datos.txt&quot;,&quot;r&quot;);
    • if (pf == NULL)
    • printf(&quot;Error al abrir el archivo&quot;);
    Es importante validar la apertura de archivos
  • 124. Manejo de Archivos
    • Función freopen( )
    • Cierra el archivo apuntado por el puntero y reasigna este puntero a un nuevo archivo que será abierto
    • Su sintaxis es:
    • freopen (nombre-archivo,&quot;modo-apertura&quot;, puntero);
    Puntero que será reasignado Puntero que será reasignado
  • 125. Manejo de Archivos
    • Cierre de Archivos:
    • Para cerrar un archivo se utiliza la función fclose( )
    • FILE *pf;
    • pf = fopen(“Alumnos.txt&quot;,&quot;r&quot;);
    • if ( pf == NULL )
    • printf (&quot;Error al abrir el archivo&quot;);
    • else
    • fclose(pf);
    el número de archivos que pueden estar abiertos es limitado Cierra el archivo asociado al puntero pf Si el archivo se cierra con éxito devuelve 0
  • 126. Escritura y Lectura de Archivos
    • fputc (variable-caracter, puntero-archivo);
    • FILE *pf;
    • char letra = ‘a’;
    • If ((pf = fopen(&quot;datos.txt&quot;,&quot;w&quot;)) == NULL) {
    • printf(&quot;Error al abrir el archivo&quot;);
    • exit(0);
    • }
    • else
    • {
    • fputc(letra,pf);
    • fclose(pf);
    • }
    Escribe el carácter letra en el archivo asociado al puntero pf
  • 127. Escritura y Lectura de Archivos
    • fgetc (puntero-archivo);
    • FILE *pf;
    • char letra;
    • if ((pf = fopen(&quot;datos.txt&quot;,&quot;r&quot;)) == NULL) {
    • printf(&quot;Error al abrir el archivo&quot;);
    • exit(0);
    • }
    • else
    • {
    • letra = fgetc(pf);
    • printf(&quot;%c&quot;,letra);
    • fclose(pf);
    • }
    Lee un carácter del archivo asociado al puntero pf y lo copia el letra
  • 128. Escritura y Lectura de Archivos
    • putw (variable-entera, puntero-archivo);
    • Escribe un número entero en formato binario en el archivo
    • getw (puntero-archivo);
    • Lee un número entero de un archivo, avanzando dos bytes después de cada lectura
  • 129. Escritura y Lectura de Archivos
    • putw( ) - Ejemplo:
    • FILE *pf;
    • int num=3;
    • if ((pf = fopen(&quot;datos.txt&quot;,&quot;wb&quot;)) == NULL) {
    • printf(&quot;Error al abrir el archivo&quot;);
    • exit(0);
    • }
    • else
    • {
    • putw(num,pf); /* Equivalente a putw(3,pf); */
    • fclose(pf);
    • }
  • 130. Escritura y Lectura de Archivos
    • getw( ) - Ejemplo:
    • FILE *pf;
    • int num;
    • if ((pf = fopen(&quot;datos.txt&quot;,&quot;rb&quot;)) == NULL) {
    • printf(&quot;Error al abrir el archivo&quot;);
    • exit(0);
    • }
    • else
    • {
    • num = getw(pf);
    • printf(&quot;%d&quot;,num);
    • fclose(pf);
    • }
  • 131. Escritura y Lectura de Archivos
    • char *fputs (char *str, FILE *f);
      • Escribe la cadena str en el archivo asociado al puntero f
    • char *fgets (char *str, int long, FILE *f);
      • Lee una cadena desde el archivo asociado al puntero f hasta que lee un carácter de nueva línea o long-1 caracteres.
  • 132. Escritura y Lectura de Archivos
    • fputs( ) - Ejemplo:
    • FILE *pf;
    • char cad []= “Aprendemos manejo de archivos en C&quot;;
    • if ((pf = fopen(&quot;datos.txt&quot;,&quot;w&quot;)) == NULL) {
    • printf(&quot;Error al abrir el archivo&quot;);
    • exit(0);
    • }
    • else
    • {
    • fputs(cad,pf);
    • fclose(pf);
    • }
    Escribe la cadena cad en el archivo asociado al puntero pf
  • 133. Escritura y Lectura de Archivo
    • fgets - Ejemplo:
    • FILE *pf;
    • char cad[80];
    • if ((pf = fopen(&quot;datos.txt&quot;,&quot;r&quot;)) == NULL) {
    • printf(&quot;Error al abrir el archivo&quot;);
    • exit(0);
    • }
    • else
    • {
    • fgets(cad,80,pf);
    • printf(&quot;%s&quot;,cad);
    • fclose(pf);
    • }
    Lee del archivo asociado a pf una cadena de longitud max 80-1 caracteres y la copia en cad
  • 134. Escritura y Lectura de Archivos
    • fprintf (puntero-archivo,formato, argumentos);
    • Escribe los argumentos en un archivo
    • fscanf (puntero-archivo, formato, argumentos);
    • Lee los argumentos desde un archivo. Al igual que un scanf( ) , es necesario indicar la dirección de memoria de los argumentos con el símbolo &
  • 135. Escritura y Lectura de Archivos
    • fprintf( ) - Ejemplo:
    • FILE *pf;
    • char nombre[20] = “Xiomara&quot;;
    • int edad = 49;
    • if (!(pf = fopen(&quot;datos.txt&quot;,&quot;w&quot;))) {
    • printf(&quot;Error al abrir el archivo&quot;);
    • exit(0);
    • }
    • else
    • {
    • fprintf(pf,“Nombre: %20s, Edad: %2d &quot;,nombre,edad);
    • fclose(pf);
    • }
  • 136. Escritura y Lectura de Archivos
    • fscanf( ) - Ejemplo:
    • FILE *pf;
    • char nombre[20];
    • int edad;
    • if (!(pf = fopen(&quot;datos.txt&quot;,&quot;r&quot;))) {
    • printf(&quot;Error al abrir el archivo&quot;);
    • exit(0);
    • }
    • else
    • {
    • fscanf(pf,“%20s%2d&quot;,nombre,&edad);
    • printf(&quot;Nombre: %s, Edad: %d&quot;, nombre, edad);
    • fclose(pf);
    • }
  • 137. Manejo de Archivos
    • rewind( )
    • Inicializa el indicador de posición, al principio del archivo. Su prototipo es: void rewind (FILE *F);
    • ferror()
    • Determina si se ha producido en error en una operación sobre un archivo. Su prototipo es: int ferror(FILE *F);
    • Devuelve cierto si se ha producido un error durante la ultima operación sobre el archivo. En caso contrario, devuelve falso
  • 138. Manejo de Archivos
    • remove( )
    • Borra el archivo especificado. Su prototipo es:
    • int remove(char *nombre-archivo);
    • Devuelve cero si tiene éxito. Si no un valor distinto de cero.