Lenguaje C Wor para Enviar A Ingirs Por Escrid

Republica Bolivariana de Venezuela Ministerio del P.P.
para la Educacin Universitaria Aldea Universitaria Ciudad Angostura Misin Sucre Ingeniera en Sistemas
Lenguaje de programacin C
Facilitadora: Prof. Ingris Manaure
Participante: Garca P. Jos R.
Ciudad Bolvar, 19 de Abril de 2012.
Elementos bsicos del lenguaje c

Temas Componentes Directivas Declaraciones globales Funciones Tipos de datos Estatuto de lectura y escritura
Elementos bsicos del lenguaje

Un programa en C++ est definido por funciones (grupo de instrucciones que pueden o no hacer algn clculo), donde la funcin principal debe ser llamada main. La composicin general de un programa en C++ es: directivas de preprocesamiento. declaracin globales. funcin main. funciones definidas por el usuario. comentarios para entender el funcionamiento del programa.
Componentes
Directivas Las directivas de preprocesamiento son definidas para que el compilador realice algo antes de compilar el programa (revisar si la sintaxis es correcta y generar un cdigo ejecutable por la computadora), como el incluir funciones de alguna biblioteca conocida Directivas En particular, en C la directiva para incluir bibliotecas es como las siguientes: Ejemplos: #include <iostream.h> Esta directiva permitir utilizar la funcin de lectura cin y la funcin de escritura cout propias de C++. #include <stdio.h> Esta directiva permitir utilizar las funciones de lectura y escritura propias de C. Directivas Estas directivas tambin funcionan con C++, aunque existen algunos compiladores que no las soportan en cuyo caso es necesario hacer uso de los namespaces. Un namespace es una declaracin de regin. El propsito de estos es localizar el nombre de identificadores para evitar colisiones.

Para tener compatibilidad, cuando un programa en C++ incluye una librera de C, haremos uso del namespace. Directivas Ejemplo: En C tenemos #include <iostream.h> Con el respectivo en C++ #include <iostream> using namespace std; Declaraciones Globales Las declaraciones globales son definiciones de variables o constantes que sern utilizadas por cualquiera de todas las funciones definidas en el programa. La sintaxis para la declaracin de una variable es: Tipo var1, var2,..., var3; o bien Tipo var1= valor, var2,..., var3; Funcin main La funcin main ( ), es obligatoria en cada programa C, C++. Indica el comienzo del programa y requiere los parntesis ( ) a continuacin de main ( ). Funciones definidas por el usuario La definicin de una funcin se realiza escribiendo primero el tipo del valor de retorno de la funcin, despus el nombre de la funcin, posteriormente entre parntesis las variables que utilizar dicha funcin (parmetros) y finalmente las instrucciones de la funcin. Ejemplos: double promedio( int a, int b, int c) { return (a + b + c ) / 3.0; } Declara a la funcin promedio, la cual recibe tres valores enteros y calcula y regresa el promedio de ellos. Comentarios Los comentarios pueden escribirse utilizando alguna de las siguientes formas: comentando en la misma lnea, utiliza //, ejemplo int edad; // la edad se utilizar como un valor entero. comentando entre varias lneas, utiliza /* */, ejemplo: /* La siguiente funcin promedio recibe tres valores enteros y calcula y regresa el promedio de los tres a travs de un valor real */ Tipos de Datos Los tipos de datos que maneja C++ son : Enteros Dentro de los enteros estn los tipos: short, int, long, los cuales varan en rango de acuerdo al compilador que se utilice, siendo long rango mayor y short el de menor. Flotantes Dentro de los flotantes C++ tiene los tipos: float, double y long double donde al igual que los enteros vara el rango de cada uno de acuerdo al compilador que se utilice. De igual forma el float es el de menor rango siendo long double el de rango mayor Tipos de Datos Caracteres
Se utiliza el tipo chart. Para representar un carcter en C++ se utilizan apstrofes. Ejemplos: a, b , 5 Para representar una cadena de caracteres se utilizan las comillas. Ejemplo: soy una cadena Estatuto de Lectura El archivo de cabecera iostream.h de la biblioteca de C++ proporciona un flujo de entrada estndar cin y un operador de extraccin >> , para extraer valores del flujo y almacenarlos en variables. Sintaxis del estatuto cin cin >> Lista de variables; donde Lista de variables puede ser una o ms variables separadas por >> Estatuto de Lectura Ejemplos: cin >> a >> b; // estamos esperando la entrada de dos valores del tipo // definido en la declaracin de a y b. cin >> num; // estamos esperando la entrada de un solo valor. cin >> Precio_venta // estamos esperando la entrada de un solo valor // del tipo definido en la declaracin de // Precio_venta. Estatuto de Escritura El archivo de cabecera iostream.h de la biblioteca de C++ proporciona un flujo de salida estndar cout y un operador de extraccin << , que normalmente se manda a la pantalla del usuario. Sintaxis del estatuto cout cout << Lista; donde Lista puede ser variables, valores constantes o expresiones separadas por << Estatuto de Escritura Ejemplos: cout << "Dame el numero "; // estamos desplegando el mensaje // en pantalla. cout << " El resultado es " << resul; // estamos desplegando el // mensaje y el valor de la // variable resul. Estatuto de Escritura Los operadores de extraccin e insercin, >> y <<, apuntan en la direccin del flujo de datos. Recordemos que para poder utilizar el estatuto cin y cout se requiere la directiva #include <iostream.h>. Existen caracteres especiales que pueden ser usados con el cout dentro de comillas. Entre ellos estn: n realiza un cambio de lnea equivalente a usar endl. t tabulador. a sonido de la campana. comilla doble. comilla simple. Estatuto de Escritura
Ejemplos: cout << "Nombre " << " " ; // despliega el mensaje Nombre, realiza un // tab ah quedar el cursor cout << "El resultado es " << resul << endl; // despliega el letrero, el // valor de la variable resul // y brinca a la siguiente // lnea donde quedara el // cursor. Temas Declaracin Reglas para nombre de variables Declaracin o definicin

La declaracin de una variable es un estatuto que proporciona informacin de la variable al compilador de C++. La sintaxis para la declaracin de una variable es: tipo variable tipo.- es el nombre de un tipo de dato conocido por C++. variable.- es un identificador (nombre) vlido en C++.
Declaracin
Reglas para nombre de variables Deben empezar con letra o underscore Pueden contener letras, nmeros y underscore Las letra maysculas y minsculas son diferentes para C++ Reglas para nombre de variables Es importante declarar las variables antes de utilizarlas. Se puede declarar una variable en dos lugares dentro de un programa: a). Al principio de un archivo o bloque de cdigo. b). En el punto de utilizacin. Las variables se pueden inicializar a la vez que se declaran, o bien, inicializarse despus de la declaracin. El primer mtodo es probablemente el mejor, ya que se combina la definicin de la variable con la asignacin de su valor inicial. Declaracin o definicin La diferencia entre declaracin y definicin es sutil. Una declaracin introduce un nombre de un objeto o de una variable y asocia un tipo con la variable/objeto. Una definicin es una declaracin que asigna simultneamente memoria al objeto/variable. Declaracin o definicin Ejemplos: int x; // declara el nombre de la variable x de tipo entero.
chart var; // declara var de tipo carcter. int i; // declara el nombre de la variable i de tipo entero. int i = 0; // define i inicializa la variable i entera a cero. Declaracin o definicin Ejemplos: int edad; Esta declaracin indica que la variable edad definida como un valor entero puede ser utilizada en cualquier funcin. double venta = 0.0; Esta declaracin presenta la declaracin de una variable como valor doble a la cual se le da un valor inicial y puede ser usada en cualesquier funcin. char nombre[30]; Esta declaracin es para declarar una variable de tipo cadena de caracteres.

Tema Funciones definidas por el usuario
Elementos bsicos del Lenguaje

Un programa en C++ se forma por una coleccin de funciones. Todos los programas se construyen a partir de una o ms funciones que se integran para crear una aplicacin. Todas las funciones contienen uno o ms estatutos C++ y se crean generalmente para realizar una nica tarea.
Funciones definidas por el usuario
Funciones definidas por el usuario La definicin de una funcin se realiza escribiendo primero el tipo del valor de retorno de la funcin, despus el nombre de la funcin, posteriormente entre parntesis las variables que utilizar dicha funcin (parmetros) y finalmente las instrucciones de la funcin. Las funciones definidas por el usuario se invocan por su nombre y los parmetros opcionales que se puedan tener. Funciones definidas por el usuario Todas las funciones tienen nombre y una lista de valores que recibe. Se puede asignar cualquier nombre a la funcin, pero normalmente se procura que dicho nombre describa el propsito de la funcin. Una declaracin de funcin indica al compilador el nombre de la funcin que se est invocando en el programa. Si la funcin no se defina, el compilador informa de un error. Funciones definidas por el usuario Por ejemplo: double promedio( int a, int b, int c) { return (a + b + c ) / 3.0; } Declara a la funcin promedio, la cual recibe tres valores enteros y calcula y regresa el promedio de ellos. Funciones definidas por el usuario
int suma( int a, int b) { return (a + b); } Declara a la funcin suma, la cual recibe dos valores enteros y calcula y regresa la suma de ellos. Tema Funcin main

Todo programa C++ tiene una funcin main ( ) que es el punto inicial de entrada al programa. Su estructura es: main( ) { bloque de estatutos }
Funcin main Los estatutos incluidos entre las llaves {} se denominan bloque. Un programa puede tener slo una funcin main ( ). Si se intenta hacer dos funciones main ( ) se produce un error. Adems de la funcin main ( ), un programa en C++, consta de una coleccin de funciones. Funcin main Ejemplo: int main () { cout << " Funcin main desplegando un mensaje "; return 0; } Declara a la funcin principal main, no tendr parmetros,
ni regresar algn valo
Estructura general de un programa en C

