introduccion a c

Introducción al Lenguaje C (ANSI)

Un poco de Historia

Fue inventado por Dennis Ritchie en un DEC-PDP-11 en los Laboratorios BELL, basándose en el lenguaje B, creado por Ken Thompson.

En 1983 el Instituto de Estándares Americanos estableció un estándar que definiera al lenguaje C, conocido como ANSI C.

Los principales compiladores de C llevan implementado el estándar ANSI C.

Características del Lenguaje C

Se cataloga como un lenguaje de nivel medio, puesto que combina elementos de lenguajes de alto nivel (Fortran, Pascal, Basic, etc.) con la funcionalidad del lenguaje ensamblador.

Permite el manejo de bits, bytes y direcciones de memoria.

Posee sólo 32 palabras clave, definidas por el comité ANSI.

32 Palabras Reservadas

char void default return

int if break auto

float else continue extern

double do goto register

long while struct const

short for union static

signed switch enum volatile

unsigned case typedef sizeof

Autor: ycarruido 1 12/04/2023

Elementos de un Programa en C ANSI

Comentarios. Identificadores. Constantes. Variables. Operadores. Sentencias o instrucciones. Macros del pre-procesador.

Comentarios

Comentarios multi-líneaComienzan con /* y terminan con */

No puede anidarse un comentario dentro de otro.

Comentarios de una sola línea (C++, Java, Delphi).

Comienzan al principio de la línea con //Ejemplo:

//Esto es un comentario/* Esto también es

un comentario */

Identificadores

Se utilizan para nombrar variables, funciones, etiquetas y elementos definidos por el usuario.

Los primeros seis caracteres deben ser significativos (distinguirse de otro similar) y máximo puede tener hasta 31 caracteres.

El primer carácter debe de ser una letra o subguión.

Posteriormente pueden ser letras, números, signos de subrayado.

Existe diferencia entre mayúsculas y minúsculas.No pueden emplearse palabras reservadas como identificadores.

No pueden emplearse nombres de funciones que ya existan en el programa o en la librería de funciones de C.

No puede llamarse main


ConvencionesEmpezar los nombres de funciones y de variables con una letra minúscula.

Las constantes escritas con #define van con mayúsculas como #define PI 3.1416Las palabras intermedias comienzan con mayúsculas.

sumaMatricesUtilizar el subguión para separar palabras intermedias.

suma_MatricesEmplear nombres cortos para optimizar. (i, j, k, cont)

ConstantesConstantes de carácter.

Ej. ‘a’, ‘0’, ‘\0x5’, ‘\0’, ‘\n’, ‘\t’, ‘$’, ’\\’, NULL

Constantes enteras.Ej. 5, +5, -5, \05, \0x5, 5L, 5U, 5lu, etc.

Constantes reales.Ej. 0.5f, 0.5, 5e-01f, 5.0e-01, (float)5, etc.

Constantes de texto (Cadenas o “Strings”)“Esto es una cadena…”

#defineSe utiliza para asignar un identificador a una constante.#define PI 3.1416#define NCOLS 20

El pre-procesador de C, sustituye la ocurrencia de PI por el valor 3.1416 en todo el programa antes de efectuar la compilación, del mismo modo se sustituye NCOLS por 2.

VariablesUna variable es una localidad de memoria cuyo valor puede ser cambiado durante la ejecución del programa.

Todas las variables deben de ser declaradas para se utilizadas.

<tipo de dato> espacio(s) <identificador>;

Ejemplo:int a;


float area, radio, volumen;

const

Es un modificador de acceso que me permite asignar a una variable un valor constante, es decir que una vez asignado a dicha variable su valor no podrá ser modificado durante el programa.

const <tipo dato> esp <identificador> = valor;Ejemplo:const int a=10;const char pais[]=“MÉXICO”;const char *nombre=“VLADIMIR”;

Operadores

Son palabras o símbolos que implican una acción sobre ciertas variables. Pueden ser unarios (1 variable), binarios (2 variables) o ternarios (3 variables).

Operadores Aritméticos Operadores Relacionales Operadores Lógicos Operadores de Asignación Operadores de Dirección Operadores de Bits

Operadores AritméticosOperador Nombre Descripción+ Suma 5+2 → 7- Resta 5-2 → 3

* Multiplicación 5*2 → 10/ División 5/2 → 2% Módulo 5%2 → 1(tipo de dato) “Cast” forzado (double)5 →

5.0

Operadores Relacionales


Operador Nombre Descripción

== Igual a if (a==‘s’)

!= Diferente de if (a!=null)

> Mayor que if (a>0.5)

< Menor que if (a<2l)

>= Mayor o igual que if (a>=2f)

<= Menor o igual que if (a<=3)

Operadores LógicosOperador Nombre Descripción