/* Comentarios de un parrafo completo comprendidos entre /*.....*/, sirven para aclarar qu el programa o una parte del programa */ // Comentarios de 1 sola lnea // Zona de ficheros de cabecera de las libreras #include <....... . h> // h de Head
#include <....... . h> // Zona de prototipos de funciones int Potencia (int x,y) // Zona de variables globales int valor; float media_total; void main (void) // Prog. ppal. tpico de Turbo C { // llave de inicio del programa // codigo del programa ....... ....... ....... // fin del programa } // Desarrollo del cdigo de las funciones anteriore Modificadores de los tipos de datos bsicos Datos tipo enteros: unsigned: sin signo signed: con signo unsigned short: corto sin signo signed short: corto con signo unsigned long: largo sin signo signed long: largo Datos tipo carcter unsigned: sin signo signed: con signo
Datos tipo real double: doble signed: doble largo TIPOS ENTEROS CHAR (CARACTER) 1 BYTE RANGO: -128... 127 char 0...255 unsigned char EJEMPLO: char car; /* car es una variable de tipo char */ INT (ENTERO) RANGO PARA 16 BITS: -32768... 32767 int 0... 65535 unsigned int EJEMPLO: int x; /* x es de tipo entero */ SHORT (ENTERO CORTO) 2 BYTES RANGO: -32768... 32767 short 0... 65535 unsigned short EJEMPLO: short x,y; /* declara x e y como enteros cortos */ LONG (ENTERO LARGO) 4 BYTES RANGO: -2147483648... 2147483647 long 0... 4.294.967.295 unsigned long EJEMPLO: long var; /* var es de tipo long*/ ENUM (ENUMERACIN) Tipo ENUMERADO
LISTA DE VALORES REPRESENTADOS POR IDENTIFICADORES EJEMPLO : enum semana
{ lunes, martes, miercoles, jueves, viernes, sabado, domingo} ; enum semana ayer /* ayer es un tipo enumerado semana * / /* lunes toma el valor 0 y domingo el valor 6* /
TIPO REAL FLOAT (REALES EN SIMPLE PRECISION) 4 BYTES RANGO: -3.402823E+38.....-1.40129E45 negativos 1.401293E-45 ... 3.40282E38 positivos -3E+38.....-14E45 14E-45.....3E38 EJEMPLO: float x; /* x es un real */ DOUBLE (REALES EN DOBLE PRECISION) 8 BYTES RANGO: -1.79769313316E308.......4.94065E-324 negativos 4.94065E-324... 1.797334862316E308 positivos EJEMPLO: double x; /* x es un real en doble precisin * /Metodologa de Programacin, Programacin en C, Aplicaciones electrnicas 6 / 6 ARRAYS CONJUNTO DE ELEMENTOS DEL MISMO TIPO EJEMPLO: char a[40]; VOID SE UTILIZA PARA DECLARAR FUNCIONES QUE NO RETORNAN NINGUN VALOR 0 NO ACEPTAN PARAMETROS . EJEMPLO: void f (int a); CONST INDICA QUE EL VALOR DE UN IDENTIFICADOR NO PUEDE /* la funcin no retorna valores */ /* 40 caracteres del 0 al 39 */
SER MODIFICADO OPERADORES ESPECIALES X ++ INCREMENTO DE LA VARIABLE X EN 1 X -- DECREMENTO DE LA VARIABLE X EN 1 ENTRADA - SALIDA ESTANDAR Con este epgrafe nos referimos a las funciones estndar de C para realizar entrada de datos por teclado y salida de datos hacia pantalla. Son funciones definidas en la librera estndar. Para usarlas es necesario incluir el fichero de cabecera de las funciones : #include <stdio.h> Estas funciones son: printf( ) Salida de datos con formato scanf( ) Entrada de datos con formato getchar( ) Entrada de caracteres. 1 caracter putchar( ) Salida de caracteres. 1 caracter fflush( ) Borrado del buffer del teclado. funcion printf ( ) Escribe una serie de caracteres en la salida estndar (pantalla). Prototipo int printf (conts char *formato [,argumentoJ...); Devuelve Nmero de caracteres escritos. Parmetros Formato: Cadena de caracteres, entre comillas dobles, que especifica cmo va a ser la salida. Incluye caracteres y especificaciones de formato.
Argumento: Indica las variables a escribir. Ejemplo: float pi=3.141596; // declara y asigna a la vez printf("El nmero pi vale %f ,pi); ^- carcter de control %f Especificaciones de formato: % [ancho] [.precision] ancho: Mnimo nmero de posiciones reservadas para la salida. precisin: Mnimo nmero de posiciones reservadas para la parte decimal. Caracteres de control en funcin del tipo Cuando necesitamos especificar el valor de una variable dentro de una instruccin printf debemos poner un carcter de control que indica qu tipo de dato va en esa posicion: control %d % %x %f %e % % \ \t Tipo asociado int enteros con signo base 10 unsigned int enteros sin signo base 10 int base 16 float float char formato eee.ddd formato xxxEee caracteres
string cadena de caracteres salto de lnea tabulador a la derecha
\a h
beeep ! sort
l L
long double
Modificadores
funcion scanf ( ) Lee datos de la entrada estndar (teclado) , los interperta y los almacena en los argumentos. Incluye caracteres y especificaciones de formato. Prototipo int scanf (conts char *formato [,argumento]...); Devuelve: El nmero de datos ledos. Si es cero indica que no han sido asignados datos. Parmetros Formato: Cadena de caracteres, entre comillas dobles, que especifica cmo van a ser introducidos los datos. Segn se especifique en el formato, as debern ser introducidos los datos. Argumento: Indica las direcciones de variables que almacenarn los datos (&). int a; float b; char c;
Sentencia datos scanf(%d %f %c" , &a, &b , &c) ; scanf("%d, %f , %c",&a,&b,&c); scanf("%d : %f : %c",&a,&b,&c);
Entrada de 5 2.3 b 5 , 23.4 , b 5 : 23.4 : b
a Direccin de memoria de la variable a
Ejemplo: #include <stdio.h> void main (void) { int a,r; // declaramos dos enteros float b; //declaramos un real char c, s[20]; // declaramos un carcter y una cadena printf (Introducir un entero, un real y un carcter : \n); r=scanf (%d %f %c, &a, &b, &c); printf (N de datos leidos: %d,r); printf (Datos leidos: %d %f %c,a,b,c); } Lectura de cadenas #include <stdio.h> void main(void) { char nombre[20], apellido[20]; printf (Introduce el nombre: ); scanf (%s, nombre); //solo lee hasta el primer espacio en blanco // en una matriz ya pasamos la direccion fflush (stdin); printf (\nApellidos: ); scanf ( ,apellidos);
printf (\n\nNombre y Apellidos: %s %s ,nombre,apellidos); }
funcion getchar ( ) Lee un caracter de la entrada estandar . Prototipo: int getchar(void); Devuelve: El caracter leido o un EOF si se detecta el fin de fichero. funcion putchar ( ) Escribe un caracter en la salida estandar . Prototipo int putchar(int c ); //recordar que un carcter es como un entero de 0..255 Devuelve El caracter escrito o EOF si ocurre un error. Parametros c caracter a imprimir. funcion fflush (stdin) Borra el buffer del teclado. #include <stdio.h> void main(void) { char carcter; printf ( Introduce caracteres y finalizar con Ctrl+Z (EOF)); carcter=getchar(); while (carcter != EOF) { putchar(carcter); carcter=getchar(); } } _________________________________________________________
OPERADORES RELACIONALES Son los siguientes : < Menor que... < = Menor o igual que... = = Igual que... > Mayor que... >= Mayor o igual que... != Distinto (no igual) Resultado: cierto ( * ) o falso (0).
^--- cualquier valor >1 #include < stdio,h > void main(void) { int cierto, falso; cierto = ( 12 < 22); falso = ( 2 > 4) ; printf("\n Cierto = %d, falso = %d", cierto, falso); } Estructuras de control Seleccin incompleta if ( condicin ) { ..., ..., } if ( condicin ) sentencia; if ( pepe > 0) printf("\n PEPE es positivo "); if ( pepe ! = 0) { pepe = 0; if <condicion> accion
printf("\n El valor es %f", pepe); } if (pepe ) { ... Seleccin completa else accion2 Elige entre dos altenativas: if ( condicin ) { ... } else { ... } if ( a> =b) printf("\n a es mayor o igual que b "); else printf( " \n b es mas pequefio " ) ; if(a%2==0 ) printf( " \n a es un numero par " ) ; else printf("\n a es impar"); x % y es la operacin Resto (x,y) si x%y ==0 son multiplos _______________________________________________________________ ___________________________ if ( a= = 0 && b= = 0) printf("\n Ecuacin degenerada "); else if( a= =0) printf("\n La raiz es %f", -c/b); else {real = -b / (2*a); d = b*b -4*a*c; ima = sqrt ( fabs(d) / 2 * a); if( d> =0) printf("\n Raices reales: %f, %f", real+ima, real-ima); else { printf("\n Raices complejas: ); printf("\n %f + j%f", real, fabs(ima); printf("\n %f j%f', real, fabs(ima); if <condicion> accion1;
} } #include < stdio.h > #define SI 1
//similar a una etiqueta con un valor #define NO 0 void main(void) { char ch; int mayu, numero, otro; mayu=numero=otro= NO // las igualamos todas a NO printf("\n Introduzca un caracter..."); scanf(" %c", &ch); if ( ch > = 'A' && ch < = 'Z' ) mayu = SI else if ( ch > = '0' && ch < = '9') numero = SI; else otro = SI } _________________________________________________________ #include < stdio.h > void main(void) /* Menor de 3 nmeros * I { int x,y ,z; printf( " \nlntroduzca los 3 nmeros. ..") ; scanf(%d %d %d", &x, &y, &z); if (x <y) if (x <z) printf("\n EI menor es %d", x); else printf("\n El menor es %dtl, z); else if (y <z) printf("\n EI menores %d", y);
else printf("\n El menor es %d" , z); }Seleccin incompleta Operador condicional Es equivalente a else accion2 maximo = (a > b) ? a: b; if ( a > b ) maximo = a; else maximo = b; absoluto = ( conta > 0) ? conta : -conta; printf ("\n EI mayor es %d ", (a>b)? a:b); ) _________________________________________________________ #include < stdio.h > #define SI 1 #define NO 0 void main(void) { int anno, bisiesto; printf("\n Introduzca el ao "); scanf(" %d" , anno); bisiesto=(anno%4= =0 && anno% 100 ! = 100 || ao %400= =0) ? SI: NO; If (bisiesto) printf ("\n SI"); else printf ("\n NO "); Estructura de Seleccin Multiple switch (opcion) ... switch ( opcion) { case 1: ...; break; case 2: ...; <cond> ? accion1: accion2
if (cond) accion1
break; case 5: ...; break; default: ....; } Ejemplo: #include < stdio.h > void main (void) { int numero ; printf("\n Introduzca un numero "); scanf('1 %d", &numero); switch(numero ) { case 0: printf("\n Es un CERO "); break; case 1: printf("\n Es un UNO "); break; default: printf("\n No ni CERO ni UNO "); } #include < stdio.h > void main(void) { float salida[100] ,t; int opcion; printf("\n Introduzca una opcion "); scanf(" %d" , &opcion); switch( opcion )
{case 0: /* Rampa * / for(t=0; t<100;t++) salida[t]=t; break; case 1: /* Triangular * / for ( t=o; t < 50; t+ +) salida[t] =t; for(t=50; t<100; t++) salida[t]= l00-t; break; case 2: /* Polarizada */ for ( t=o; t < 50; t+ +) salida[t] =t; for ( t=50; t < 100; t+ + ) salida[t] = t-50; break; default: printf("\n NINGUNO DE ELLAS "); } for( t=0; t< 100; t+ +) printf("\n Valor = %f", salida[t]); } Cmo sera una cuadrada normal y otra polarizada?
Estructura repetitiva while (condicion) accion1; Bucle con condicin de entrada. ESTRUCTURA: while ( condicion ) { ..... ..... } while ( condicion ) accion; Ejemplos: #include <stdio.h> void main (void)
{ int conta = 0; while ( conta < 10 ) { printf ("\n EI valor es %d", conta ); conta = conta + 1 ; } printf("\n Ha terminado el bucle. Conta = %d", conta ); } #include <stdio.h> void main(void) { int conta = 0; while ( conta < 10) /* Bucle infinito */ { printf ("\n EI valor es %d", conta ); conta = conta -1; } }Calculo del cuadrado de un numero: #include <stdio. h> void main(void) { int numero = 0; while ( numero < 10) { printf ("\n EI cuadrado es %d", numero*numero ); numero++; } } Otra versin: #include <stdio.h> void main(void) { int numero = 0; // conta--
while ( numero*numero < 100 ) { printf ("\n EI cuadrado es %d", numero*numero ); numero++. } } Lectura teclado: #include <stdio. h> void main(void) { int numero, estado; estado = scanf("%d", &numero); while (estado==1) { printf("\n Numero %d", numero); estado = scanf("%d", &numero); } } #include <stdio.h> void main(void) { int numero; while ( scanf("%d", &numero) ==1) printf ("\n Numero %d", numero); } #include < stdio.h > void main(void) { int a; a=3; if (a) { printf ("\n Valor de a %d. ,a ); a=0;
} if (a) printf (\n Valor de a = %d.,a ); Estructura repetitiva Ejemplos: #include <stdio.h> void main(void) { int conta; for( conta = 0; conta < 10; conta = conta +1 ) printf ("\n EI valor es %d", conta ); J printf("\n Ha terminado el bucle. Conta = %d", conta ); } #include <stdio. h> void main(void) { int conta; /* No entra al bucle */ for ( conta = 10; conta < 10; conta++) { printf ("\n EI valor es %d", conta ); conta = conta + 1 ; } printf ("\n Salida del bucle: %d", conta ); }#include <stdio.h> void main(void) { int conta=0; for (; conta < 10; conta++) // inicializo fuera del bucle printf ("\n EI valor es %d", conta ); printf ("\n Salida del bucle: %d", conta ); } Estructura repetitiva do accion while (condicion); for ( i=... , i=... , incr i ) accion1;
Bucle con condicin de salida. ESTRUCTURA: do { ..... } while ( condicion ) ; Ejemplos: #include <stdio. h> void main(void) { int conta=0; do { conta++; printf ("\n EI valor es %d", conta ); } while ( conta < 10); } #include <stdio.h> void main(void) { char ch; do { scanf("%c", &ch); printf("\n%c",ch); } while ( ch != * ); } #include < stdio.h > void main(void) { int t,k; for ( t=0; t<10; t++) { printf("\n El valor de t es %d'., t); for( k = 3; k >0; k--) printf("\n El valor de t+k es %d'., t+k);
} } #include < stdio.h > void main(void) { int t, aux; int fac; for (t=1; t< =5; t++) { aux = t; fac = 1; do { fac = fac * aux. aux--; // Rutina de factorial } while ( aux > 0); printf('.\n E1 factorial de %d es %d", t, fac); } } Salida: 1 1.2 1.3.2 1.4.3.2 1.5.4.3.2 Arrays ( Matrices y Vectores ) Variables del mismo tipo, con el mismo nombre y que se Distinguen y referencian por un indice : float numero[10] ; // int k[104]; // Matriz de 10 n reales /* Factoriales de los numeros entre 1 y 5
Matriz de 104 enteros
char ch[300] ; // Cadena de 299 caracteres int M [23][43] // Matriz de 2 dimensiones #include < stdio.h > void main (void)
{ float k[5]; int t; for ( t=0; t <5; t+ +) { printf (\n Introduzca valor de k[%d] ,t); scanf( %f,&k[ t ]); } for( t=4; t > =0; t--) printf (\n Los valores han sido %f , k[ t ]); }#include < stdio.h > void main (void) { char nombre[5][45]; int t; for ( t=0; t<5; t+ + ) { printf(\n Introduzca nombre de k[%d] , t ); scanf(%s, &nombre[t]); for( t=4; t> =0; t--) printf(\n Los nombres han sido %s, nombre[t]); } #include < stdio.h > void main(void) { int k[3][3]; // Matriz de dimensiones 3x3 int x,y; printf (\n Introduzca los valores de la matriz...); for ( x=0; x < 3; x+ + ) for ( y=0; y <3;y+ +) { printf ( \n Coeficiente [%d][%d] , x,y); scanf (%d, &k[x][y]);
} printf (\n La matriz es: \n); // Ahora escribimos el contenido de la matriz ...
for (x=0; x<3; x+ + ) { for (y=0; y<3;y++) printf( %d , k[x][y]); printf(\n); } printf(tI\n La matriz traspuesta es: \ntl); for (x=0; x<3; x+ + ) { for( y=O; y <3;y+ + ) printf(%d, k[y][x]); printf(\n); } } Strings o cadenas de caracteres Es una array de dos dimensiones de tipo char donde cada fila se considera una cadena de caracteres. Lista [filas] [columnas]
h o c o v o c a
l m y s
a o l
Lista{0} Lista{1} Lista{2}
Lista{3}
Ejemplo: Leer una lista de nombres y almacenarlos en un array
#include<stdio.h> void main(void) #define max 10 // Se pone as porque es mas facil, si queremos #define long 60 // posteriormente modificar las dimensiones de la matriz void main(void) { char lista [max][long]; int i=0,n; puts (Pulsa ^Z para finalizar...); do { printf (\nNombre y apellidos...); fin=gets(Lista[i]); i++; }while (fin!= NULL && i<max); printf (\n\n); for (n=0;n<i;n++) printf (\n Nombre y Apellidos..: %s,Lista[n]); } // Recordar lo que ocurra con scanf al leer una cadena con espacios en blanco FUNCIONES Subrutinas o subprogramas que forman un programa. FUNCIONES SIN ARGUMENTOS Son funciones que no recogen ni devuelven ningn valor. #include < stdio.h > void func1(void); /* Prototipo*/ ^ ^----- no recoge ningun parametro no devuelve ningun valor void main (void)
{ int a,b, conta; a=1; b=2; func1( ); // LLamada a la funcin 1 for (conta = 0; conta < 10; conta+ + ) func1 ( ); } // Cuerpo o codigo de la funcion void func1( ) // Definicin { printf("\n Esta funcion imprime un mensaje "); } FUNCIONES CON ARGUMENTOS Son funciones que regogen 1 o mas parametros del mismo o distinto tipo. #include < stdio.h > void func1(int, int); /* Prototipo*/ ^----- recoge dos parametros de tipo entero void main ( ) { int a,b, conta; a=1; b=2; func1(a,b); //Llamada a la funcin for(conta = 0; conta < 10; conta + + ) func1(a,conta); } void func1(int x, int y) { printf ("\nValores : %d, %d", x, y "); }
FUNCION QUE DEVUELVE UN VALOR #include < stdio.h > double suma(double, double); int maximo(int,int); void main (void) { int a,b, mayor; double x, y ,total; x=22.2; y= 443.0; a=1; b=2; total = suma (x,y); mayor= maximo (a,b); } double suma(double x, double y) { return (x+y); } int maximo(int x, int y) { // si (x>y) entonces devuelve x, sino devuelve y return (x >y) ? x:y; } #include < stdio.h > void uno(void); void dos(void); void main (void) { uno( );
} void uno( ) { printf(\n UNO 1); dos( ); // desde una funcion llamamos a otra funcion } void dos( ) { printf(\n DOS 2);
Variables locales y globales Locales #include < stdio.h> void fun(void); void main (void ) { int a,b; /* Variables locales */ a=b= 1; printf("\n Antes de llamar a fun: a = %d, b= %d", a,b); fun( ); printf("\n Despues de llamar a fun: a = %d, b= %d",a,b); } void fun() { int a,b; // son locales a esta funcion a=b=11; printf {"\n En la funcin: a = %d b= %d", a,b); } _________________________________________________________ #include < stdio.h >
int suma(int,int); void main(void) { int a,b,total; /* Variables locales */ a=b=1; total = suma(a,b); printf ("\n a = %d, b= %d, suma = %d",a,b,total); } int suma(int a, int b) { //a y b son locales en suma int total; total = a+b; a++; b++; return ( total) ; Globales #include < stdio.h > void suma(int,int); int total; /* Variable global , declarada fuera del main */ void main (void) { int a,b; /* Variables locales */ a=b=1; suma(a,b); printf("\n a = %d, b= %d, suma = %d1,a,b,total); } void suma(int a, int b ) { /* a y b son locales en suma */ total = a+b; /* Total es variable global */
a++; b++; } Punteros Una variable puede ser accedida de dos formas distintas. Recordemos que una variable no es mas que una posicin de memoria que se reserva para almacenar un valor, y que se asigna en el momento de la declaracin Ejemplo: int x=3; direccion RAM 12300 3 X Identificador Esto significa que la variable X puede ser accedida por su identificador o por la direccion RAM que ocupa 12300. Como la direccion se asigna cuando se ejecuta un programa y puede variar de una ejecucion a otra, necesitamos una variable que pueda contener a una direccion y un operador que nos diga que direccion RAM tiene asignada una variable. Esto lo realiza un PUNTERO. Los operadores son * y &. - & aplicado a una variable obtiene la direccin RAM - * aplicado a un puntero obtiene el contenido de la direccin de la variable a la que apunta. Declaracin: Int *p; // Declara una variable de tipo direccion Int x=3; p= &x; // Obtenemos la direccion de la variable X *p=4 // El contenido de lo que apunta p vale 4
// Es lo mismo que si hubiera hecho x=4 Los punteros nos sirven, entre otras cosas para que una funcion pueda cambiar los valores de una variable local y tambien para que pueda devolver mas de un argumento Ejemplo: #include "stdio.h" void cambia (int *, int*); void main ( void) { int x = 1; int y= 2; cambia(&x,&y) // pasamos las direcciones de memoria de x e y printf(\n El valor de x = %d y de y = %d , x,y); } void cambia ( int *x, int *y ) { int aux; aux= *x; //GUARDO EN AUX EL CONTENIDO DE DONDE APUNTA X *x = *y *y = aux Hacer dibujo en pizarra } x a y b aux main funcion
PUNTEROS y ARRAYS. La relacin entre un puntero y un array es que la variable que designa al array contiene la direccion de memoria del primer elemento del mismo. #include "stdio.h" void main (void) { int x[10] , t;
for ( t=0; t<10; t++) x[t] = t; for ( t=0; t<10; t++) printf(\n Valores : %d, %d' , x[t], *(x+t)); } #include "stdio.h" void main (void) { int x[10], t; int *p; p = &x[o]; //Obtengo la dir del primer elem.
for ( t=0; t<10; t++) x[t] = t; for ( t=0; t<10; t++) { printf("\n El valor es %d y %d", x[t], *p);
p++; } } Devolucin de ms de 1 valor #include <stdio.h> void F ( int, int, int*, int* ) - - - void main (void) { int x,y,z,t; x=1; y=5; z=10; F ( x, y, &z, &t ); printf (%d - %d - %d - %d ,x, y, z, t); }
x y &z &t void F ( int a, int b, int *c,int *d) 1 5 10 ? { int aux,m,n; aux=a+b; m= b * (*c)+aux; n= (*c)+m; *c=m; *d=n; } Cadenas de caracteres Es un vector de caracteres. Las cadenas acaban con el carcter de fin de cadena \0, el cual no es visible ni imprimible. Ejemplos: char cadena [ ] =abcde; // es un vector de 6 posiciones, la ultima es \0 char cadena [3]=pepe; // error pues supera los lmites char nombre [30]=pepe // el resto se inicializa a \0 char nombres [100][60]; // Define una matriz de 100 cadenas y 59 caracteres de longitud Funcion gets ( ) Lee una cadena desde el teclado, Sustituye el carcter del [enter] por el \0 de fin de cadena. Lee espacios en blanco. prototipo: char * gets (char * cadena)
Parametros: cadena: Vector donde se almacenara la cadena leda Devuelve: puntero a la cadena leda
Funcin puts ( ) Escribe una cadena de caracteres en la pantalla, Sustituye el \0 por un salto de lnea (\n). Prototipo: int puts (char* cadena) Parmetros: cadena: cadena a presentar por pantalla Devuelve : un valor positivo si no hay error. Si hay error devuelve EOF. Ejemplo: #include <stdio.h> #include <conio.h> char lnea[81], *pc; void main (void) { printf (Introducir una cadena); pc=gets(linea); printf (\n Pulsa una tecla para continuar); getch ( ); printf ( Presento la cadena); puts (pc); puts (linea);
Funciones para el manejo de cadenas Librera <strength>
#include < stdio.h > #include < strength > void main(void) { char origen[ ] = " SSSS323232 *S " ; char destino[100]; printf( " \n % s " , origen) ; strcpy(destino,origen); // copia dos cadenas printf("\n %s" ,destino); printf("\n La longitud del array origen es %d" , strlen(origen)); if (strcmp(origen,destino)) // compara dos cadenas printf("\n Son diferentes "); else printf("\n Son iguales"); destino[2] = '@' ; if (strcmp(origen,destino) printf("\n Son diferentes "); else printf( " \n Son iguales " ) ;
strcat(destino,origen); /* Concatena dos cadenas */ printf("\n %s" ,destino); strncat(destino,origen,3); /*Concatena los 3 primeros de origen */ printf("\n% s " ,destino ); strset(destino, '\0'); /*Setea la cadena a un caracter dado */
printf("\n %s" ,destino); } Funciones de conversin entre nmeros y caracteres Funciones avanzadas para la presentacin de texto por pantalla int cprintf (char *formato [, argumentos, ...]); int cputs (char *cadena); (void) normvideo (void) (void) highvideo (void) (void) lowvideo (void) (void) textcolor (int color) (void) textbackground (int color) (void) gotoxy (int x , int y) (void) puttext (int izda, int arriba, int dcha, int abajo, void* dato) APENDICE RESUMEN DE LAS FUNCIONES PRINCIPALES DE LAS UNIDADES ESTANDAR DE C FUNCIONES CON CADENAS. FUNCIONES MATEMATICAS. FUNCIONES DE HORA Y FECHA Y OTRAS RELACIONADAS CON EL SISTEMA. FUNCIONES DE PANTALLA FUNCIONES DE ENTRADA Y DE SALIDA OTRAS FUNCIONES FUNCIONES CON CADENAS include <stdlib.h> double atof(char *cad)
Descripcin Esta funcin devuelve la cadena apuntada por cad a un valor de tipo ouble. La cadena debe tener un nmero vlido en coma lotante. Esto incluye espacios en blanco, signos de puntuacin distintos el punto, y caracteres que no sean E o e. Esto supone que si atof()se llama con la cadena "100.00HOLA" se devuelve el valor 100.00. #include<stdlib.h> int atoi(char *cad) Descripcin La funcin atoi() convierte la cadena apuntada por cad a un valor int. La cadena debe contener un nmero entero vlido. Si este no es el caso, el valor devuelto queda indefinido; sin embargo, muchas de las implementaciones devuelven cero. El nmero puede acabar con cualquier caracter que no forme parte de un nmero entero. Esto incluye espacios en blanco, signos de puntuacin y otros que no sean dgitos. Esto supone que si atoi() se llama con 123.23 se devuelve el valor entero 123 y el .23 se ignora. #include<stdlib.h> int atol(char *cad) Descripcin La funcin atol () convierte la cadena apuntada por cad aun valor long int. La cadena debe contener un nmero entero de tipo long vlido. Si no es este el caso, el valor devuelto queda indefinido; sin embargo, la mayor parte de las implementaciones devuelven cero. El nmero puede acabar con cualquier caracter que no forme parte de un nmero entero. Esto incluye espacios en blanco, signos de puntuacin y otros que no sean dgitos. Esto supone que si atol() se
llama con 123.23 se devuelve el valor entero 123 y el .23 se ignora. #include<stdlib.h> int itoa( int num, char cad, int base) Descripcin La funcin itoa() convierte el entero num a su cadena equivalente y situa el resultado en la cadena apuntada por cad. La base de la cadena de salida se determina por base, que se encuentra normalmente en el rango 2 a 16. La funcin itoa devuelve un puntero a cad. Generalmente no devuelve valor de error. Asegrese al llamar a itoa() que la cadena es lo suficientemente grande como para contener el resultado transformado. Su uso principal es convertir tipos de datos enteros a cadenas de modo que pueden ser enviados a un dispositivo no soportado directamente por el sistema de E/S usual de C -es decir, a un dispositivo no de flujo-. Lo mismo se puede utilizar llevando a cabo utilizando sprintf(). #include<stdlib.h> int ltoa( int long num, char cad, int base) Descripcin La funcin ltoa() convierte el entero num de tipo long a su cadena equivalente y situa el resultado en la cadena apuntada por cad. La base de la cadena de salida se determina por base ,que se encuentra normalmente en el rango 2 a 16. La funcin ltoa() devuelve un puntero a cad. Generalmente no devuelve valor de error. Asegrese al llamar a ltoa() quela cadena es lo suficientemente grande como para contener el resultado transformado.
Su uso principal es transformar enteros en cadenas de modo que pueden ser enviados a un dispositivo no soportado directamente por el sistema de E/S usual de C -es decir, a un dispositivo de no flujo-. Lo mismo se puede utilizar llevando a cabo utilizando sprintf(). #include<stdlib.h> long int strtol(char *ini, char *fin, int base) Descripcin Convierte la representacin en cadena de caracteres de un nmero almacenada en la cadena apuntada por ini- en un nmero de tipo long int y devuelve el resultado. La base del nmero est determinada por base. Si base es 0, debe estar en el rango de 2 a 36. La funcin strtol() trabaja de la siguiente forma: primero elimina cualquier espacio en blanco de la cadena apuntada por ini. A continuacin, se le cada uno de los caracteres que constituyen el nmero . Cualquier caracter que no pueda formar parte de un nmero de tipo long int finaliza el proceso. Por ltimo, fin se deja apuntando al resto, si lo hay, de la cadena original. Esto supone que si strol() se llama con 100.000 pliers, se devuelve el valor de 100L y fin apunta al espacio que precede a pliers. #include <ctype.h> int isalnum(int ch) Descripcin isalnum() es una funcin que analiza a ch y devuelve un valor distinto de cero en caso de que sta sea una letra del alfabeto o un dgito; si no, devuelve cero. #include<ctype.h> int isalpha(int ch)
Descripcin isalpha() es una funcin que nos sirve para determinar si ch es una l #include <ctype.h> int iscntrl(int ch) Descripcin Mediante esta funcin, determinamos si ch es un caracter de control entre 0 y 0x1F(0 a 31 en decimal) o si ch es igual a 0x7F(la tecla DEL) en cualquier todo caso, devuelve cero. #include<ctype.h> int isdigit(int ch) Descripcin La funcin isdigit() devuelve un valor distinto de cero si ch es un nmero dgito (desde 0 a 9). De lo contrario,devuelve cero. #include<ctype.h> int islower(int ch) Descripcin La funcin islower() devuelve un valor distinto de cero cuando ch es un caracter en minscula es decir, una letra desde a hasta z; en cualquier otro caso devuelve cero. #include<ctype.h> int isprint(int ch) Descripcin La funcin isprint() verifica que ch sea un carcter imprimible, incluyendo el espacio en blanco; en cualquier otro caso, se devuelve cero. Generalmente, los caracteres imprimibles oscilan entre 0x20 y 0x7E. #include<ctype,h>
int isspace(int ch) Descripcin Esta funcin, devuelve un valor diferente de cero en caso de que ch sea el espacio en blanco, el tabulador o un caracter de salto delnea; en cualquier otro caso, devuelve cero. netra del alfabeto; si es as, regresa un valor diferente de cero como resultado de la ejecucin,en cualquier otro caso, devuelve cero . #include<ctype.h> int isupper(int ch); Descripcin isupper() comprueba que ch sea una letra mayscula(cualquier letra entre A y Z); en caso contrario devuelve cero. #include <ctype.h> int isxdigit(int ch) Descripcin La funcin isxdigit() devuelve un valor distinto de cero si ch es un dgito hexadecimal; en caso contrario, devuelve cero.Los dgitos se encuentran en uno de estos rangos: A hasta F, a hasta f, y de 0 a 9. #include <strength> char *strcat(char *cad1, char *cad2) Descripcin Esta funcin concatena una copia de cad2 en cad1 y aade al final de cad1 un caracter nulo. El caracter nulo determinacin que originalmente tena cad1 es sustituido por el primer caracter de cad2. La cadena cad2 no se toca en esta operacin. La funcin devuelve cad1. Es tu responsabilidad que cad1 sea lo suficientemente grande como
Para mantener su contenido original y el de cad2. #include<strength> char *strchr(char *cad, int ch) Descripcin La funcin strchr() devuelve un puntero a la primera ocurrencia de ch en la cadena apuntada por cad. Si no se encuentra, devuelve un puntero nulo. #include<strength> int strcmp(char *cad1, char *cad2) Descripcin Por medio de esta funcin se comparan lexicogrficamente dos cadenas que finalizan con el caracter nulo y devuelve un entero que se interpreta de la siguiente forma: Valor Interpretacin Menor que 0 cad1 es menor que cad2 0 cad1 es iguala cad2
Mayor que 0 cad1 es mayor que cad2 #include <strength> char *strcpy(char *cad1, char *cad2) Descripcin strcpy() se utiliza para copiar el contenido de cad2 en cad1. La variable cad2 debe ser un puntero a una cadena que finalice con un caracter nulo; strcpy() devuelve un puntero a cad1. Si cad1 y cad2 se solapan, el comportamiento de strcpy() es indefinido. #include <strength> char *strerror(int num_error) Descripcin
Esta funcin convierte el nmero de error especificado por num_error en una cadena de mensaje de error. Regresa un putero a la cadena. El mensaje a cada num_error est definido en la implementacin. Bajo ninguna circunstancia se debe modificar la cadena. #include<strength> unsigned int strlen(char *cad) Descripcin strlen() nos sirve para determinar el nmero de caracteres que contiene una cadena que finaliza con el caracter nulo. El carcter nulo no se contabiliza. #include<strength> char *strncat(char *cad1,char *cad2, unsigned int n) Descripcin La funcin strncat() concatena n caracteres de la cadena apuntada por cad2 en la cadena apuntada por cad1 y pone al final de cad1 el caracter nulo. El caracter nulo que tenia inicialmente cad1 es sustituido por el primer caracter de cad2. La cadena cad2 no se toca. strncat() devuelve cad1. No olvide que no se hacen comprobaciones de lmites. As que es responsabilidad del programador asegurarse que cad1 sea lo suficientemente grande como para mantener su contenido original y el de cad2. #include<strength> int strncmp(char *cad1,char *cad2, unsigned int n ) Descripcin Esta funcin compara lexicogrficamente un mximo de n caracteres de las dos cadenas terminadas con un caracter nulo y devuelve un entero cuyo significado se presenta a continuacin:
Valor
Interpretacin
Menos que 0 cad1 es menor que cad2 0 cad1 es iguala cad2 Mayor que 0 cad1 es mayor que cad2 #include<strength> char *strncpy(char *cad1,char *cad2, unsigned int n) Descripcin La funcin strncpy() copia n caracteres de la cadena apuntada por cad2 en la cadena apuntada por cad1 . El elemento cad2 debe de tener un caracter final de cadena nulo. La funcin devuelve un puntero a cad1. Los caracteres nulos al final, indican el final de la cadena. Si cad1 y cad2 se solapan, el comportamiento de strncpy() est indefinido. Si la cadena apuntada por cad2 contiene menos caracteres que los indicados por n, se aaden caracteres nulos al final de cad1 hasta que se copie n caracteres. En ca #include<stdio.h> char *strstr(char *cad1,char *cad2) Descripcin La funcin strstr() devuelve un puntero a la direccin de la primera ocurrencia en la cadena apuntada por cad1 de la cadena apuntada por cad2 excepto el caracter nulo de terminacin de cad2. Si no la encuentra, devuelve un puntero nulo. #include<ctype.h> int to lower(int ch) Descripcin Mediante esta funcin se regresa el equivalente en minscula de ch si ch es una letra; en cualquier otro caso devuelve ch sin modificar. #include <ctype.h>
int toupper(int ch) Descripcin toupper() devuelve la mayscula de ch si ch es una letra; en cualquier otro, devuelve ch sin modificar. FUNCIONES MATEMATICAS La mayora de las funciones matemticas estn definidas con tipo de datos dobles pero podemos utilizar esas funciones con tipos de datos de menor rango, excepto caracteres. include <stdlib.h> int abs(int num) Descripcin La funcin abs() devuelve el valor absoluto del entero num. mbio, si la cadena apuntada por cad2 es mayor que cuenta, la cadena resultante apuntada por cad1 no tiene caracter nulo de terminacin.
#include<math.h> double acos(double arg) Descripcin La funcin acos() obtiene el arcocoseno de arg. El argumento de acos() debe estar en el rango de -1a 1; en cualquier otro caso se produce un error de dominio. #include<math.h> double asin(double arg) Descripcin Esta funcin devuelve el arcoseno de arg. El parmetro con el que se mande llamar a asin() debe estar en el rango de -1 a1 para que no produzca un error de dominio.
#include <math.h> double atan(double arg) Descripcin Devuelve el arcotangente de arg . #include<math.h> double atan2(double y, double x) Descripcin atan2() devuelve el arcotangente de y/x. Utiliza el signo de sus argumentos para obtener el cuadrante del valor devuelto. #include <math.h> double ceil(double num) Descripcin Esta funcin d como resultado un valor double que representa el entero ms pequeo que es mayor o igual a num. Por ejemplo, dado 1.02, ceil() devuelve 2.0; dado -1.02, devuelve-1. #include <math.h> double cos(double arg) Descripcin Esta funcin devuelve el coseno de arg. El valor de arg debe darse en radianes. #include<math.h> double cosh(double arg) Descripcin cosh() devuelve el coseno hiperblico de arg. El valor de arg debe darse en radianes. #include <math.h> double exp(double arg)
Descripcin La funcin exp() devuelve un nmero e elevado a la potencia arg. #include <math.h> double fabs(double num) Descripcin Devuelve el valor absoluto de num. #include<math.h> double floor(double num) Descripcin La funcin floor() el mayor entero (representado en double)que no es mayor que num. Por ejemplo, dado 1.02, floor() devuelve 1.0; dado -1.02, floor() devuelve -2.0 #include <math.h> double fmod(double x, double y) Descripcin Esta funcin retorna el residuo de la divisin entera x/y. #include <math.h> double log(double num) Descripcin La funcin log() devuelve el logaritmo neperiano de num.Se produce un error cuando num es negativo y error de rango si el argumento es cero. #include <math.h> double log10(double arg) Descripcin Esta funcin, regresa el logaritmo decimal de num. Se produce un error de dominio si el argumento es negativo, y un error de rango en
caso de ser cero. #include <math.h> double modf(double num, int i) Descripcin Esta funcin descompone num en su parte entera y fraccionaria, y situa la parte entera en la variable apuntada por i. #include<math.h> double pow(double base, double exp) Descripcin pow() retorna base elevada a exp. Se produce un error de dominio si base es cero y exp es menor o igual a cero. Tambin ocurre si base es negativo y expno es entero. Un desbordamiento produce un error de rango. #include <math.h> double sin (double arg) Descripcin Devuelve el seno de arg. El valor de arg, debe darse en radianes. #include <math.h> double sinh(double arg) Descripcin La funcin sinh() devuelve el seno hiperblico de arg. El valor de arg debe darse en radianes. #include<math.h> double sqrt(double num) Descripcin La funcin sqrt() devuelve la raz cuadrada de num. Si se llama con un nmero negativo, se produce un error de dominio. #include <math.h>
double tan(double arg) Descripcin Esta funcin, devuelve la tangente de arg. El valor dearg debe darse en radianes. #include <math.h> double tanh(double arg) Descripcin tanh() retorna la tangente hiperblica de arg. El valor devuelto debe darse en radianes. FUNCIONES DE PANTALLA #include<conio.h> void clreol() Descripcin clreol() borra desde la posicin del cursor hasta que se alcanza el final de la linea en el extremo derecho de la pantalla. Esta operacin slo es vlida en modo texto. #include<conio.h> void clreos() Descripcin La funcin clreos() borra la pantalla desde la posicin actual del curso hasta abajo. Slo se aplica en pantallas en modotexto. #include<conio.h> void clrscr() Descripcin La funcin clrscr() borra toda la pantalla. En general, esta operacin slo se aplica cuando la pantalla est en modo texto. include<conio.h> void gotoxy(int x, int y)
Descripcin Esta funcin, situa el cursor en la fila y columna definidas por x,y. Esta operacin slo se utiliza en pantallas de modo texto. #include<conio.h> void home() Descripcin Coloca el cursor en la posicin 0,0 (el extremo superior izquierdo de la pantalla). No borra la pantalla. Slo funciona en modo texto. #include<conio.h> int gettext(int izq,int top, int der, int centro, void *destino); Descripcin Copia texto de la pantalla en modo texto a la memoria. Las coordenadas utilizadas son absolutas, no relativas a la ventana en la que se est trabajando.La coordenada del extremo superior izquierdo es (1,1). Regresa un valor diferente de cero si la operacin fu exitosa. #include<conio.h> void insline(); Descripcin Inserta una lnea en blanco en una ventana de texto en la posicin del cursor. Las lineas que se encuentran debajo de la posicin del cursor se recorren una linea hacia abajo y se pierde la ltima lnea. #include<conio.h> void lowvideo(void); Descripcin Dismuinuye la intensidad de la luminosidad de los caracteres. Afecta a todos los caracteres que se imprimen posteriormente en pantalla dentro de esa ventana. #include<conio.h>
void highvideo(void); Descripcin Aumenta la intensidad de la luminosidad de los caracteres. Afecta a todos los caracteres que se imprimen posteriormente en pantalla dentro de esa ventana. #include<conio.h> void normvideo(void); Descripcin Anula a highvideo() y/o normvideo(). Es decir, la luminosidad de los caracteres que se escriban a continuacin, ser normal dentro de esa ventana. #include<conio.h> void textcolor(int color); Descripcin Selecciona un nuevo color de los caracteres que se escribirn a continuacin. #include<conio.h> void texbackground(int color); Descripcin Selecciona un nuevo color del fondo de la pantalla. #include<conio.h> void window(int iniciox,int inicioy, int finx, int finy); Descripcin Crea una ventana activa en pantalla. FUNCIONES DE ENTRADA Y SALIDA #include<stdio.h> Int getchar ()
Descripcin Esta funcin lee un carcter desde el teclado hasta que se pulse <ENTER>.En caso de que se digite ms de un carcter antes de pulsar <ENTER>, la variable slo almacenar el primer carcter que se tecle. #include<stdio.h> char *gets(char *cad) Descripcin Esta funcin lee una cadena de caracteres desde el teclado y la coloca En la cadena cad. Se leen caracteres hasta que se recibe la pulsacin de <ENTER>. Esto no quiere decir que en la cadena se almacenar este carcter sino que aadir un carcter nulo (\0) para identificar el final de la cadena. En caso de error, gets () retorna un puntero nulo y el Contenido de cad ser indeterminado. Con gets () puedes leer todos los caracteres que desees. Por tanto, Corresponde al programador asegurarse que la cantidad de caracteres ledos no superen la capacidad del array. #include<stdio.h> int putchar (ch) Descripcin Putchar () escribe un carcter en pantalla donde ch puede ser una Variable de tipo carcter o un carcter ASCII entre comillas simples ('a') y Posiciona el cursor en la siguiente lnea. #include<stdio.h> int puts (char *cad) Descripcin La funcin puts () escribe en pantalla el contenido de una cadena
apuntada por cad (un conjunto de caracteres) y posiciona el cursor en la siguiente lnea. #include<stdio.h> int kbhit() Descripcin Esta funcin no est definida por el ANSI propuesto. Sin embargo, la incluimos aqu porque aunque con nombre diferente, se encuentra Definida en todas las implementaciones de C. Su uso principal es permitir que el usuario pueda interrumpir alguna Rutina desde el teclado. Regresa un valor distinto de cero, si se ha Pulsado una tecla y en caso contrario, el valor retornado es Cero.
#include<stdio.h> int printf(char *formato, lista_arg) Descripcin La funcin printf() despliega en pantalla tanto cadenas constantes (mensajes) como variables de acuerdo al contenido de formato. Con formato, se especifica la cadena constante y/o el tipo de variables que desplegar en pantalla. Todo esto siempre v entre comillas dobles(" ") . Por ejemplo: printf("Hola, como estas?"); printf("%s",nombre); Con la primera instruccin, mandamos un mensaje a pantalla. En este caso, no es necesario especificar algn formato ya que slo se despliega el mensaje. Es en el segundo ejemplo de printf() donde utilizamos formato para determinar el tipo de variable(s) que van a ser
desplegadas. En el caso anterior, determinamos que se va a escribir el contenido de nombre que es una variable de tipo cadena. Veamos el formato que puede utilizarse para definir el contenido de cualquier variable: Cdigo Formato %c Un slo carcter %d Decimal
%i Decimal %e %f Notacin cientfica 5e-3 Coma flotante
%g utiliza el ms corto de %e o %f. %o %s Octal Cadena de caracteres
%u Decimal sin signo %x Hexadecimal %% Imprimir el smbolo % %p Presentar un puntero Tambin podemos desplegar en el monitor mensajes como el contenido de variables con el mismo comando printf() como en el ejemplo siguiente: printf("Hola %s soy %s, tengo %i aos."huesped,nombre,edad); Si husped="visitante", nombre="el supervisor", edad=35 el resultado ser el siguiente mensaje en pantalla: <Hola visitante soy el supervisor, tengo 35 aos>. Recuerde que se deben especificar en el mismo orden tanto el contenido delas variables a imprimir dentro de formato como las variables en s. La funcin printf() devuelve el nmero de caracteres
realmente presentados en pantalla. Un valor negativo significa que se ha producido un error. Se pueden escribir enteros entre el signo de porcentaje y el carcter que especifica el tipo de dato a presentar. Esto sirve para determinar la longitud del campo, el nmero de decimales y un indicador de justificacin a la izquierda. Para especificar la longitud del campo, basta con escribir el nmero despus del signo de porcentaje; despus se agrega un punto y el nmero de posiciones decimales que se desea presentar en el caso de los nmeros en coma flotante. Si la cadena es mayor que la anchura del campo, se truncan los caracteres por el final. Por ejemplo, %12.4f determina a un nmero de como mximo doce caracteres de longitud con cuatro posiciones para la parte decimal. Cuando se aplica a cadenas de caracteres o enteros, el nmero despus del punto determina la mxima longitud del campo. Por ejemplo %3.5s presenta una cadena que tiene al menos tres caracteres y que no excede de cinco. Si la cadena es mayor que el campo, se truncan los caracteres por el final. Por defecto, toda salida est justificada por la derecha. En otras palabras, si la anchura del campo es mayor que la de los datos presentados, esto son situados en la parte derecha del campo. Puede forzar que la informacin quede justificada a la izquierda situando un signo menos (-) inmediatamente despus del signo de porcentaje. Por ejemplo %-6.3f justifica un nmero en coma flotante por la izquierda con tres posiciones decimales en un campo de seis caracteres. Ejemplo: Si saludo="hola" , printf("%-10s",saludo); presentar: <hola >
#include <stdio.h> int scanf(char *formato,lista_arg) Descripcin Esta funcin realiza la operacin contraria a printf()es decir, lee datos de cualquier tipo desde el teclado hasta que se pulse un retorno de carro(<ENTER>). Sus parmetros tambin son similares a printf() ya que en formato se especifica el o los tipos de variables que se van a leer mientras que en lista_arg se escriben las direcciones de memoria (&) de las variables. Por ejemplo: scanf("%d",&edad); scanf("%i%c",&edad,&sexo); La seccin de formato corresponde a "%d" donde se indica que se va a leer un entero decimal; &edad corresponde a lista_arg e indica que los caracteres ledos sern almacenados en la direccin que ocupa la variable edad. La diferencia entre la sintaxis de scanf() y printf() consiste en que en la lista de argumentos, scanf() necesita que se le especifique que el lugar donde v a almacenar los datos es en la direccin de la variable( &edad). La nica excepcin es cuando se v a leer una cadena de caracteres ya que este tipo de variables indican una direccin por si mismas. Ejemplo: char nombre[10]; scanf("%s", nombre); A continuacin se presentan los cdigos de formato de scanf(). Cdigo Interpretacin %c %d %i %e %f Leer un nico carcter Leer un entero decimal Leer un entero decimal Leer un nmero en coma flotante Leer un nmero en coma flotante
%h %o %s %x %p
Leer un entero corto Leer un nmero octal Leer una cadena de caracteres Leer un nmero hexadecimal Leer un puntero
Un espacio en blanco en la cadena de control da lugar a que scanf() salte uno o ms espacios en blanco en el flujo de entrada. Un carcter blanco es un espacio, un tabulador o carcter de nueva lnea. Por ejemplo, %d,%d d lugar a que scanf() lea primero un entero, entonces lea y descarte la coma, y finalmente lea otro nmero. Si el carcter especificado no se encuentra, scanf() termina. Un * situado despus del % y antes del cdigo de formato lee los datos de tipo especificado pero elimina su asignacin. As, dada la entrada 10/20, el cdigo scanf("%d*%d",&x,&y); asigna el valor 10 a x, descarta el signo de divisin, y d a y el valor 20. Las rdenes de formato pueden especificar un modificador de mxima longitud de campo. Situado entre el % y el cdigo de orden de formato, es un entero que limita la cantidad de caracteres a leer para cualquier campo. Por ejemplo, si se quieren leer slo 15 caracteres en nombre se escribira as: scanf("%15s",direccion); Si el flujo de entrada fuera mayor de 15 caracteres, entonces una posterior llamada de entrada debera comenzar donde esta llamada la dej. Por ejemplo, si Av._Corregidora_#_500 se ha introducido como respuesta al scanf() anterior, nicamente los primeros 15 caracteres (hasta la a de corregidora) seran situados en direccin debido al especificador de tamao mximo. Cuando se hiciera otra llamada a scanf() tal como scanf("%s",cadena);
_#_500 se asignar a cadena. FUNCIONES DE HORA, FECHA . OTRAS RELACIONES CON EL SISTEMA. #include <time.h>
char *asctime(punt) struct tm *punt Descripcin: Esta funcin regresa un puntero a una cadena que convierte la informacin almacenada en la estructura apuntada por punt de la forma siguiente: dia mes horas:minutos:segundos ao\n\0 Por ejemplo: Mircoles Jun 19 12:05:34 1999 El puntero a estructura pasado a asctime() se obtiene generalmente de localtime() o gmtime(). El buffer utilizado por asctime() para mantener la cadena de salida con formato se situa estticamente en un array de caracteres y se sobreescribe cada vez que se llama a la funcin. Si se desea salvar el contenido de la cadena, es necesario copiarlo en otro lugar. #include<time.h> clock_t_clock() Descripcin Indica el tiempo empleado en la ejecucin de un proceso. Para transformar este valor en segundos, se divide entre el valor de la macro CLK_TCK. Se devuelve el valor -1 si el tiempo no est disponible.
#include<time.h> char *ctime(long *hora) long *ctime(long *hora) Descripcin Dado un puntero a la hora de calendario, la funcin ctime()convierte un tiempo almacenado como un valor de tipo time_t a una cadena de caracteres de la forma: dia mes fecha horas:minutos:segundos ao\n\0 La hora de calendario se obtiene normalmente durante una llamada atime(). La funcin ctime() es equivalente a: asctime (localtime(hora)) El buffer utilizado por ctime() para guardar la cadena de salida con formato se sita de forma esttica en un array de caracteres y se sobreescribe cada vez que se llama a la funcin. Si se desea guardar el contenido de la cadena es necesario guardarla en otro lugar. #include <time.h> struct tm *localtime(time_t *hora) Descripcin La funcin localtime() devuelve un puntero a la forma separada de hora en la estructura tm. La hora se representa con la hora local. Esta se obtiene normalmente a travs de una llamada a time(). La estructura utilizada por localtime() para mantener la hora separada, se situada de forma esttica y se rescribe cada vez que se llama a la funcin. Si se desea guardar el contenido de la estructura, es necesario copiarla en otra variable. #include<time.h> time_t time(time_t hora)
Descripcin
La funcin time() devuelve la hora actual del calendario del sistema. Si el sistema no tiene hora,devuelve -1. Puede llamarse con un puntero nulo o con un puntero a una variable de tipo time_t. Si se utiliza este ltimo, el argumento tambin es asignado a la hora de calendario .
El lenguaje de Programacin C
1. Introduccin. 2. Elementos bsicos del lenguaje. 3. Las estructuras de control. 4. Estructura de un programa. 5. Tipos de datos estructurados. 6. Las entradas y salidas de C.
1. Introduccin 1. El origen del C. 2. La estructura de un programa en C. 3. Un primer programa en C. 4. Fases de la compilacin. 5. La compilacin separada.
El origen del lenguaje C ALGOL (Working Group of IFIP) 1960 UNIX en B UNIX en ensamblador (Ken Thompson) 1969
UNIX en C 1973 CPL (Universidad de Londres) 1963 BCPL (Martin Richards) 1967 B (Ken Thompson) 1970 C (Dennis Ritchie) 1972 PASCAL MODULA ANSI C Biblioteca ANSI 1983 La estructura de un programa en C Un programa en C est constituido por una sucesin de funciones. Siempre existe una funcin llamada main. Una funcin se compone de: Una cabecera Tipo nombre_de_funcin (argumentos) Una secuencia de instrucciones agrupadas en un bloque { Instrucciones }
/*Este programa convierte una cantidad de minutos */ /* a su equivalente en horas y minutos */ #include <stdio.h> void main(void) { int x, horas, minutos; printf("Cuantos minutos? "); scanf("%d", &x); horas = x / 60; minutos = x % 60;
printf("%d minutos son %d hora(s) y %d minuto(s)",x,horas,minutos); } Un primer programa en C La salida del anterior programa es: Cuantos minutos? 136 136 minuto(s) son 2 hora(s) y 16 minuto(s)
Ejemplo: El rea de un tringulo /* Programa que calcula el rea de un tringulo */ #include <stdio.h> void main (void) { float base, altura, area; printf (Introduzca la base:); scanf (%f, &base); printf (Introduzca la altura:); scanf (%f, &altura); area = base * altura / 2; printf (El rea del tringulo es: %f, area); }
Cdigo fuente Preprocesado Compilacin Linkado Fases de la compilacin Directivas: #include #define #if, etc. Cdigo fuente preprocesado Se transforma el cdigo fuente en ensamblador Cdigo objeto Se enlazan las llamadas a funciones con las funciones Cdigo ejecutable
Compilacin separada
C1.c main() { f1(); } C2.c f1() { f2() } C3.c f2() { } C1.OBJ C2.OBJ C3.OBJ Libreras Ejecutable COMPILACIN LINKADO
2. Elementos fundamentales del Lenguaje C 1. Identificadores. 2. Tipos de datos. 3. Constantes y variables. 4. Operadores, expresiones y sentencias. 5. Conversin de tipos. 6. Punteros.
Identificadores Un identificador es cualquier combinacin de letras, nmeros y guiones de subrayado. _Media8 Calcular_Sumatorio No se puede comenzar un identificador con un nmero. 8_Media No vlido Las palabras clave de C son en minsculas. Se distingue entre maysculas y minsculas. CASAcasa
Se recomienda utilizar identificadores descriptivos. Tipos de datos Los tipos de datos fundamentales son: char carcter int entero float real double real de doble precisin Modificadores de los tipos fundamentales: short entero corto long entero largo y double largo unsigned entero sin signo signed entero con signo
Rango de los tipos de datos El rango de los valores de los tipos de datos es dependiente de la implementacin. Consultar limits.h y float.h No obstante, si que hay definidos unos mnimos: Tipo Rango mnimo de valores char -128 a 127 unsigned char 0 a 255 signed char -128 a 127 int -32768 a 32767 unsigned int 0 a 65535 signed int -32768 a 32767 short int -32768 a 32767 unsigned short int 0 a 65535 signed short int -32768 a 32767 long int -2147483648 a 2147483647 signed long int -2147483648 a 2147483647 unsigned long int 0 a 4294967295 float 6 dgitos de precisin double 10 dgitos de precisin long double 10 dgitos de precisin El tipo booleano A diferencia de PASCAL, en C no existe un tipo booleano.
Tampoco existen las constantes TRUE y FALSE, aunque podemos definirlas. Lo que se usa como valores booleanos son los tipos enteros: FALSE es 0, \0 o NULL TRUE es cualquier valor diferente de 0. Una expresin como: a>5 es evaluada en tiempo de ejecucin por el programa y en caso de ser falsa el resultado es cero, en caso contrario un valor distinto de cero (puede ser cualquier valor).
Definicin de tipos C dispone de una declaracin denominada typedef para la creacin de nuevos nombres de tipos de datos. typedef tipo nombre_del_nuevo_tipo; Por ejemplo: typedef unsigned short int UNSHORT; define el tipo UNSHORT. Este tipo de dato nuevo ser un entero corto sin signo, utilizable como si fuese un tipo bsico.
Constantes En C existen cuatro tipos bsicos de constantes: enteras reales carcter cadena de caracteres. Constantes enteras Decimal: 19, -213, 3 Octal: 023, -0325, -03 Hexadecimal: 0x13, 0Xd5, 0x3 Decimal sin signo: 19U, 213U, 3U Octal sin signo: 023U, 0325U
Hexadecimal sin signo: 0x13U, 0Xd5U Decimal largo: -213L, 3000000L Octal largo: 023L, -0325L Hexadecimal largo: 0x13L, 0Xd5L Decimal largo sin signo: 190000UL
Constantes Constantes reales: 4.7, -5.65, 4E3, -7e-2, 4.8E4, -7.2e-2 La letra E substituye al nmero 10. As, el nmero 4.8 x 104 es el 4.8E4. Las siguientes constantes representan el mismo valor: 0.00075E1, 0.0075, 0.075E-1, 0.75E-2, 75E-4
Constantes Constantes carcter: Representacin: Un nico carcter entre comillas simples (). Una constante carcter tiene asociado un valor numrico: su cdigo ASCII. Una secuencia de escape es una pareja de caracteres que representan uno solo. El primero es siempre la barra inclinada \ Significado Mnemnico Smbolo Nueva lnea NL (LF) \n Tabulacin horizontal HT \t Espacio atrs BS \b Retorno de carro CR \r Salto de pgina FF \f Antislash \ \\ Apstrofe ' \' Comilla doble \ Configuracin de bits ddd (d en base 8) \ddd
Constantes Constantes cadena: Representacin: una secuencia de
caracteres delimitados por comillas dobles . Esto es una cadena INICIO\n\nFIN Comillas dobles \ y simples \ C:\\Directorio\\Fichero.txt Toda cadena tiene un carcter final de cdigo ASCII 0 (\0) que el compilador sita automticamente al final de la cadena.
Variables Una variable es un identificador que hace referencia a una posicin de memoria. Todas las variables deben ser declaradas antes de ser usadas. Las variables pueden declararse en: Dentro de una funcin. Variables locales. En la cabecera de una funcin. Argumentos. Fuera de todas las funciones. Variables globales. Es posible dar un valor inicial a las variables. int i=0; char a=a; La declaracin de constantes: const float pi=3.14; const char A = A;
Expresiones Expresin: combinacin de operadores y expresiones. La expresin ms simple puede ser una constante, una variable o una llamada a una funcin. Una expresin acabada en punto y coma (;) se convierte en una
sentencia. Una secuencia de sentencias dentro de llaves { } forma una sentencia (sentencia compuesta).
Operadores aritmticos Operador Accin - Sustraccin y signo unario + Adicin * Multiplicacin / Divisin % Mdulo (resto de la divisin entera) -- Decremento ++ Incremento Sentencia Equivalencia z++; z=z+1; ++z; z=z+1; x=++z; z=z+1; x=z; x=z++; x=z; z=z+1;
Operadores relacionales Operador Accin > Mayor que >= Mayor o igual que < Menor que <= Menor o igual que == Igual != Distinto El resultado de estos operadores es un valor entero (0 FALSE, otro valor TRUE). En los primeros programas que se escriben en C es frecuente confundir los operadores == y != al usar sus equivalentes en PASCAL, = y <>. <> producir un error de compilacin. = no produce error de compilacin, pues es un operador vlido en C.
Operadores lgicos Operador Accin && AND (Y lgico) || OR (O lgico) ! NOT (negacin) Condicin Resultado lgico 5 Cierto !5 Falso !0 Cierto 5<6 && 7>=5 Cierto 5>6 && 7>=5 Falso 6>5 || 7>=5 Cierto 5>6 || 7<=5 Falso !(5>6 || 7<=5) Cierto
Operadores de manejo de bits Operador Accin ~ Complemento a 1 unario & AND bit a bit | OR inclusivo bit a bit ^ OR exclusivo (XOR) bit a bit << Desplazamiento a la izquierda >> Desplazamiento a la derecha
Operadores de asignacin Operador Accin = Asignacin operador= Asignacin especial Sentencia Equivalencia a=b=c; a=c; b=c; a+=b; a=a+b; a*=b; a=a*b;
Operador condicional
El operador ?: es un operador de asignacin condicional. Su sintaxis es: (expresin_1)?expresin_2:expresin_3 Ejemplo x=(a>5)? 1 : 0; Es equivalente a: Si a>5 entonces x=1 sino x=0
Otros operadores Operador Accin & Direccin de un objeto (unario). * Direccionamiento indirecto (unario). [] Direccionamiento indexado. sizeof(_) Da la talla de la variable o el tipo entre parntesis. , Sirve para reunir varias expresiones en una instruccin. . Da acceso a los campos de las estructuras. -> Da acceso a los campos de las estructuras accedidas por punteros.
Conversin de tipos Cuando en una expresin aparecen operandos de distinto tipo: Conversin automtica sin prdida de informacin. los datos se convierten al ms general (char a int, int a float, etc.) int i=20; float f; f=i * 3.1416; Conversin explcita o type casting Se obliga a una expresin a evaluarse
con un tipo que se indica explcitamente. x=(unsigned int) (y/655)%32;
Punteros Un puntero es una variable que contiene direcciones. Una variable puntero es una variable como cualquier otra, lo que cambia es el tipo de los datos que almacena. Debemos inicializarla antes de usarla. Lo que le asignemos debe corresponder con el tipo de la variable (una direccin). Declaracin: int *px, *py; /* Punteros a int */ char *pc; /* Puntero a char */ void *pv; /* Puntero a cualquier cosa */ Asignacin: Asignacin de otro puntero: px=py; Asignacin de una direccin: int x, *px; px=&x; px=0xFF0E; px=NULL; /* Direccin 0*/
Punteros Operador asterisco: permite acceder a un dato apuntado por un puntero. int x = 5; int *px; px=&x; printf (%d, *px);/*Escribir 5*/ No es lo mismo px=py que *px=*py. px=py asigna la direccin de py a px. int x=5, y=10; int *px, *py; px=&x; py=&y; px=py; Resultado: x! 5, y!10, *px!10, *py!10
*px=*py asigna el contenido de donde apunta py al lugar donde apunta px. int x=5, y=10; int *px, *py; px=&x; py=&y; *px=*py; Resultado: x! 10, y!10, *px!10, *py!10
Punteros Suma y resta de punteros. Puntero + entero: Puntero + puntero: No vlido. Puntero entero: Puntero puntero: py-px ! i px px++ px+i 01i px-i px 01 px-i px py 01i
Punteros Comparacin (==, >, !=, etc.) Se comparan los valores numricos de las direcciones. Punteros a puntero. Dado que un puntero es una variable, su direccin tambin puede ser contenida por un puntero. int x=5; int *px; int **ppx; /*puntero a puntero*/ px=&x; ppx=&px; Resultado: x!5,*px!5,**ppx!5 **ppx=6; Resultado: x!6, *px!6, **ppx!6 ppx=&x; Error: Distinto nivel de indireccin
Ejercicio de punteros Qu resultado muestra en pantalla el siguiente programa? int x=5, y=2; int *px, *py, *pz; px=&x; printf(%d, *px); py=&y; printf(%d, *py); *px=*py; printf(%d, x); *px=5; px=py; printf(%d, x); printf(%d, *px); *pz=6; pz=NULL; *pz=6;
3. Las estructuras de control 1. Estructura de seleccin simple. 2. Estructura de seleccin mltiple. 3. Estructuras de repeticin. 4. Control de las estructuras de repeticin.
Estructura de seleccin simple La estructura de seleccin simple (if-else) tiene la siguiente sintaxis: if (expresin condicional) sentencia else sentencia La clusula else es opcional. Los parntesis son obligatorios. La sentencia puede ser simple o compuesta.
Ejemplo: if (a>5) printf(a es mayor que 5); else printf(a no es mayor que 5); El else se asocia al if ms cercano. Se pueden anidar ifs.
Estructura de seleccin mltiple switch ( expresin entera) { case constante1: secuencia de sentencias; break; case constante2: secuencia de sentencias; break; ... default: secuencia de sentencias; } Ejemplo: switch(a) { case 1: printf(vale 1); break; case 2: case 3: printf(Vale 2 o 3); break; default: printf(Vale otra cosa); }
Estructuras de repeticin Existen tres estructuras de repeticin: while do-while for Estructura while: while ( condicin) sentencia; while (p!=7) p++; while (x<5) { printf(%d, x);
x++; }
Estructuras de repeticin Estructura do-while: do { secuencia de sentencias; } while (condicin); do { printf(Deme un nmero del 1 al 10:\n); scanf(%d, &i); } while (i<1 || i>10); Estructuras de repeticin Estructura for: for (inicializacin; condicin; progresin) sentencia; for (i=0; i<10; i++) printf(%d, vector[i]; for (i=0, j=0; i<10 && j<10; i++, j++) printf(%d, matriz[i][j]); for (encontrado=0, i=0; i<10 && !encontrado; i++) if (vector[i]==valor) encontrado=1; encontrado=0; i=0; for(;i<10 && !encontrado; ) { if (vector[i]==valor) encontrado=1; i++; }
Sentencias de control en las estructuras de repeticin Existen dos palabras clave en C que provocan un salto dentro de una estructura de repeticin: break: interrumpe la ejecucin de un
bucle saltando a la instruccin siguiente. continue: produce un salto a la evaluacin de la condicin. i=0; while (i<5) { i++; if (i==2) printf(%d, i); } Salida con continue: 1, 3, 4, 5 Salida con break: 1 break; continue 4. Estructura de un programa en C++ 1. Funciones. 2. Paso de parmetros por referencia. 3. Tipos de variables. 4. El preprocesador.
Funciones Un programa est constituido por funciones. El programa principal lo constituye la funcin main. No existe una diferenciacin entre procedimientos y funciones, como en PASCAL. Una funcin es un sub-programa al cual se le transmite una lista de argumentos y que devuelve un valor. Los valores en una funcin se retornan por medio de la palabra return.
Funciones Existen dos formas de declarar
funciones: Declaracin clsica (K&R) considerada obsoleta: tipo_retorno nombre_funcin (parmetros) declaracin de parmetros; { declaracin de variables; instrucciones; } Declaracin moderna (ANSI): tipo_retorno nombre_funcin(parmetros con sus tipos) { declaracin de variables; instrucciones; } Funciones Declaracin K&R: float maximo( a, b) float a,b; { return (a>b)? a: b; } Declaracin ANSI: float maximo( float a, float b) { return (a>b)?a:b; } En ambos casos, la forma de llamar a la funcin es la misma: float x=3.3,y=2.2,z; z=maximo(x,y); No se puede poner: float a, b Funciones Los prototipos de funciones tienen como finalidad que el compilador conozca el tipo de los parmetros de una funcin cuando se produce la llamada a sta.
Los prototipos son declaraciones de funciones, cuya definicin aparecer posteriormente, en el mismo fichero u otro que vaya a ser enlazado a ste. Slo son necesarios cuando la llamada a una funcin aparece antes que su declaracin. Los ficheros a los que se llama con #include contienen los prototipos de las funciones que incorpora el compilador.
Funciones #include <stdio.h> float maximo( float, float); /* Prototipo*/ void main ( void ) { float x, y, z; printf(Dame x e y:); scanf (%f,%f, &x,&y); z=maximo(x,y); printf(El mximo es %f, z); } float maximo(float x, float y) { return (a>b)?a:b; } Si no estuviera el prototipo, el compilador asumira que z es de tipo int
Funciones El equivalente al PROCEDURE de PASCAL se implementa mediante la definicin de una funcin que no devuelve nada. #include<stdio.h> void mensaje(void); void main(void) { mensaje();
} void mensaje (void) { printf(Esto es un mensaje\n); } El tipo void indica que no devuelve nada Para hacer que la funcin concluya se puede escribir: return; Se deben poner parntesis, aunque no se pasen parmetros
Paso de parmetros a funciones En la mayora de lenguajes de programacin existen dos tipos de pasos de parmetros: Paso de parmetros por valor. Paso de parmetros por referencia. En C no existe el paso de parmetros por referencia, aunque se imita por medio de los punteros. En C++ s existen ambos tipos de pasos de parmetros.
Paso de parmetros por valor Paso de parmetros por valor. Lo que se pasa a la funcin es nicamente un valor, sin que exista una relacin entre la variable cuyo valor es pasado a la funcin y el parmetro que recibe el valor. /* Cuerpo de una funcin cualquiera*/ int a=5; ... a=5; f(a); /* Llamada a la funcin f*/
... } void f( int p) { p=30; } Al ser un paso por valor, a p se la ha asignado el valor de a, pero no hay ninguna relacin entre ambas variables. Aunque se modifique p, la variable a sigue valiendo 5. Paso de parmetros por referencia En el paso de parmetros por referencia el parmetro es un nombre alternativo de la variable que le corresponde en la llamada a la funcin. Es decir, son la misma variable, as si se modifica el parmetro la variable queda modificada. /* Cuerpo de una funcin cualquiera*/ int a=5; ... a=5; f(a); ... } void f( int & p) { p=30; } Al ser un paso por referencia, lo que se le haga a p es como si se le hiciese a a. Se est modificando a, pues p hace referencia a a. En C++, el smbolo & en un parmetro indica que es un paso por referencia. Se ver en la parte de C++.
No se puede usar en las prcticas de C. Paso por referencia en C En C slo existe el paso por valor. Para conseguir que una funcin pueda modificar una variable que se le pasa en una llamada, debemos pasar su direccin. int a = 6; f(a); int a = 6; f(&a); Aqu lo que en realidad se est pasando es el valor 6, por lo que la funcin no podr modificar a a Aqu se est pasando la direccin de a. A travs de la direccin, la funcin puede modificar a a. Paso por referencia en C Si se pasa una direccin a una funcin, el parmetro correspondiente tendr que ser un puntero. int x=5, y=6; swap (&x, &y); printf(%d, %d\n, x,y); } void swap (int *v1, int *v2) { int temp; temp=*v1; *v1=*v2; *v2=temp; } La direccin de las variables a modificar La salida ser: 6, 5. x e y han intercambiado sus valores.
Si se pasa la direccin de un int, el parmetro ser un puntero a int. v1 es la direccin, *v1 es el entero Como v1 y v2 son las direcciones de x e y, al modificar *v1 y *v2 se est modificando a x e y. Paso por referencia en C /* Programa que pide dos valores y devuelve su suma */ #include <stdio.h> void main(void) { int x, y, resultado; PedirValor(&x); PedirValor(&y); SumarValores (x,y, &z); printf(La suma de %d y %d es %d,x,y,resultado); } void PedirValor(int *v) { printf(Dame un valor:); scanf(%d, v); } void SumarValores(int v1, int v2, int *r) { *r=v1+v2; }
Tipos de variables En C se distinguen cuatro tipos de variables: Externas Automticas Estticas Registro Las variables externas (globales) se definen fuera de todas las funciones. Pueden ser ledas y modificadas desde cualquier funcin que se encuentre detrs de su declaracin. Si se quiere utilizar una variable
externa en un fichero diferente a donde est declarada, se la debe volver a declarar en el segundo fichero, pero precedida por la palabra reservada extern. Tipos de variables: extern /* Fichero 1 */ int variable_externa1; void main( void ) { variable_externa1=1; fun(); } int variable_externa2; ... /* Fichero 2 */ extern int variable_externa1; void fun( void ) { extern int variable_externa2; variable_externa1=2; variable_externa2=2; } ... Variable externa (global) Variable externa, se podr usar en las funciones definidas a partir de aqu. La palabra extern indica que esta variable est definida en otro fichero Esta variable slo podr usarse en esta funcin
Tipos de variables: auto Las variables automticas se definen
dentro de las funciones. Su vida empieza cada vez que empieza a ejecutarse la funcin donde estn. Desaparecen cada vez que la funcin concluye. Se crean y destruyen de manera automtica. A lo largo de una ejecucin de un programa, una variable automtica se crear tantas veces como se ejecute la funcin donde ha sido declarada. void funcion( void) { char a; ... }
Tipos de variables: static Las variables estticas (static) son un caso intermedio entre las variables extern y auto: Se declaran dentro de las funciones al igual que las auto. Slo son accesibles desde la funcin donde se declaran. Se crean y se destruyen slo una vez en cada programa al igual que las extern. Su espacio de memoria se mantiene durante toda la ejecucin del programa. Slo se inicializan una vez. int CalculoRaro(void) { static int var = 0; var += 10; return var; } La primera vez que se ejecuta la funcin Calculo Raro devuelve 10, la segunda 20, la tercera 30, etc.
Tipos de variables: register
Si una variable se declara como register, ser situada en un registro de la CPU, siempre y cuando haya alguno disponible. Se emplea para variables a las que se acceda muy frecuentemente, ya que es ms rpido acceder a un registro que a la memoria del ordenador. register int i; for (i=0; i<10000; i++) ... El preprocesador Las directivas del preprocesador son procesadas en un primer paso de la compilacin. Tres tipos de directivas: Inclusin de ficheros #include Substitucin simblica #define Compilacin condicional #if, #else, etc. #define define una cadena que substituir a otra: #define TALLA 100 #define PI 3.14 #define BEGIN { #define END } #define max(a,b) ((a>b)?a:b) #include incluye un fichero de texto. #include <stdio.h> En el directorio del compilador. #include mio.h En mi directorio.
El preprocesador #if, #else, #endif, etc. Permiten definir partes del programa que sern compiladas o no dependiendo de una condicin que se evala en tiempo de compilacin. #if defined(HDR) /* Cdigo a compilar en el primer caso*/ ... #else
/* Cdigo a compilar en el segundo caso*/ ... #endif
El preprocesador: Ejemplo #define TALLA 100 #define FALSE 0 #define TRUE !FALSE #define max(a,b) ((a)>(b))?(a):b)) i=1; condicion=TRUE; mayor=0; while (condicion==TRUE && i<TALLA) { printf(Introduzca un valor:); scanf(%d, &num); if (num<=0) condicion=FALSE; else mayor=max(mayor, num); } i=1; condicion=!0; mayor=0; while (condicion==!0 && i<100) { printf(Introduzca un valor:); scanf(%d, &num); if (num<=0) condicion=0; else mayor=((mayor)>(num)) ? (mayor):(num); }
5. Tipos de datos estructurados 1. Vectores. 2. Vectores n-dimensionales. 3. Funciones para el manejo de bloques de memoria. 4. Cadenas de caracteres. 5. Vectores y punteros. 6. Estructuras. 7. Uniones.
8. El tipo enumerado. 9. Argumentos de la funcin main. 10.Memoria dinmica. Vectores Un vector es un conjunto de elementos del mismo tipo que se sitan en posiciones contiguas de memoria. Declaracin: tipo nombre [tamao]; int vector_enteros [20]; char vector_caracteres[30]; El primer elemento de un vector es el 0: int a[2]; "a[0], a[1] Los elementos de un vector de tamao n van desde el 0 hasta n-1. Al igual que para cualquier variable, el operador & permite saber la direccin de memoria que ocupa un elemento: &a[5]"Direccin del 6 elemento del vector a int int int int ... int
Vectores El nombre de un vector es la direccin de memoria donde se encuentra: a==&a[0] La direccin del i-simo elemento de un vector es: &a[i] == a+i El ndice que aparece entre corchetes puede ser cualquier expresin que d como resultado un valor entero. Los vectores externos y estticos pueden ser inicializados: int vi [5]={1,2,3,4,5}; Cuando se pasa un vector a una funcin se pasa su direccin (referencia): f(a);
Vectores n-dimensionales Declaracin: tipo nombre [tamao1][tamao2][tamao n]; Cuando en C se declara un vector como el siguiente: float mf[10][30]; Se est declarando un vector de 10 elementos, donde cada elemento es un vector de 30 floats. Cada uno de los 10 vectores puede ser tratado individualmente: mf[9][5] " Un float. mf[5] " Un vector de floats. mf " Un vector de vectores de floats. El posicionamiento de los 10 vectores sigue siendo adyacente. Vectores n-dimensionales /* Programa que encuentra el mximo en un vector */ #include <stdio.h> void PedirElementos ( int v[], int n); int Mayor (int v[], int n); void main (void) { int vector[10]; Pedir Elementos (vector, 10); printf (El mximo es: %d\n, Mayor (vector, 10); } void PedirElementos ( int v[], int n) { int i; for (i=0; i<n; i++) scanf (%d, &v[i]); } int Mayor (int v[], int n) { int i, maxim=-32000; for(i=0; i<n; i++) if (maxim<v[i]) maxim=v[i]; return maxim; }
Vectores n-dimensionales /* Operaciones con vectores bidimensionales */ #include <stdio.h> void RellenaVector ( long v[], int l, int val); void RellenaMatriz ( long m[][10], int l, int a, int val); void VisualizaVector (long v[], int l); void VisualizaMatriz (long m[][10], int l, int a); void main (void) { long v1 [10]; long v2 [5][10]; RellenaVector (v1, 10, 0); RellenaMatriz (v2, 5, 10, 0); VisualizaVector ( v1, 10); VisualizaMatriz ( v2, 5, 10); } void RellenaVector ( long v[], int l, int val) { register int i; for (i=0; i<l; i++) v[i]=val; } void RellenaMatriz ( long m[][10], int l, int a, int val) { register int i; for (i=0; i<l; i++) RellenaVector (m[i], a, val); } /* Intentad completar las funciones de visualizacin */
Funciones para el manejo de buffers memcpy Copia n bytes de s a d void *memcpy(void *d,void *s,size_t n); memchr Busca el carcter c en n bytes de s void *memchr(void *s,int c,size_t n); memcmp Compara n bytes de s1 y s2 int memcmp(void *s1, void *s2,size_t n); memset Pone c en n caracteres de s void *memset(void *s,int c,size_t n);
Cadenas de caracteres Las cadenas de caracteres son agrupaciones de caracteres posicionados sobre un vector de tipo char. Las cadenas de caracteres tienen
siempre un carcter final ASCII 0 que delimita los caracteres que pertenecen a la cadena. Inicializacin: char cadena [8]=Hola; H o l a \0 Funciones para el manejo de cadenas strcpy Copia un string en otro char *strcpy(char *destino, char *origen); strcat Aade un string a otro char *strcat(char *destino,char *origen); strchr Busca un carcter char *strchr(char *s, int c); strcmp Compara dos strings int strcmp(char *s1, char*s2); strlen Calcula la longitud size_t strlen (char *s); strstr Busca un string en otro char *strstr(char *s1, char *s2);
Vectores y punteros El nombre de un vector es la direccin donde empieza el vector. Por lo tanto, el nombre de un vector es un puntero constante. int vector[10]; int *p; p=vector; p[6]=6; *(p+3)=3; *(vector+2)=2; p++; vector++; vector=p; Asignar a p la direccin del vector Se puede usar p como un vector, pues es una direccin, igual que vector p+3 y vector+2 son direcciones *(p+3) y *(vector+2) son las variables apuntadas por las
direcciones p pasa a apuntar al siguiente elemento de vector No se puede modificar vector, pues es constante
Vectores y punteros char * strcpy (char s[], char t[]) { int i=0; while ((s[i]=t[i])!=\0) i++; return s; } char *strcpy (char *s, char *t) { while ((*s++=*t++)!=\0); return s; } int capicua (char *s) { char *p, *q; for (p=s, q=s+strlen(s)-1; *p==*q && q>p; p++, q--); return p>q; }
Estructuras Una estructura (struct) es un conjunto que comprende una o ms variables que pueden ser de distinto tipo, y que se agrupan bajo el mismo nombre. Declaracin: struct dir { int numero; char calle[16]; long codigoPostal; char ciudad [15]; }; trust cuenta { long numero; char nombre [18]; struct dir direccion;
} variableCuenta;
Estructuras Inicializacin struct familia { char apellido[10]; char nombrePadre[10]; char nombreMadre[10]; int numeroHijos; } fam1={"Garca", "Juan", "Carmen", 3}; struct familia fam2={"Pitarch", "Ramn", "Amparo", 7}; Operaciones sobre estructuras: Para acceder a un campo de una estructura se emplea el operador punto . fam2.numeroHijos=8; La direccin de una estructura se obtiene mediante el operador &. struct familia *pf; pf=&fam2; Si pf es un puntero a una estructura, se puede acceder a los campos de dos formas: (*pf).numero Hijos=9; pf->numero Hijos = 9; Uniones Una unin es un conjunto de elementos de los que slo puede contener uno de ellos en un momento dado. Permite manipular datos de distintos tipos y diferentes tallas usando una nica zona de memoria. union datos { int i; char c [5]; } unionEjemplo; Se accede a los campos de igual manera que en los struct.
Tipo enumerado Permite definir una lista de constantes bajo un nombre de tipo. Definicin: enum arcoiris { rojo, amarillo, verde, azul}; enum semana {lunes=1, martes, miercoles}; Rojo=0, amarillo=1, etc. lunes=1, martes=2, etc
Argumentos de la funcin main La funcin main puede recibir parmetros que vienen de la llamada al programa. Un programa puede recibir tantos argumentos como se desee, pero la funcin main slo recibe 2: El primer argumento es un entero que indica el nmero de parmetros que ha recibido el programa. Siempre el primer argumento es el nombre del programa, por lo que todo programa tiene al menos un argumento. El segundo y ltimo parmetro es un vector de cadenas de caracteres, donde cada cadena es uno de los parmetros recibidos por el programa. int main (int argc, char *argv[]) { int i; for (i=0; i<argc; i++) printf("Argumento %d=%s\n", i, argv[i]); return 0; }
Memoria dinmica La reserva de memoria en C se hace mediante la funcin malloc. La reserva de memoria se realiza en los siguientes pasos:
Se pide un bloque de memoria de n bytes. El gestor de memoria marca como reservado un fragmento de memoria que est libre y lo apunta en la tabla de asignacin de memoria. El gestor de memoria devuelve la direccin de memoria donde a localizado el bloque reservado. Que un bloque est reservado significa que nadie, que no sea el proceso que lo ha reservado, puede escribir en l. Se garantiza la integridad de los datos all almacenados. Si metemos datos en una direccin no reservada: No hay garanta de que no sean sobrescritos. Si no se sabe donde se est escribiendo, se puede causar un error de ejecucin.
Memoria dinmica La liberacin de memoria en C se hace con la funcin free. Liberar un bloque de memoria significa que ya no se garantiza la integridad de los datos que all estn almacenados. Slo se debe liberar un bloque de memoria cuando ya no se vaya a hacer uso de los datos all almacenados. struct datos { int v1: char vect[30]; }; ... struct datos *p; p=(struct datos *)malloc(sizeof(struct datos)); ... free (p);
Memoria dinmica
#include<stdio.h> #include<stdlib.h> #include<conio.h> typedef struct { int tam; int ult; int *mem; } pila; void Insertar ( pila *pp); void Extraer ( pila *pp); void main ( void ) { pila p; char num; printf ("Tamao de la pila:\n"); scanf ("%d", &p.tam); p.mem=(int *) malloc(sizeof(int)*p.tam); p.ult=0; num='1'; while ( num!='0') { num=getch(); switch(num) { case '0': break; case '1': Insertar (&p); break; case '2': Extraer (&p); break; } } free (p.mem); }
Memoria dinmica void Insertar(pila *pp) { if (pp->ult==pp->tam) { printf("P. llena\n"); return; } printf("Valor: "); scanf ("%d", &(pp->mem[pp->ult])); pp->ult++; } void Extraer(pila *pp) {
if (pp->ult==0) { printf("P.vacia\n"); return; } pp->ult--; printf("El valor es: %d\n", pp->mem[pp->ult]); } Memoria dinmica #include <stdio.h> #include <conio.h> #include <stdlib.h> #define FALSE 0 #define TRUE !0 typedef struct lista { int info; struct lista *next; } LISTA; void Insertar ( LISTA **, LISTA **); void Extraer (LISTA **, LISTA **); void Liberar Lista (LISTA **); char menu (void); void main ( void ) { LISTA *Cabeza; LISTA *Cola; int salir=FALSE; Cabeza=NULL; Cola=NULL; while (!salir) { switch(menu()) { case ' 0': salir=TRUE; break; case '1': Insertar (&Cabeza, &Cola); break; case '2': Extraer (&Cabeza, &Cola); break; } } LiberarLista (&Cabeza); } Memoria dinmica void Insertar (LISTA **PCap, LISTA **PCola) { LISTA *aux;
aux=(LISTA *)malloc(sizeof(LISTA)); printf("Introduzca un valor:"); fflush(stdin); scanf("%d", &aux->info); aux->next=NULL; if(*PCola) { (*PCola)->next=aux; *PCola=aux; } else *PCap=*PCola=aux; } void Extraer (LISTA **PCap, LISTA **PCola) { LISTA *aux; if (*PCap==NULL) { printf ("La lista est vaca\n"); return; } printf("El valor es %d\n", (*PCap)->info); aux=*PCap; *PCap=(*PCap)->next; if (*PCap==NULL) *PCola=NULL; free (aux); } Memoria dinmica void LiberarLista (LISTA **PCap) { LISTA *aux; while (*PCap!=NULL) { aux=*PCap; *PCap=(*PCap)->next; free(aux); } } char menu (void) { char c; do { printf("0...Salir\n"); printf("1...Insertar\n"); printf("2...Extraer\n"); c=getch();
} while (c<'0' || c>'2'); return c; }
Entrada/salida en C 1. Streams. 2. Algunas funciones de E/S. 3. Archivos. Streams Se distinguen dos tipos de streams: Texto Binarios Existen varios streams que siempre estn definidos en C: stdin stdout stderr Programa stream Dispositivo fsico o lgico
Funciones de E/S La funcin de salida ms significativa es printf: printf (cadena de control, lista de variables); La cadena de control puede contener caracteres de formato: Cdigo de formato Significado d nmero entero l nmero entero largo o nmero octal u nmero entero sin signo x nmero hexadecimal e float o double notacin exponencial f float o double notacin decimal g el ms corto de e o f s cadena de caracteres c carcter individual - ajustar a izquierda
nmero amplitud del campo . (punto) nmero amplitud del campo detrs del punto decimal
Funciones de E/S Dadas las siguientes declaraciones: int i = 1001; float x = 543.456; char a = 'A'; char c [ 11 ] = "1234567890"; Se obtendrn las siguientes salidas para cada llamada a printf: printf ("i =%d, x =%f, a =%c, c =%s|\n", i, x, a, c); i =1001, x =543.455994, a =A, c =1234567890| printf ("i =%3d, x =%3f, a =%3c, c =%3s|\n", i, x, a, c); i =1001, x =543.455994, a = A, c =1234567890| printf ("i =%15d, x =%15f, a =%15c, c =%15s|\n",i,x,a,c); i = 1001, x = 543.455994, a = A, c = 1234567890| printf ("i =%.2d, x =%.2f, a =%.2c, c =%.2s|\n", i, x, a, c); i =1001, x =543.46, a =A, c =12| printf ("i =%.12d, x =%.12f, a =%.12c, c =%.12s|\n", i,x,a,c); i =000000001001, x =543.455993652344, a =A, c =1234567890|
Funciones de E/S Otras funciones de salida son: int i; char mensaje[60]=Los caracteres del 32 al 128; puts(mensaje); for (i=32; i<=128; i++) putchar(i); Nombre Accin Prototipo putchar() Escribe un carcter int putchar(int ch); puts() Escribe una cadena int puts(const char *s);
Funciones de E/S La contrapartida a printf para entrada de datos es scanf: scanf (cadena de control, lista de variables); Su formato es similar al de printf.
Se ha de pasar la direccin de las variables. Una cadena de caracteres ya es una direccin. scanf(%s, cadena); A menudo es necesario utilizar la funcin fflush para limpiar el buffer de entrada, de manera que scanf no recoja basura. fflush(stdin); scanf(%c, &carcter); Otras funciones de entrada son: Nombre Accin Prototipo getchar() Lee un carcter int getchar(); gets() Lee una cadena char *gets(char *s);
Archivos Para manejar un archivo se debe declarar un FILE *. fopen abre un fichero: FILE *fp; fp=fopen(FICHERO.TXT, rb); if(!fp) printf(ERROR\n); Existen 6 modos bsicos de apertura: Lectura " r Escritura " w Aadir " a Lect./escrit. " r+ (Debe existir) Lect./escrit. " w+ (Crea o trunca) Lect./aadir " a+ (Crea el fichero) Estos modos se multiplican por 2, pues podemos abrir en texto o binario. texto: rt, wt, at, r+t, w+t, a+t binario: rb, wb, ab, r+b, w+b, a+b
Archivos Cerrar un fichero: fclose(fp); Escribir un carcter: putc(c, fp);
Leer un carcter: c=getc(fp); Escribir una cadena con formato: fprintf(fp, %d, i); Leer una cadena con formato: scanf(fp, %d, &i); Escribir un bloque de bytes: int v[30]; fwrite (v, sizeof(int), 30, fp); Leer un bloque de bytes: int v[30]; fread (v, sizeof(int), 30, fp); Saber si hubo error de final de fichero: i=feof(fp); Desplazamiento en el fichero: fseek(fp, offset, donde); offset es un long y donde puede valer: 0,1,2.
Archivos #include <stdio.h> #include <strength> #include <stdlib.h> void main(void) { FILE *stream; char ms[] = "Prueba de un ejemplo con fread/fwrite"; char buf[20]; if ((stream = fopen("NADA.FIL", "w+")) == NULL) { fprintf(stderr, "No se puede abrir el fichero.\n"); return 1; } /* escribimos datos en el fichero */ fwrite(msg, strlen(msg)+1, 1, stream); /* localizamos el principio del fichero */ fseek(stream, SEEK_SET, 0); /* leemos los datos y los mostramos en pantalla */ fread(buf, strlen(msg)+1, 1, stream); printf("%s\n", buf); fclose(stream); }
Archivos #include <stdio.h>
long filesize(FILE *stream); void main(void) { FILE *stream; stream = fopen("FICHERO.TXT", "w+"); fprintf(stream, "Prueba del fichero"); printf("Tamao del fichero FICHERO.TXT: %ld bytes\n", filesize(stream)); fclose(stream); } long filesize(FILE *stream) { long curpos, length; /* recuperamos y guardamos la posicin actual del puntero del fichero */ curpos = ftell(stream); printf("El puntero del fichero esta en byte %ld\n", curpos); /*situamos el puntero en la situacin final 'SEEK_END' */ fseek(stream, 0L, SEEK_END); /* obtenemos el byte de la posicin final y devolvemos el puntero a la posicin que tena antes de la llamada a esta funcin */ length = ftell(stream); fseek(stream, curpos, SEEK_SET); return length; } Archivos #include <stdio.h> void main () { FILE *fp; int i, j; fp = fopen ("Fichero.bin", "wb"); for ( i = 0; i < 10; i++) fwrite (&i,sizeof(int),1, fp); fclose ( fp ); fp = fopen ("Fichero.bin", "rb"); fread (&j, sizeof ( int ), 1, fp); while (!feof(fp)) { printf ("%d\n", j); fread (&j, sizeof(int),1,fp); } fclose ( fp ); fp = fopen ("Fichero.txt", "w"); for ( i = 0; i < 10; i++) fprintf (fp,"%d\n",i); fclose ( fp ); fp = fopen ("Fichero.txt", "r"); fscanf (fp,"%d",&j);
while (!feof(fp)) { printf ("%d\n", j); fscanf (fp,"%d",&j); }f close ( fp ); }