&& Y (AND) if ((a>3) && (a<9))

|| O (OR) if ((a==2) || (a==3))

! NEGADO (NOT) if (!(a==3)) es igual aif (a!=3)

Importante: FALSO es igual a cero.VERDADERO es diferente de cero

Operadores de Asignación


Operador Abreviado No Abreviado

= a=2; a=2;

++ n++; n=n+1;

-- n--; n=n-1;

+= n+=2; n=n+2;

-= n-=2; n=n-2;

*= n*=2; n=n*2;

/= n/=2; n=n/2;

%= n%=2; n=n%2;

Operadores de BitsOperador Nombre Descripción

<< Corrimiento a la izquierda

b=a>>2;

>> Corrimiento a la derecha

b=a<<3;

& Y (AND) entre bits

c=a&128;

| O (OR) entre bits c=a|0x0a;

~ Complemento A1 c=~a;

^ O exclusivo (XOR) c=^a;

Operadores de Asignaciónpara bits


Operador Abreviado No Abreviado

<<= n<<=2; n=n<<2;

>>= n>>=2; n=n>>2;

&= n&=0x0a; n=n&0x0a;

|= n|=7; n=n|7;

^= n^=0x03; n=^0x03;

= n=0x7f; n=0x7f;

Operadores De DirecciónOperador Nombre Descripción* Operador

indirección

Me da el valor que está almacenado en una dirección de memoria.También sirve para

declarar una variable apuntador.

& Operador dirección

Me da la dirección de memoria de una

variable.

Variables ApuntadorSirven para almacenar una dirección de memoria.Utilizan el operador & para obtener la dirección.Se deben inicializar con NULL (equivale a cero).Se declaran como:

<tipo de dato><*> espacio(s) <identificador>;Ejemplo:int *a=NULL;int b=2,c=1;a=&b; /*Guarda la direc. de b en a */c=*a; /*c vale 2 */

Precedencia de Operadores

( ) [ ] -> Alta prioridad ! ~ + - ++ -- & * Unarios


sizeof * / % + - Aritméticos

<< >> Corrimiento de bits< <= > >= == != Relacionales& ^ | && || ?: Bits / Lógicos /

Condicional = *= /= %= += -= &=

^= |= <<= >>= Asignación

, Evaluación

Sentencias (Instrucciones)

Una sentencia es una instrucción o expresión en C que tiene una consecuencia. Pueden ser asignaciones, operaciones, llamadas a funciones.

Todas las sentencias terminan con el signo de punto y coma ;Pueden ser simples o compuestas. Las compuestas van entre llaves:

{ sentencia1; sentencia2; : sentencian; }

Sentencias de Selección.if – else, switch – case, ?:

Sentencias de Repetición.do – while, while, for

Sentencias de Salto. return, break, continue

Estructura de un programa en C


I. Directivas del pre-procesador#include y #define

II. Declaración de Prototipos(Declaración de funciones)

III. Declaración de variables globales

IV. Funciones definidas por el usuario

V. Función Principal main( )

Ejemplos de un Programa en C

#include <stdio.h> // Librería: printf, getchar

main() // Función Principal{ printf("Hola mundo!"); // Imprime en pantalla getchar(); // Pausa: espera tecla ENTER return 0; // Termina con éxito}

-----------------------------------------------------------

#include <stdio.h>#include <math.h>#define VALOR 5.7

double modulo3D( double x, double y, double z );double mod3; /* Variable global */

double modulo3D( double x, double y, double z ){ return(sqrt(x*x+y*y+z*z);}

int main( void ){ int x, y, z; x=y=z=VALOR; mod3=modulo3D(x,y,z); printf(“\nEl módulo es: %lf”,mod3); return(0);}


-----------------------------------------------------------

#include <stdio.h>#define FACTOR 2int doble(int valor);int main(){int indice = 2;printf(“El doble de %d es %d\n”, indice, doble(indice));return 0;}int doble(int valor){return (valor * FACTOR);}

Sentencia if-else

if (expresión) sentencia;else sentencia;

Nota: una expresión en C es todo aquello que regresa un valor. Como por ejemplo una condición lógica, operaciones aritméticas, llamadas a funciones, una variable, una constante (númérica, carácter, etc.).

if (expresión) { sentencia1; sentencia2; }else { sentencia1; sentencia2; }

Sentencia switch-case

switch(expresión)


{ case 1: sentencias; break; case 2: sentencias; break; : case n: sentencias; break; default: sentencias_default; break; }

Arreglos Unidimensionales

Los arreglos unidimensionales son secuencias de valores del mismo tipo que se almacenan en localidades contiguas de memoria, según el orden del índice.<tipo dato> esp <identificador>[tamaño];

Ejemplo:

int valores[10];float datos[5]={1.3,2.8,4.89,0.0,5.7};char pais[]=“MÉXICO”;char *nombre=“VLADIMIR”;

Un arreglo se identifica por su nombre, pero para el compilador este equivale a la dirección del primer elemento del arreglo, es decir:

Ejemplo:int num[50];

Para el compilador:num es igual a &num[0]/* La dirección del elemento 0 */

Los índices son necesarios para desplazarse a través del arreglo. El primer elemento tiene el índice cero y el último el índice (tamaño-1).Se deben utilizar variables enteras y para agilizar el acceso a memoria se pueden declarar con el modificador register.Ejemplo:

int register i, j, k;


Para guardar o leer los elemento en un arreglo es muy frecuente utilizar la sentencia for.

Ejemplo:

int register i;int num[50];

/* Asigno al arreglo valores del 0 al 500 */for (i=0; i<50; i++) num[i]= i*10;

Para introducir los elemento en un arreglo con la función scanf se recomienda utilizar una variable auxiliar dentro de un ciclo for.

Ejemplo:

int register i;double datos[100];double temp;for (i=0; i<100; i++) { scanf(“%lf”,&temp); fflush(stdin); /* stdin=entrada estándar */ num[i]= temp; }

Un arreglo puede tener N dimensiones, dependiendo de las limitaciones de la memoria y su declaración es la siguiente:

<tipo dato> esp <identificador>[dim1] [dim2]…[dimN];

Ejemplo:double cubo[3][3][3];

Arreglos de Caracteres

Una cadena o “String” se manipula en lenguaje C, mediante arreglos de caracteres. Los arreglos de caracteres terminan con el carácter nulo ‘\0’ que en realidad es el valor cero.


La única diferencia con los arreglos numéricos es que se requiere un carácter adicional para indicar cuando el final del arreglo.

Ejemplo:char nombre[31]; /* Uso sólo 30 */

LA FUNCIÓN printf

Sintaxis: printf ("formato", var1, var2, ..., varN)

"formato": serie de caracteres. Secuencias especiales:

%d: escribir un entero; %o: escribir en octal; %x: escribir en hexadecimal; %u: escribir en entero sin signo; %ld, %lo, %lx: lo mismo solo que para un long; %hd, %ho, %hx: lo mismo solo que para un short; %c: hace referencia a un caracter; %f, %lf: escribir un flotante o doble; %%: escribir caracter '%';

LA FUNCIÓN scanf

Sintaxis: scanf("formato", &var1, &var2, ..., &varN)

"formato": debe contener una las secuencias siguientes:

%d, %o, %x: se refiere a un decimal, octal o hexadecimal;

%ld, %lo, %lx: lo mismo solo que para un long; %hd, %ho, %hx: lo mismo solo que para un short; %c: hace referencia a un caracter; %f, %lf: referencia a un float o double


Ejercicios

Programa que convierte de metros a pies y pulgadas.

#include stdio.h

main(){float metros,resul,pulg;int resul2,pulg2;clrscr();

printf("\nValor en metros: ");scanf("%f",&metros);resul=metros*(1/.3048);resul2=resul;pulg=resul-resul2;pulg=pulg*12;pulg2=pulg;printf("El resultado es: %d pies %d pulgadas",resul2,pulg2);

getch();}

Programa que realiza las cuatro operaciones aritméticas fundamentales

#include stdio.h#include conio.h

void main(){int prim,seg,resul;char oper;

clrscr();

printf("\nPrimer numero: ");scanf("%d",&prim);printf("\nOperacion a realizar (+,-,*,/): ");oper=getche();printf("\nSegundo numero: ");scanf("%d",&seg);

if(oper=='+')resul=prim+seg;if(oper=='-')resul=prim-seg;if(oper=='*')resul=prim*seg;if(oper=='/')


resul=prim/seg;

printf("\nEl resultado de la operacion %d %c %d es %d",prim,oper,seg,resul);getch();}

Programa que lee los tres lados de un triángulo y detecta el tipo.#include stdio.h

main(){

float uno,dos,tres;clrscr();

printf("\nValor del primer lado: ");scanf("%f",&uno);

printf("\nValor del segundo lado: ");scanf("%f",&dos);

printf("\nValor del tercer lado: ");scanf("%f",&tres);

if((uno==dos) && (dos==tres) && (uno==tres))printf("\nEl triangulo es equilatero");

else if((uno!=dos) && (dos!=tres) && (uno!=tres))printf("\nEl triangulo es escaleno");

elseprintf("\nEl triangulo es isoceles");

getch();}


Programa que lee las edades de un grupo de alumnos y encuentra el promedio.

#include stdio.h

main(){int alumnos,edad,counter=1;float promedio,sumaedad=0;clrscr();

printf("\nNumero de alumnos: ");scanf("%d",&alumnos);

while(1){

printf("\nEdad alumno %d: ",counter);scanf("%d",&edad);

sumaedad=sumaedad+edad;if(counter==alumnos){break;}counter++;}promedio=sumaedad/counter;printf("\nLa edad promedio de %d alumno(s) es %.1f años",counter,promedio);

getch();}


Función que lee calificaciones (0-10) de alumnos y cuente el número de alumnos reprobados, (calif<7) de un conjunto de notas. La función recibe como parámetro el número de notas a leer y deberá regresar el número de alumnos reprobados. Crear un programa que llame a la función anterior y que despliegue el número de alumnos reprobados.

#include stdio.h

int numreprob(int not);

void main(void){int notas,reprobados;clrscr();

printf("\nNumero de notas a leer: ");scanf("%d",& notas);reprobados=numreprob(notas);printf("\nExiste un total de %d alumnos reprobados",reprobados);getch();}

int numreprob(int not){

int c=1,calif,rep=0;

while(c<=not){

printf("\nCalificacion de la nota %d: ",c);scanf("%d",&calif);

if(calif<7){rep++;}

c++;}return(rep);}


Función que lee las matrículas (números enteros) y las calificaciones (tipo char) de los alumnos de un grupo y las almacene en dos arreglos unidimensionales. La función deberá leer los datos hasta que se de una matrícula cero la cual indica el fin de captura. La función regresa el número de alumnos por el mecanismo de return. Después debe de imprimir el contenido de los arreglos.

#include stdio.h

void despliega(int *mats,char *califs,int numcap);int leedato(int *mats,char *califs,int maximo);

void main(void){int max=30,matr[29],numalumn;char calif[29];

clrscr();

numalumn=leedato(matr,calif,max);printf("\nEl numero de alumnos capturados es %d",numalumn);despliega(matr,calif,numalumn);

}int leedato(int *mats,char *califs,int maximo){

int n=0;

printf("\n *** Introduce la matricula y su calificacion. ***");printf("\n *** Para terminar dale un cero a la matricula. ***");

while(1){

if(n>=maximo){printf("\nEl arreglo se encuentra lleno");getch();break;}printf("\n\nMatricula del alumno %d: ",n+1);scanf("%d",mats);

if(*mats==0){break;}printf("\nCalificacion del alumno %d: ",n+1);scanf("%d",califs);

mats++;califs++;


n++;}return n;}

void despliega(int *mats,char *califs,int numcap){

int i=1;

while(1){

if(i>numcap){break;}printf("\nLa calificacion del alumno %d es %d",*mats,*califs);i++;mats++;califs++;}getch();}

Programa que despliega una tabla de conversión de ºC a ºF y viceversa. El programa debe tener una función que pregunte el tipo de conversión deseada. El usuario tecleará "c" o "C" si la conversión va a ser de ºC a ºF y "f" o "F" si la conversión es de ºF a ºC, regresando el caracter leído por medio de return. Otra función preguntará el rango de valores de la tabla y el incremento, recibiendo como parámetros las direcciones de las variables donde se almacenarán esos datos. Otras dos funciones serán para desplegar cada tipo de tabla de conversión.

#include stdio.h#include ctype.h

void despliegaFC(int *ran1,int *ran2,int *inc);void despliegaCF(int *ran1,int *ran2,int *inc);void leeDatos(int *ran1,int *ran2,int *inc);char tipoConv(void);

void main(void){

int rango1,rango2,incremento;char tipo;clrscr();tipo=tipoConv();leeDatos(&rango1,&rango2,&incremento);


if(tipo=='C'){despliegaCF(&rango1,&rango2,&incremento);}else{despliegaFC(&rango1,&rango2,&incremento);}}char tipoConv(void){char caract;

printf(" TABLA DE CONVERSION DE GRADOS CENTIGRADOS A GRADOS FARENHEIT");printf("\n Y DE GRADOS FARENHEIT A GRADOS CENTIGRADOS");printf("\n\nPara convertir de Centigrados a Farenheit oprime 'C'");printf("\npara convertir de Farenheit a Centigrados oprime 'F'");

printf("\n\nTipo de Conversion (C o F): ");caract=toupper(getch());

return caract;}

void leeDatos(int *ran1,int *ran2,int *inc){

printf("\n\nValor inicial de la tabla: ");scanf("%d",ran1);printf("\nValor final de la tabla: ");scanf("%d",ran2);

printf("\n\nIncremento de los valores de la tabla: ");scanf("%d",inc);}

void despliegaCF(int *ran1,int *ran2,int *inc){

int suma=*ran1,incremento=*inc,rango2=*ran2;float conversion;

while(suma<=rango2){

conversion=(((suma)*9)/5)+32;printf("\n%d §C ----------------------------- %.1f §F",suma,conversion);

suma=suma+incremento;}getch();}


void despliegaFC(int *ran1,int *ran2,int *inc){

int suma=*ran1,incremento=*inc,rango2=*ran2;int conversion;

while(suma<=rango2){

conversion=((suma-32)*5)/9;printf("\n%d §F ----------------------------- %d §C",suma,conversion);

suma=suma+incremento;}getch();}

Ejemplos de cadenas. Función que realiza la misma operación que la función atoi, que convierte una cadena en un entero. La función regresa el entero representado por la cadena s si se pudo convertir, en caso contrario regresa 0. Si la función encuentra caracteres espacio o tabulación, los salta. Si al empezar la secuencia de dígitos, ésta se interrumpe, el programa termina.


int myatoi(char *s);

void main(void){

int n;char cad[50];clrscr();

printf("Introduce la cadena: ");gets(cad);n=myatoi(cad);printf("\nEl entero extraido de la cadena fue %d",n);getch();}

int myatoi(char *s){int signo=1,num=0;

while(1){if(*s==' ' || *s=='\t'){s++;}else break;


}if(*s=='+'){s++;}else if(*s=='-'){signo=-1;s++;}while(1){if(*s=='\0' || !isdigit(*s)){break;}num=10*num+(*s-'0');s++;}return signo*num;}

Ejemplos de cadenas. Función que realiza la misma operación que la función strlen. Calcula la longitud de la cadena S. Regresa el número de caracteres en S sin contar el caracter de fin de cadena.


int mystrlen(char *s);

void main(void){

int n;char cad[50];clrscr();

printf("Introduce la cadena: ");gets(cad);n=mystrlen(cad);printf("\nEl numero de caracteres de la cadena s fue %d",n);getch();}

int mystrlen(char *s){

int c=0;

while(1){if(*s=='\0'){break;}c++;


s++;}return c;}

Función que lee una serie de números de la línea de comandos y ejecuta la instrucción proporcionada después del último número de la serie. Si la instrucción es GUARDA, los números son guardados en un arreglo de tipo entero. Si la instrucción es LISTA, los numeros son desplegados como cadenas.

#include stdio.h#include ctype.h#include string.h#include stdlib.h

void main(int np, char *ps[]){int arreglo[100],j,i;clrscr();

if(strcmp(ps[np-1],"GUARDA")==0){for(i=0,j=1;j<(np-1);i++,j++){arreglo[i]=atoi(ps[j]);printf("\n%d",arreglo[i]);}}

if(strcmp(ps[np-1],"LISTA")==0){for(i=1;i<(np-1);i++){puts(ps[i]);}}

}

Programa que recibe en la línea de comando un número flotante, un caracter que represente una de las cuatro operaciones fundamentales y un segundo número. El programa deberá desplegar el resultado de la operación deseada.

#include stdio.h#include stdlib.h#include string.h

void main(int narg,char *sarg[]){float op1,op2,resul;int i=1;clrscr();


printf("PROGRAMA QUE CALCULA UNA OPERACION ARITMETICA SIMPLE ENTRE DOS OPERANDOS");printf("\n\nLa sintaxis es: Calcula operando operador operando");printf("\n");while(i<=narg){printf("%s",sarg[i]);i++;}

op1=atof(sarg[1]);op2=atof(sarg[3]);

if(strcmp(sarg[2],"+")==0)resul=op1+op2;else if(sarg[2][0]=='-')resul=op1-op2;else if(strcmp(sarg[2],"*")==0)resul=op1*op2;else if(sarg[2][0]=='/')resul=op1/op2;else{printf("\nOperador invalido: '%s'",sarg[2]);return;}printf("\n\nEl resultado es %.1f",resul);getch();

}

Editor de textos con arreglo de cadenas.

#include string.h

#include stdio.h

#include ctype.h

void inserta(char t[][50],int *ll,int act,int max);void modif_actual(int *act,int ll);void reemplaza_linea(char t[][50],int ll,int *act);void lista(char t[][50],int *ll);void agrega_linea(char t[][50],int *ll,int max,int *act);

void main(void){

char txt[30][50],opcion;int llenas=0,max=30,actual;

while(1){


clrscr();printf(" EDITOR DE TEXTO");printf("\n SELECCIONA LA PRIMERA LETRA DE LA OPCION DESEADA");printf("\n\nAgregar Salir Lista Reemplaza Inserta Opcion: ");

opcion=toupper(getch());if(opcion=='S')break;if(opcion=='A')agrega_linea(txt,&llenas,max,&actual);if(opcion=='L')lista(txt,&llenas);if(opcion=='R')reemplaza_linea(txt,llenas,&actual);if(opcion=='I')inserta(txt,&llenas,actual,max);}}

/**************************************************************************/void agrega_linea(char t[][50],int *ll,int max,int *act){if(*ll==max){printf("\n\nMemoria insuficiente...");return;}printf("\n\n>");fflush(stdin);gets(t[*ll]);*ll=*ll+1;*act=*ll;}

/**************************************************************************/

void lista(char t[][50],int *ll){

int i=0;printf("\n\n");

while(i<*ll){

puts(t[i]);i++;}getch();


}

/**************************************************************************/

void modif_actual(int *act,int ll){int v;

printf("\n\nIndica el numero de la linea a posicionar: ");scanf("%d",&v);

if(v<=ll && v!=0){*act=v;}else{*act=-1;}}

/**************************************************************************/

void reemplaza_linea(char t[][50],int ll,int *act){

if(ll==0){printf("\n\nNo existe informacion a reemplazar");getch();return;}modif_actual(act,ll);if(*act==-1){printf("\n\nLa linea seleccionada no existe...");getch();}

else{

printf("\n\nIntroduce la nueva linea: ");fflush(stdin);gets(t[*act-1]);}}

/*************************************************************************/

void inserta(char t[][50],int *ll,int act,int max){int j;


if(*ll==max){printf("\n\nMemoria insuficiente...");getch();return;}modif_actual(&act,*ll);

if(act==-1){printf("\n\nLa linea seleccionada no existe...");getch();}else{

j=*ll-1;

while(j>=act-1){strcpy(t[j+1],t[j]);j--;}printf("\n\nInserta la nueva linea: ");fflush(stdin);gets(t[act-1]);(*ll)++;}}

Directorio telefónico con manejo de archivos.

#include stdio.h#include conio.h#include ctype.h#include string.h#include stdlib.h

struct DIREC{ char nombre[35]; char tele[20];} ;

FILE *pack(FILE *a);void ordena(FILE *a);void consulta2(FILE *a);long busca_Clave2(FILE *a,char buscado[]);void lee(FILE *a);void imprime(FILE *a);

void main(){

char opcion; FILE *archivo;


archivo=fopen("TELE.DAT","rb+"); /* usar opción "wb+" para crear el archivo .DAT y después cambiar a "rb+" */

while(1){ clrscr(); textattr(6+5*5); clrscr(); textcolor(YELLOW); cprintf(" DIRECTORIO TELEFONICO"); printf("\n\n"); cprintf(" N"); printf("uevo"); textcolor(YELLOW); cprintf(" L"); printf("ista"); textcolor(YELLOW); cprintf(" B"); printf("aja"); textcolor(YELLOW); cprintf(" C"); printf("onsulta"); textcolor(YELLOW); cprintf(" O"); printf("rdena"); textcolor(YELLOW); cprintf(" S"); printf("alir");

gotoxy(1,25); printf(" *** PRESIONE LA LETRA RESALTADA PARA ESCOGER LA OPCION ***"); gotoxy(1,4); opcion=toupper(getch());

if(opcion=='S') break;

switch(opcion){case 'N':{ lee(archivo); break;}case 'L':{ imprime(archivo); break;}case 'B':{ pack(archivo); break;}case 'C':{


consulta2(archivo); break;}case 'O':{ ordena(archivo); break;}

} } clrscr(); fclose(archivo); normvideo(); clrscr();}

/*********************************************************************/

void imprime(FILE *a){ int r,y=0,c=1; struct DIREC reactivo; clrscr(); textcolor(YELLOW); cprintf("NOMBRE TELEFONO"); normvideo(); rewind(a); while(1){

r=fread(&reactivo,sizeof(struct DIREC),1,a);if(r==0) break;

if((c%2)!=0){ textattr(6+5*5); /* textcolor(LIGHTGRAY);*/ printf("\n"); cprintf("%d.- %-30s

%16s",c,reactivo.nombre,reactivo.tele); normvideo(); }

else{ textattr(6+5*4);

/* textcolor(WHITE);*/ printf("\n"); cprintf("%d.- %-30s

%16s",c,reactivo.nombre,reactivo.tele); normvideo();

}

if(y==23){


getch(); y=0;} y++; c++;

} getch();

}

/*********************************************************************/

void lee(FILE *a){ struct DIREC reactivo; printf("\n\n");

fflush(stdin); printf("Nombre : ");strupr(gets(reactivo.nombre));

if(strlen(reactivo.nombre)<30){

if(busca_Clave2(a,reactivo.nombre)==0){printf("Tel‚fono : ");gets(reactivo.tele);

fseek(a,0,SEEK_END);fwrite(&reactivo,sizeof(struct DIREC),1,a);

} else{ printf("\n\nYa existen esos datos!!!"); getch(); }} else{ printf("\n\nM ximo 25 letras por

nombre..."); printf("\n\nEl programa puede da¤arse si

repite este error!!!"); getch();

}}

/*********************************************************************/

long busca_Clave2(FILE *a,char buscado[]){ long p; struct DIREC r; rewind(a);

while(1){ if(fread(&r,sizeof(struct DIREC),1,a)==0)


break; if(strcmp(r.nombre,buscado)==0){ p=ftell(a)/sizeof(struct DIREC); return(p);}

}return 0;

}

/*********************************************************************/

void consulta2(FILE *a){ char nombre[30]; long p; struct DIREC r;

printf("\n\nDame el nombre a buscar: ");strupr(gets(nombre));

p=busca_Clave2(a,nombre);

if(p!=0){

fseek(a,(p-1)*sizeof(struct DIREC),SEEK_SET); fread(&r,sizeof(struct DIREC),1,a); printf("\n\n\n"); textcolor(LIGHTGRAY); cprintf("NOMBRE

TELEFONO"); normvideo(); printf("\n%-20s %30s",r.nombre,r.tele); getch();

}else{ printf("\n\nLa informaci¢n solicitada no

existe ..."); getch();}

}

/*********************************************************************/

void ordena(FILE *a){ int i=0,j=0,s,t; struct DIREC r; struct DIREC temp[100]; struct DIREC temporal;


while(1){fseek(a,i*sizeof(struct DIREC),SEEK_SET);if(fread(&r,sizeof(struct DIREC),1,a)==0)break; temp[j]=r; i++; j++;} for(s=0;s0){

temporal=temp[s];temp[s]=temp[t];temp[t]=temporal;

}

s=0; i=0; while(1){ if(s>=j) break;

r=temp[s];fseek(a,i*sizeof(struct

DIREC),SEEK_SET);fwrite(&r,sizeof(struct DIREC),1,a);s++;i++;

}printf("\n\nSus archivos han sido

ordenados alfab‚ticamente...");getch();

}

/*********************************************************************/

FILE *pack(FILE *a){ int i=0; long p; char clave[30]; struct DIREC r; FILE *t; t=fopen("TMP.DAT","wb");

printf("\n\nDame el nombre a dar de baja: ");strupr(gets(clave));p=busca_Clave2(a,clave);

if(p!=0){while(1){


fseek(a,i*sizeof(struct DIREC),SEEK_SET); if(fread(&r,sizeof(struct DIREC),1,a)==0) break; if(strcmp(r.nombre,clave)!=0){ fseek(a,i*sizeof(struct DIREC),SEEK_SET); fwrite(&r,sizeof(struct DIREC),1,t); } i++;} fclose(t); fclose(a); remove("TELE.DAT"); rename("TMP.DAT","TELE.DAT"); t=fopen("TELE.DAT","rb+");

printf("\n\nLa informaci¢n solicitada ha sido dada de baja...");

getch();return(t);

}else{ printf("\n\nNo existe el nombre..."); getch();} return 0;

}

Basicos

Ejemplo salida de datos

#include <stdio.h>

int main( ) { int i,j;

i=3; j=4; printf("Hola el mundo \n"); printf("Valor i:%d \nValor j:%d \n",i,j); }

/* Salida en pantalla:

Hola el mundo Valor i:3 Valor j:4 */

Ejercicios salida datos


1. Del programa anterior elimine los \n que aparecen y vea que sucede

2. Del programa anterior modifique la linea printf("Valor i:\%d \nValor j:\n%d",i,j); por printf("Valor i:\%d \nValor j:\n%d",i); y vea que sucede

Ejemplo captura de datos

/* Programa de ejemplo de captura de un entero corto, un entero y un flotante */

#include <stdio.h>

int main( ) { short s; int l; float f;

printf("Introduzca un entero corto, un entero y un flotante separados por un espacio: \n") scanf("%hd %d %f",&s,&l,&f);

}

/* Después de haber introducido -123 999 y 99.0044 <RET> las variables s,l, y f tienen los valores -123 999 y 99.0044 */

Ejercicios captura de datos

1. Del programa anterior borre todos los caracteres "&" de la función scanf( ) y vea que sucede.

2. El programa anterior no despliega lo captura, modifique el programa de tal forma que despliegue lo capturado.

3. Cambie la línea scanf("%hd %d %f",&s,&l,&f); por scanf("%hd,%d,%f",&s,&l,&f); y vea lo que sucede

4.

Prueba localidad variables

#include <stdio.h>


int global;

int main ( ) { int l1,l2;

printf("Introduzca tres valores enteros separados por un espacio:\n"); scanf("%d%d%d",&global,&l1,&l2); printf("Desplegado 1, valor de global,l1,l2:); printf("%d,%d,%d\n",global,l1,l2); { int global,l1; printf("Introduzca tres valores enteros separados por un espacio:\n"); scanf("%d%d%d",&global,&l1,&l2); printf("Desplegado 2, valor de global,l1,l2:"); printf("%d,%d,%d\n",global,l1,l2); } printf("Desplegado 3, valor de global,l1,l2:"); printf("%d,%d,%d\n",global,l1,l2); }

Ejemplo operaciones aritméticas enteras

/* Cálculo hora llegada de un vuelo */

#include <stdio.h>

int main(){

int hora, mins, segs; int tmpvol;

printf(''De hora salida vuelo (hh mm ss):''); scanf(''%d%d%d'',&hora,&mins,&segs); printf(''Tiempo vuelo (en segundos):''); scanf(''%d'',&tmpvol); segs = segs + tmpvol; mins = mins + segs / 60; segs = segs % 60; hora = hora + mins / 60; mins = mins % 60; hora = hora % 24; printf(''Hora estimada llegada:''); printf(''%d hrs %d mins %d segs \n'',hora,mins,segs);


}

/* Cálculo del área de un triángulo y círculo */

#include <stdio.h>

int main() {

float base, altura; float area; float radio, pi;

printf(''Valor de la base y altura:''); scanf(''%f%f'',&base,&altura); area = (base * altura)/2; printf(''El 'area del triangulo es: %f \n'',area); printf(''De el valor del radio:''); scanf(''%f'',&radio); pi = 3.151416; area = pi * radio * radio; printf(''El 'area del circulo es: %f \n'',area); }

Ejemplo operador condicional

/* Determina si un número es menor mayor o igual a cero */

#include <stdio.h>

int main(){ int x;

printf(''De el valor de x:''); scanf(%d'',&x); if (x <= 0) { if (x== 0) printf(''N'umero igual a cero \n'');


else printf(''Número MAYOR que cero \n''); } else printf(''Numero menor que cero \n''); }

/* Determina el número más grande de entre tres */

#include <stdio.h>

int main()

{ int i,j,k,mayor;

printf(''De los valores i j k : ''); scanf(''%d%d%d'',&i,&j,&k); if (i > j) mayor = j; else mayor = i;

if (mayor < k) mayor = k;

printf(''El mas grande de (%d,%d,%d) es: %d \n'',i,j,k,mayor) }

Ejercicios operador condicional

1. Escribir un programa que permita jugar a doble o nada: El jugador apuesta una cantidad y tira una moneda. Si sale cara obtiene el doble de la cantidad apostada. Si sale cruz la pierde todo.

2. Escribir un programa que lea tres valores enteros y muestre por pantalla el máximo y el mínimo de ellos.

3. Escribir un programa que, pida la fecha de nacimiento (dia y numero de mes) de una persona e imprima por pantalla su signo zodiacal


ESTRUCTURA GENERAL DEL switch

Estructura general del switch

switch (var) {

case c1: case c2: Bloque 1 Bloque 2 break; case c3: case c4: Bloque 3 Bloque 4 case c5: Bloque 5 case c6: case c7: case c8: Bloque 6 break; default: Bloque 7 } Bloque 8

Opcion default no obligatoria.

Ejemplo uso switch: un menu

#include <stdio.h>

int main(){ int opcion;

printf(''1> Mexico \n''); printf(''2> Francia \n''); printf(''3> Italia \n''); printf(''4> Inglaterra \n''); printf(''5> Barcelona \n''); printf(''Opcion: ''); scanf(''%d'',&opcion);


switch (opcion) { case 1: printf(''Bueno \n''); break; case 2: printf(''Allo \n''); break; case 3: printf(''Pronto \n''); break; case 4: printf(''Hello \n''); break; case 5: printf(''Digi \n''); break; } }

#include <stdio.h>

int main()

{ char letra; printf(''De una letra: ''); scanf(''%c'',&letra); switch (letra) { case 'a': case 'e': case 'i': case 'o': case 'u': printf(''Es una vocal minuscula\n''); break; case 'A': case 'E': case 'I': case 'O': case 'U': printf(''Es una vocal MAYUSCULA\n''); break; default: if( (letra>'a') && (letra<'z')) printf(''Consonante minuscula \n''); else printf(''Consonante MAYUSCULA \n''); } }Ejercicios

1. Escribir un programa que pida la nota de un examen (un nº real entre 0 y 10) e imprima en pantalla “Suspendido”, si la nota es menor que 5, “Aprobado” si está entre 5 inclusive y 7 sin incluir, “Notable” si está entre 7 inclusive y 9 sin incluir, “Sobresaliente” si está entre 9 inclusive y 10 sin


incluir y “Matrícula de honor” si la nota es igual a 1.

2. Escribir un programa que, dado el número del mes, y el año (hay que considerar si el año es bisiesto) saque por pantalla el número de dias del mes.


introduccion a c

Documents