Lenguaje C Wor para Enviar A Ingirs Por Escrid

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Lenguaje C Wor para Enviar A Ingirs Por Escrid

Diunggah oleh

Hak Cipta:

Format Tersedia

Republica Bolivariana de Venezuela Ministerio del P.P.

Facilitadora: Prof. Ingris Manaure

Participante: Garca P. Jos R.

Ciudad Bolvar, 19 de Abril de 2012.

Elementos bsicos del lenguaje c

Elementos bsicos del lenguaje

Elementos bsicos del lenguaje

Tema Funciones definidas por el usuario

Elementos bsicos del Lenguaje

Funciones definidas por el usuario

Elementos bsicos del lenguaje

ni regresar algn valo

Estructura general de un programa en C

LISTA DE VALORES REPRESENTADOS POR IDENTIFICADORES EJEMPLO : enum semana

string cadena de caracteres salto de lnea tabulador a la derecha

Entrada de 5 2.3 b 5 , 23.4 , b 5 : 23.4 : b

a Direccin de memoria de la variable a

printf (\n\nNombre y Apellidos: %s %s ,nombre,apellidos); }

} } #include < stdio.h > #define SI 1

Matriz de 104 enteros

Lista{0} Lista{1} Lista{2}

Ejemplo: Leer una lista de nombres y almacenarlos en un array

Funciones para el manejo de cadenas Librera <strength>

%i Decimal %e %f Notacin cientfica 5e-3 Coma flotante

%g utiliza el ms corto de %e o %f. %o %s Octal Cadena de caracteres

Constantes Constantes cadena: Representacin: una secuencia de

con un tipo que se indica explcitamente. x=(unsigned int) (y/655)%32;

Funciones Existen dos formas de declarar

Tipos de variables: auto Las variables automticas se definen

Tipos de variables: register

/* Cdigo a compilar en el segundo caso*/ ... #endif

} while (c<'0' || c>'2'); return c; }

Archivos Cerrar un fichero: fclose(fp); Escribir un carcter: putc(c, fp);

Archivos #include <stdio.h>

while (!feof(fp)) { printf ("%d\n", j); fscanf (fp,"%d",&j); }f close ( fp ); }

Anda mungkin juga menyukai