#include <stdio.

h> main (void) /*Mi primer programa en C*/ { printf("hola amigos\n"); return 0; }

Observando nuestro primer programa, hay la funcin main que no contiene datos y nos los recibe tampoco, por eso la lista de parmetros est vaca. La funcin main contiene 2 instrucciones: 1. Llama a la funcin printf con el argumento ("hola amigos\n"), cuyo efecto es desplegar la cade3 na de caracteres hola amigos. 2. El comando return con el argumento 0, cuyo efecto es devolver el valor 0 como cdigo de error al ambiente. El argumento de la funcin printf es una cadena de caracteres indicada entre . Los smbolos \n al final de la cadena de caracteres es la notacin en C para indicar saltar a la siguiente lnea. En C existen algunas parejas de smbolos que controlan el despliegue o la impresin de textos. Estas son llamadas secuencias de escape, siempre estn precedidas por el carcter \. La funcin prinft forma parte de la biblioteca de funciones estndar <stdio.h> que maneja las entradas y salidas de datos. La primera lnea del programa #include <stdio.h> instruye al compilador de incluir el archivo de cabecera stdio.h en el texto del programa. Este archivo contiene las informaciones necesarias para poder utilizar las funciones de la biblioteca estndar stdio. Funciones.En C, el programa principal y los subprogramas estn definidos como funciones. No existen estructuras especiales para el programa principal ni para los procedimientos. El programa principal tambin es una funcin, y por eso debemos interesarnos en la definicin y en las caractersticas de las funciones en C. el resultado de una funcin depende entonces del tipo como ha sido definido. Si algn tipo no est definido explcitamente, se supone por defecto el tipo de resultado es entero. La entrega de resultados se la realiza en general al final de la funcin mediante la instruccin return. Y para terminar con esta parte, en C toda instruccin simple debe ser terminada por un ;, inclusive si se encuentra en la ltima posicin de un bloque de instrucciones.

Tipos de base.-

Las variables y las constantes son los datos principales a utilizarse en un programa. Las declaraciones introducen las variables que se utilizan, fijan su tipo y tambin a veces su valor inicial. Tipos simples En matemticas el orden y magnitud de los nmeros es ilimitado y los racionales pueden ser expresados sin prdida de precisin. En cambio un computador no puede captar fcilmente cualquier nmero entero, sino solamente de un tamao limitado, utiliza el sistema binario para calcular y guardar estos nmeros. Entonces el computador utiliza astucias de clculo y de representacin para poder obtener valores correctos. As como de enteros muy grandes y racionales con parte decimal infinita. El programador debe ser capaz de: 1. Escoger un tipo numrico apropiado para un problema dado. 2. Debe escoger un tipo apropiado para su representacin en pantalla. 3. Prever el tipo resultante de una operacin entre diferentes tipos numricos. 4. Debe prever y optimizar la precisin de los resultados intermedios en el curso de un clculo detectado. Tipos enteros DEFINICIN DESCRIPCIN DOMINIO MIN DOMINIO MAX 127 32767 32767 2147483647 N OCTETOS

char short int long

Carcter Entero corto Entero estndar Entero largo

-128(2^8) -32768(2^15) -32768 2147483648(2^31)

1 2 2 4

Char: se refiere a un carcter, las variables del tipo char pueden contener valores entre (128 y 127) pueden sufrir las mismas operaciones que las variables del tipo short, int o long. Int: en cada mquina el tipo int es el tipo de base para los clculos con enteros.

Short: esta codificado en dos octetos. Este tipo solo es necesario si se quiere utilizar el mismo programa en otras mquinas en las cuales el tipo estndar de enteros no es forzosamente de dos octetos. Los modificadores (signed/unsigned) desplazan el dominio como se indica acontinuacin. DEFINICIN DESCRIPCIN DOMINIO MIN DOMINIO MAX 255 65535 65535 # OCTETOS 1 2 2

unsigned unsigned unsigned

char short int

Carcter Entero corto Entero estndar Entero largo

0 0 0

unsigned

long

4294967295

Z+ -> <mantisa>*10 <exponente>

Definicin

Precisin

Mantisa

Dom. Mnimo 3.4*10^-18 1.7*10^-308 3.4*10^4932

Dom. Mximo 3.4*10^38 1.7*10^308 3.4*10^4932

N octetos

FLOAT DOUBLE LONG DOUBLE

SIMPLE DOBLE SUPLEMENT

6 15 19

4 8 10

Declaraciones de variables Ejemplos: int x, y; Float largo, diametro; Double radio, masa; Char tecla;

Constantes numricas

Cuando hablamos de las constantes enteras, se cambia de tipo automticamente con el propsito de escoger la solucin ms econmica, as entonces se cambiara el tipo intlong-unsigned long segn la magnitud de la variable entere en cuestin. Si el nmero dado es demasiado grande para unsigned long, la reaccin del programa es imprevisible. Si queremos forzar al computador a utilizar un tipo especial, podemos emplear los subtipos siguientes: Uu Ll UL ul Unsigned (int o long) Long Unsigned long 550u 123456789L 12092UL

Si una constante entera empieza por cero, entonces es interpretada como que est en base ocho. Si una variable entera empieza por 0x (0X) es interpretada como que est en base diecisis. Base 10 100 255 655036 Base 8 0144 0377 237 7274 Base 16 0X64 0xff 9 FEBC Base 2 1100100 11111111 1001 1111 1110 1011 1100 11 1111 1000 1010 1010 1010 1010 1001001001 11 1110 1000 1001 1100 1100101011111110

1016 4 3690

01770 12 5252

3F8 0XAAAA

585 1000 156 5 1966

1111 1750 0234 14 5376

249 3E8 9C CAFE

Constantes racionales Estas pueden ser indicadas en notacin decimal, en notacin exponencial, o cientfica asi por ejemplo: (123.4) (0.0001) (234e-1) (1E-3) (0.01E2) Por defecto las constantes racionales son del tipo double. El subfijo F o f forza la utilizacin del tipo float. El subfijo L o l forza la utilizacin del tipo long double. Los caracteres constantes, que designan un solo carcter se indica entre 2 apstrofes por ejemplo: Char x El valor de un carcter constante es el cdigo interno de este mismo carcter, por ejemplo el cdigo aski. Dentro de esto mismo los caracteres constantes pueden aparecer en operaciones aritmticas o lgicas, pero en general son utilizados para ser comprados con otras variables. Secuencias de escape Una secuencia de escape es una pareja de smbolos donde el primero es el signo (\), el segundo signo puede variar indicando diferentes instrucciones, segn el siguiente cuadro:
\a \b \t \n \r Sonido Cursor hacia atrs Tabulacin Nueva lnea Regresar al comienzo de lnea Nulo Trazo oblicuo Signo de interrogacin Apostrofe comillas Salto de pgina (impresora) Tabulador vertical

\0 \\ \? \ \ \f \v

(\0) significa el final de una cadena de caracteres Inicializacin de variables En C es posible inicializar variables en el momento de su declaracin, por ejemplo: Int x=10; Float radio=2.56; Char TAB= \t; Utilizando el atributo CONST indicamos que el valor de una variable no cambia en el transcurso de un programa, por ejemplo: Const int MAX=767; Const doubl PI=3.141592654 Const float X=1.05E-4 Operadores estndar Signo de afectacin (=) Por ejemplo: x=5; x= x+1; los operadores y las funciones aritmticas utilizadas en las expresiones, no existen todas las conocidas en matemticas en forma general. As por ejemplo: no existe una funcin estndar en C para calcular el cuadrado de un nmero. Ejemplo: Pow(x,y) -> xy Y ==3(C) -> y=3 (mat)

Operadores en C + * /(div. Entera y racional!) % mdulo (resto de una div. entera) && AND || OR NOT 1=0 6.3=0

Operadores de comparacin == igual a = diferente de <, <=, >= 32&&2.3 -> 1 !(-65.34) -> 0 0||!(32>10) -> 0 Operadores de afectacin En la prctica frecuentemente encontramos expresiones como x=x+2; que se pueden escribir como x+=2; en general: expr1=(expr1)op(expr2); expr1 op=expr2; += -= *= /= %= sumar a restar de multiplicar por dividir para Es el valor residual del valor dado menos la divisin entera mas cercana

Elemento [n+i+j]=Elemento[n+i+j]*X[j]; Elemento [n+i+j]*=X[j]; Operadores de incrementacin y decrementacin

I=I+1; I=I-1; En C disponemos de dos operadores especiales para este tipo de aplicaciones. I++ ++I; I-- --I; X=I++; Pasa primero el valor de I a la variable x y aumenta despus X=++I; Primero incrementa el valor de I y pasa el valor incrementado a x X=I--; Pasa primero el valor de I a la variable x y disminuye despus X=--I; Primero disminuye el valor de I y pasa el valor disminuido a x

Sean A=1 y B=4; !--A==++!B -> !0==++0 ->1==1 ->1

Sean A=20 D=2 Evaluar:

B=5

C=-10

X=12 Y=15

1) (5*X)+2*((3*B)+4) -> 98 2) (5*(X+2)*3)*(B+4) -> 1890 3) A==(B=5) -> 0, B=5 4) A+=(X+5) -> 37 5) A!=(C*=(-D)) -> 0, C=20 6) A*=C+(X-D) -> 0, A=0 7) A%=D++ -> A=0, D=3 8) A%=++D -> A=2, D=3 9) (X++)*(A+C) -> 120, X=13 10) A=X*(B<C)+Y*!(B<C) -> A=15

11) !(X-D+C)||D -> 1 12) A&&B||!0&&C&&!D -> 1 13) ((A&&B)||(!0&&C))&&!D -> 1 14) ((A&&B)||!0)&&(C&&(!D)) -> 0

Las funciones aritmticas estn definidas en la biblioteca <math>. Para poder utilizarlas el programa debe contener la lnea # include <math.h> los argumentos y los resultados de las funciones aritmticas son por defecto del tipo doubl Exp(x) -> ex Log(x) -> lnx, x>0 Log10(x) -> log10x, x>0 Pow(x,y) -> xy Sqrt(x) -> (x)1/2, x>0 Fabs(x) -> |x| Floor(x) -> valor redondeado en menos (int(x)) Ceil(x) -> valor redondeado mas Fmod(x,y) -> resta racional de x/y (mismo signo de x), x0 Sin(x) Cos(x) Tan(x) Asin(x) Acos(x) Atan(x) Sinh(x) Cosh(x) Tanh(x)

PROGRAMA:
# include <stdio.h> main() { double A; double B; double RES; /*Introducir A y B*/ printf("Introducir el valor scanf("%lf",&A); printf("Introducir el valor scanf("%lf",&B); /*Clculos*/ RES=A*A; /*Desplegar el resultado*/ printf("el cuadrado de A es /*Clculos*/ RES= B*B; /*Desplegar el resultado*/ printf("el cuadrado de B es return 0; } A elevado a la B # include <math.h> main() { double A; double B; double PRO; /*Introducir A y B*/ printf("Introducir el valor de A:"); scanf("%lf",&A); printf("Introducir el valor de B:"); scanf("%lf",&B); /*Clculos*/ PRO=pow(A,B); /*Desplegar el resultado*/ printf("A elevado a la B es %f\n", PRO); return 0; } La hipotenusa # include <math.h> main() { double A; double B; double PRO; /*Introducir A y B*/ printf("Introducir el valor de A:"); scanf("%lf",&A); printf("Introducir el valor de B:"); scanf("%lf",&B);

de A:"); de B:");

%f\n", RES);

%f\n", RES);

/*Clculos*/ PRO=sqrt(A*A+B*B); /*Desplegar el resultado*/ printf("la hipotenusa es %f\n", PRO); return 0; } Tan A usando seno y coseno de A # include <math.h> main() { double A; double PRO; /*Introducir A y B*/ printf("Introducir el valor de A:"); scanf("%lf",&A); /*Clculos*/ PRO=sin(A)/cos(A); /*Desplegar el resultado*/ printf("la tangente es %f\n", PRO); return 0; }

C permite mezclar datos de diferentes tipos en una expresin antes de realizar los clculos dichos datos deben ser convertidos a un solo tipo. La mayora de estas conversiones se realizan automticamente sin la intervencin del programador, que debe de todas maneras prever su efecto A veces es necesario convertir un dato en un tipo diferente que el que se escogera en la conversin automtica, en este caso debemos forzar la conversin con la ayuda de un operador especial (cast)

Conversiones de tipo automticas.En una afectacin, el dato que est a la derecha del signo = es convertido en el tipo que est a la izquierda del mismo signo de igualdad, en este caso puede haber perdida de .. si el tipo de destino es ms pequeo que el del dato inicial. Si un operador tiene operando de diferentes tipos, los valores de los operando se convierten automticamente en un tipo comn. Normalmente se convierten los tipos ms pequeos en tipos ms grandes, para no perder en precisin. Int I=8; Float x=12.5;

Double y; y=I*x; y=100.00 int A=200; int RES; RES=pow(A,2); Reglas de conversin automtica A raz de una operacin: (1) dos enteros:, primeramente los tipos char, short se convierten en int. Luego el computador escoge el ms grande de los tipos segn la escala int, unsignedint, long, unsigned long. (2) entero y un racional el tipo entero se convierte en racional automticamente. (3) dos racionales el computador escoge el ms grande de los dos tipos segn la escala float, doubl, long double. (4) afectaciones y operaciones de afectacin a raz de una afectacin, el resultado siempre se convierte en el tipo del dato que sea destino. Si este tipo es ms pequeo puede haber una prdida de precisin. Int x; Float A=12.48; Char B=4; X=A/B; X=3

Char A=3; Int B=4; Float C=4; Float D, E; Char F; D=A/C;

E=A/B; F=A/C; D=0.75 E=0.00 F=0

Conversiones del tipo forzadas (casting).Tienen una forma general que son: (<tipo>)<expresin> Char A=3; Int B=4; Float C; C= (float) A/B; C=0.75

Lectura y escritura de datos.Printf () -> escritura de un dato Scanf () -> leer un dato Putchar () -> escribir un carcter Gotchar () -> leer un carcter Printf ().Se utiliza para transferir texto, valores de variables o resultados de expresiones hacia el archivo de salida estndar stdout que por defecto es la pantalla, print (<format>, <expre1>, <expre2>), <expre> son las expresiones en las que se van a representar sus valores. <format> esto es una cadena de caracteres o secuencia de escape o especificadores de formato.

Int A=1234;

Int B=567; Printf (%i por %i es %li\n, A, B, (long) A*B); Se observar 1234 por 567 es 699678

Char B=A; Printf (El carcter %c tiene el cdigo %i !\n, B, B); El carcter A tiene el cdigo 65 !

SMBOLO %d %i %u %o %x %c %f

TIPO Int Int Int Int Int Doubl

APARECE COMO Entero relativo Entero natural (unsigned) Entero en octal Entero en hexadecimal carcter Racional en notacin decimal Racional en notacin cientfica Cadena de caracteres

%e

Doubl

%s

Char*

NOTA.1.- A propsito de los argumentos de tipo long, los especificadores (%d %i %u %o %x), pueden representar solamente valores del tipo (int, unsigned int). Un valor demasiado grande puede ser codificado en dos octetos o dos bytes y cortado sin advertencia si utilizamos (%d). Para poder procesar correctamente los argumentos del tipo long, hay que utilizar los especificadores (%ld, %li, %lu, %lo, %lx) 2.- Sobre los argumentos racionales, los especificadores (%f, %e) pueden ser utilizados para representar argumentos de tipo float o doubl, la mantisa de los nmeros

representados por este formato (%e) contiene exactamente una cifra (no nula) delante del punto decimal. Esta representacin se llama la notacin cientfica de los racionales. Para poder tratar correctamente los argumentos de tipo (long doubl),hay que utilizar los especificadores (%Lf, %Le). 3.- A propsito del mnimo espacio para los enteros, para los enteros podemos indicar el largo mnimo del valor a anotarse. En el campo asi reservado los nmeros son justificados hacia la derecha.

Prinf(%4d, 123); -> _123 Printf(%4d, 12345); -> 12345 Printf(%4X, 123); -> _7B Printf(%4x, 123); -> _7b

El largo mnimo de precisin para los racionales.4.- para los racionales podemos indicar el largo mnimo del valor a mostrarse y la precisin del nmero a desplegarse. La precisin por defecto es de 6 decimales, las posiciones decimales se redondean al valor ms prximo.

Printf (%f, 100.123); -> 100.123000 Printf (%.2f, 100.123); -> 100.12 Printf (%5.0f, 100.123); -> __100.0 Printf (%10.3f, 100.123); -> _______100.123

#include <stdio.h> main () { int N=10,P=5,Q=10,R; char C='S'; N=5;P=2; Q=N++>P||P++!=3; printf("C: N=%d P=%d Q=%d\n",N,P,Q); C: N=6 P=2 Q=1 N=5;P=2;

Q=N++<P||P++ !=3; printf("D: N=%d P=%d Q=%d\n",N,P,Q); D: N=6 P=2 D=1 N=5;P=2; Q=++N==3&&++P==3; printf("E: N=%d P=%d Q=%d\n",N,P,Q); E: N=6 P=3 E=0 N=5;P=2; Q=++N==6&&++P==3; printf("F: N=%d P=%d Q=%d\n",N,P,Q); F: N=6 P=3 E=1 N=C; printf("G: %c %c\n",C,N); printf("H: %d %d\n",C,N); printf("I: %x %x\n",C,N); return 0; }

La funcin scanf es la funcin simtrica de la printf nos ofrece prcticamente las mismas conversiones que printf pero en sentido inverso Scanf (<format>, <direccVar1>, <direccVar2>,) <format>-> indica el formato de lectura de los datos <direccVar1> -> direccin de las variables a las que los datos sern atribuidos. La funcin scanf recibe sus datos a partir del archivo de entrada standard (stdin) -> teclado. La cadena del formato determina como los datos recibidos deben ser interpretados. Los datos recibidos correctamente son memorizados sucesivamente en las direcciones indicadas por: <direccVar1>, <direccVar2> La direccin de una variable se indica por el nombre de la variable precedido del signo (&) por ejemplo: (%A) La instruccin scanf entrega como resultado el nmero de datos correctamente recibidos SMBOLO %d %i %u %o %x %c LECTURA DE Entero relativo Entero natural (unsigned) Entero en octal Entero en hexadecimal Carcter TIPO Int* Int* Int* Int* Char*

%s %f %e

Cadena de caracteres Racional en decimal o exponencial (cientfico)

Char* Float*

(*) indica el entero sobre una variable Observaciones.1.- sobre el tipo long, si queremos leer un dato del tipo long, debemos utilizar los especificadores (%ld, %li, %lu, %lo, %lx), 2.- sobre el tipo doubl, si queremos leer un dato del tipo doubl, debemos utilizar los especificadores (%le, %lf). 3.- sobre el tipo long doubl, si queremos leer un dato del tipo long doubl, debemos utilizar los especificadores (%Le, %Lf). 4.- sobre la indicacin del largo mnimo, para todos los especificadores podemos indicar el largo mximo a evaluar para un dato. Las cifras que sobrepasan dicho campo son atribuidas a la prxima variable que ser leda. Por ejemplo: Int A, B; Scanf(%4d %2d, &A, &B); 1234567 -> A=1234 B=56 Lectura y escritura de un carcter.- (putchar(a);) Este comando transfiere el carcter a hacia el archivo estndar de salida (stdout). Los argumentos de la funcin putchar son o bien caracteres (nmeros enteros entre 0 y 255) o bien el smbolo EOF (End Of File). EOF es una constante definida en <stdio.h> que indica el final de un archivo. La instruccin putchar(EOF); es utilizada en el caso donde stdout es desviada hacia un archivo.

Putchar ()

EOF -> para no confundirse con un carcter, la constante EOF debe necesariamente tener un valor que salga del dominio de los caracteres. Entonces, los argumentos de putchar son por definicin de tipo int y todos los valores tratados por putchar son convertidos primeramente en enteros.

Char A=225; -> declaracin de A, () Char B=\a; -> Int C=\a; Putchar (x); -> despliega la letra x Putchar (?); -> despliega el signo de interrogacin Putchar (\n); -> salto de lnea Putchar (65); -> despliega el smbolo correspondiente al cdigo 65 (ASCII: A) Putchar (A); -> despliega el smbolo correspondiente al cdigo 225 (ASCII: A) Putchar (B); -> Beep sonoro Putchar (C); -> Beep sonoro Putchar (EOF); -> marca el final del archivo

Getchar () Esta funcin est declarada en el archivo de entrada <stdin>, los valores que entrega de char son o bien caracteres (0-255) o bien el smbolo EOF. Y son del tipo int. En general el char se utiliza como una afectacin: Int C C=getchar (); Para realizar el proceso de getchar () <-> getch () se debe anticipar los comandos de la biblioteca <conio>. Escribir el programa que lea un carcter desde el teclado y que muestre tanto el carcter como su cdigo numrico. 1.- Usando getchar () y printf
# include <stdio.h> main ()

{ int C; printf ("introduzca un caracter, seguido de 'Enter'\n"); C=getchar (); printf ("El caracter %c tiene el codigo ASCII %d\n", C,C); return 0; }

2.- empleando getch (), printf

# include <stdio.h> # include <conio.h> main () { int C; printf ("introduzca un caracter, seguido de 'Enter'\n"); C=getch (); printf ("El caracter %c tiene el codigo ASCII %d\n", C,C); return 0; }

# include <stdio.h> /*Copiar entrada a la salida*/ main () { int C; C=getchar(); while (C!=EOF) { putchar (C); C=getchar(); } return 0; } # include <stdio.h> /*Copiar entrada a la salida*/ main () { int C; while ((C=getchar())!=EOF) putchar (C); C=getchar(); return 0; }

Se trata de escribir un programa que permute y muestre tres variables del tipo entero a, b y c introducidas desde el teclado

Podemos agregar una variable extra;

# include <stdio.h> main () { int A,B,C,AUX; printf ("Introduzca 3 enteros(A,B,C):"); scanf ("%i,%i,%i", &A, &B, &C); /*Despliegue los resultados*/ printf ("A=%i\t B=%i\t C=%i\n",A,B,C); AUX=A; A=C; C=B; B=AUX; /*Mostrar los resultados*/ printf ("A=%i\t B=%i\t C=%i\n",A,B,C); return 0; }

Escribir un programa que demuestre el cociente y el resto de la divisin entera de 2 nmeros enteros introducidos desde el teclado as como el cociente racional de estos nmeros

# include <stdio.h> main () { int A,B; printf ("Introduzca 2 enteros:"); scanf ("%i, %i", &A, &B); printf ("Division entera: %i\n",A/B); printf ("Resto: %i\n",A%B); printf ("Cociente racional: %f\n",(float)A/B); return 0; }

Escribir el programa que muestre la resistencia equivalente de tres resistencias R1, R2, R3 tipo (doubl) bajo 2 condiciones si las resitencias estn conectadas en serie y si las resitencias estn en paralelo.
# include <stdio.h> main () { int R1,R2,R3; printf ("Introduzca las 3 resistencias:"); scanf ("%i, %i, %i", &R1, &R2, &R3); /*en serie*/ printf ("Resultado en serie: %i\n",R1+R2+R3);

/*en paralelo*/ printf ("Resultado en paralelo: %f\n",(float) (R1*R2*R3)/(R1*R2+R1*R3+R2*R3) ); return 0; }

Calcular y mostrar el rea de un tringulo conocidos los lados con las longitudes de los lados tipo entero
# include <stdio.h> # include <math.h> main () { /*Para no perde precision, declaramos P como racional*/ int A,B,C; double P; printf ("Introduzca los 3 lados del triangulo:"); scanf ("%i, %i, %i", &A, &B, &C); /*Forzando la conversion de A, las otras se convierten automaticamente*/ printf ("El semiperimetro es P: %f\n",P=((double)A+B+C)/2); printf ("Area del traingulo S: %f\n",sqrt(P*(P-A)*(P-B)*(P-C))); return 0; }

Realizar un programa que calcule y muestre la distancia (double) entre 2 puntos de coordenadas A (XA, YA) y B (XB, YB)
# include <math.h> main () { int A,B,C,D; float R=1; printf("Primera coordenada:"); scanf("%i %i",&A,&B); printf("Segunda coordenada:"); scanf("%i %i",&C,&D); printf("La distancia es:%.2lf\n",R=sqrt((A-C)*(A-C)+(B-D)*(B-D))); return 0; }

ESTRUCTURA ALTERNATIVA.If.else If (<expresin>) <bloque_instrucciones 1> Else <bloque_instrucciones 2>

Ejemplo.If (a>b) Max=a; Else Max=b;

If (IGUAL) Printf (A es igual a B\n); Else Printf(A es diferente de B\n);

If (A-B) printf (A es diferente de B\n); Else printf (A es igual a B\n);

If (A>B) { AUX=A; A=C; C=AUX; } Else { AUX=B; B=C; C=AUX; }

ESTRUCTURA REPETITIVA.While (<expresin>) <bloque_instrucciones> Ejemplos./*mostrar los nmeros de 0 a 9*/ Int I=0; While (I<10) { Printf (%i\n,I); I++; }

/*mostrar los nmeros de 10 a 1*/ Int I=10; While (I<10) <-> while (I!=0) Printf (%i\n, I--);
# include <stdio.h> main () { int N=1, SUMA=0; while (N<=100) { SUMA+=N; N++; } printf("SUMA= %d\n",SUMA); return 0; }

PRUEBA INICIO N=1 SUMA=0 LEER DATO DATO=0 -> SI -> -> NO -> DATOS INSUFISICIENTES -> FIN SUMA=SUMA+DATO N=N+1 LEER DATO DATO =0 -> SI -> N=N-1 -> MEDIA =SUMA/N IMPRIMIR MEDIA FIN -> NO ->

# include <stdio.h> main () { int N=1; float SUMA=0,DATO,MEDIA; printf("Introduzca el dato %d:\n",N); scanf("%f",&DATO); /*Lee el dato*/ /*El primer dato no puede ser cero....*/ if (N==1&&DATO==0) printf("datos insuficientes\n"); else { /*si se introduce un 0, la serie de datos termina*/ while (DATO) { SUMA+=DATO; N++; printf("Introduzca el dato %d:\n",N); scanf("%f",&DATO); /*lee dato*/ } N--; MEDIA=SUMA/N; /*mostrar el resultado con una cifra decimal*/ printf("MEDIA=%.1f\n",MEDIA); } return 0;

IF.If (<expresin>) <bloque_instrucciones> Ejemplo. if (N>0) if(A>B) MAX=A; else MAX=B; if (N>0) if(A>B) MAX=A; else MAX=B;

El else corresponde al ltimo if que no tiene parte else

Se debera poner:
if (N>0) { if(A>B) MAX=A; } else MAX=B; if (N>0) if(A>B) MAX=A; else MAX=B;

Aplicacin:
# include <stdio.h> main () { int A,B; printf("determine los valores A y B:\n"); scanf("%i,%i",&A,&B); if (A>B) printf("primera opcin\n");

else { { if (A>10) printf("segunda opcin\n"); } { if (B<10) printf("tercera opcin\n"); else printf("cuarta opcin\n"); } } return 0; }

IF ELSE IF ELSE.If(<expresin>) <bloque> Else if (<expresin>) <bloque> Else if (<expresin>) <bloque> Else if (<expression enesima>) <bloque enesimo> Ejemplo:
# include <stdio.h> main () { int A,B; printf("Introduzca dos enteros: "); scanf("%i,%i",&A,&B); if (A>B) printf("%i es mayor que %i\n",A,B); else if (A<B) printf("%i es menor que %i\n",A,B); else printf("%i es igual que %i\n",A,B); return 0; }

OPERADORES CONDICINALES.<expresione1>?<expresin2>:<expression3> Ejemplo: If (A>B) MAX=A; Else MAX=B; MAX = (A>B)? A : B ; Escribir un programa que lea tres valores enteros A, B, C, introducidos desde el teclado y que muestre el mayor de ellos, realcelo de cuatro maneras diferentes. A. Ifelse, +AUX
# include <stdio.h> main () { int A,B,C; int AUX; printf("Introduzca tres valores enteros:"); scanf("%i %i &i",&A,&B,&C); if (A>B) AUX=A; else AUX=B; if (C>AUX) AUX=C; printf("el mayor valor es %i\n",AUX); return 0; }

B. Ifelse ifelse, sin AUX

# include <stdio.h> main () { int A,B,C; printf("Introduzca tres valores enteros:"); scanf("%i %i &i",&A,&B,&C); printf("El mayor valor es "); if(A>B&&A>C) printf("%i\n",A); else if (B>A&&B>C) printf("%i\n",B); else printf("%i\n",C); return 0; }

C. Operadores condicionales, +AUX

# include <stdio.h> main () { int A,B,C; int AUX; printf("Introduzca tres valores enteros:"); scanf("%i %i &i",&A,&B,&C); AUX=(A>B)?A:B; AUX=(AUX>C)?AUX:B; printf("el mayor valor es %i\n",AUX); return 0; }

D. Operadores condicionales, sin AUX

# include <stdio.h> main () { int A,C,B; printf("Introduzca tres valores enteros:"); scanf("%i %i &i",&A,&B,&C); A=(A>B&&A>C)?A:(B>A&&B>C)?B:C; printf("el mayor valor es %i\n",A); return 0; }

Realizar un programa que lea dos variables en tipo entero y que indique el signo del producto sin realizar la multiplicacin.

# include <stdio.h> main () { int A,B; printf ("Introduzca los 2 valores enteros a ser calculados:\n"); scanf ("%i,%i",&A,&B); if ((A>0&&B>0)||(A<0&&B<0)) printf("El signo del producto es positivo\n"); else printf ("El signo del producto es negativo\n"); return 0; }

Disear un programa que permita transformar los grados farenheit a Grados celcius basado en un rango de temperatura.
# include <stdio.h> main()

{ int A; printf("Introduzca la temperatura en grados Celcius entre los valores [0,200]:\n"); scanf(" %i",&A); if (A>200||A<0) printf("La tempaeratura ingresada es incorrecta.\n"); else printf("La temperatura en grados farenheit es: %i\n",A=9/5*A32); return 0; }

Do..While.Do <bloque_instrucciones> While(<expresin>);

do printf("INtrduzca un entero entre 1 y 10:"); scanf("%i",&N); while (N<1||N>10);

Realizar un programa que muestre la raz cuadrada de un #

# include <stdio.h> # include <math.h> main() { float N; do { printf("Intrduzca un numero[>=0]:"); scanf("%f",&N); } while (N<0); printf("La raz cuadrada de %.2f es %.2f\n",N,sqrt(N)); return 0; }

Escribir un programa que lea n nmeros introducidos desde el teclado y que muestre su suma, su producto y su promedio
# include <stdio.h> main() { int N;/*numero de datos*/ int NUM;/*Dato actual*/

int I;/*Contador*/ long SUMA;/*suma de los datos*/ double PROD;/*producto de los datos*/ printf ("nmero de datos: "); scanf("%d",&N); SUMA=0; PROD=1; I=1; while (I<=N) { printf("%d numero: ",I); scanf("%d",&NUM); SUMA+=NUM; PROD*=NUM; I++; } printf("La suma de los %d numeros es %ld\n",N,SUMA); printf("El producto de los %d numeros es %.0f\n",N,PROD); printf("El promedio de los %d numeros es %.4f\n",N, (float)SUMA/N); return 0; }

Escribir un programa que lea n nmeros introducidos desde el teclado y que muestre su suma, su producto y su promedio
# include <stdio.h> main () { int N; /*nmero de datos*/ int NUM;/*dato actual*/ int I; /*contador*/ long SUMA; /*suma de los numeros introducidos*/ double PROD;/*producto de los numeros introducidos*/ printf("Numero de datos:"); scanf("%d",&N); SUMA=0; PROD=1; I=1; do { printf("%d.numero:",I); scanf("%d",&NUM); SUMA+=NUM; PROD*=NUM; I++; } while(I<=N); printf("La suma de los %d numeros introducidos es %ld\n",N,SUMA); printf("El producto de los %d numeros es %.0f\n",N,PROD); printf("El promedio de los %d numeros es %.4f\n",N, (float)SUMA/N); return 0; }

For For(<expre1>;<expre2;<expre3>) <bloque_instrucciones> <expre1> While (<expre2>) { <bloque_instrucciones> <expre3> } A menudo for se utiliza como lazo de conteo es decir For(<inicio>;<condicin repeticin>;<contador>) < bloque_instrucciones > Escribir un programa que lea n nmeros introducidos desde el teclado y que muestre su suma, su producto y su promedio
# include <stdio.h> main () { int N; /*nmero de datos*/ int NUM;/*dato actual*/ int I; /*contador*/ long SUMA; /*suma de los numeros introducidos*/ double PROD;/*producto de los numeros introducidos*/ printf("Numero de datos:"); scanf("%d",&N); for (SUMA=0,PROD=1,I=1;I<=N;I++) { printf("%d.numero:",I); scanf("%d",&NUM); SUMA+=NUM; PROD*=NUM; } printf("La suma de los %d numeros introducidos es %ld\n",N,SUMA); printf("El producto de los %d numeros es %.0f\n",N,PROD); printf("El promedio de los %d numeros es %.4f\n",N, (float)SUMA/N); return 0; }

Realizar un programa tal que muestre los rangos de temperatura de 0 a 300 grados celcius a grados farenheit

# include <stdio.h> /*imprimir una tabla Farenheit-Celcius para Farenhit=0,20,.......,300*/ main() { int Fahrenh, Celcius, min, MAX, paso; min=0; MAX=300; paso=20; Fahrenh=min; while (Fahrenh<=MAX) { Celcius=5*(Fahrenh-32)/9; printf("%d\t%d\n",Fahrenh,Celcius); Fahrenh+=paso; } return 0; }

Versin nmero 2

# include <stdio.h> /*imprimir una tabla Farenheit-Celcius para Farenhit=0,20,.......,300*/ main() { int min, MAX, paso; double Fahrenh,Celcius; min=0; MAX=300; paso=20; Fahrenh=min; while (Fahrenh<=MAX) { Celcius=(5.0/9.0)*(Fahrenh-32.0); printf("%.0f\t%6.1f\n",Fahrenh,Celcius); Fahrenh+=paso; } return 0; }

Versin numero 3
# include <stdio.h> /*imprimir una tabla Farenheit-Celcius para Farenhit=0,20,.......,300*/ main() { int Fahrenh; for(Fahrenh=0;Fahrenh<=300;Fahrenh+=20) printf("%3d\t%6.1f\n",Fahrenh,(5.0/9.0)*(Fahrenh-32)); return 0; }

Escribir un programa que calcule el factorial de n

# include <stdio.h> main() { int i;/*el contador*/ int n;/*el dato*/ double fact;/*valor de n!-tipo double por la talla del resultado*/ do { printf("introduzca un entero natural:"); scanf("%d",&n); } while (n<0); /*para n=0, automaticamente 0!=1*/ i=1; fact=1; while (i<=n) { fact*=i; i++; } printf("%d!=%.0f\n",n,fact); return 0; }

Por el mtodo de for

# include <stdio.h> main() { int i;/*el contador*/ int n;/*el dato*/ double fact;/*valor de n!-tipo double por la talla del resultado*/ do { printf("introduzca un entero natural:"); scanf("%d",&n); } while (n<0); /*para n=0, automaticamente 0!=1*/ for (i=1.0,fact=1;i<=n;i++) fact*=i; printf("%d!=%.0f\n",n,fact); return 0; }

Realice un programa que calcule la suma de los N primeros trminos de la serie armnica
# include<stdio.h> main() {

int N; int I; float SUMA; do { printf("Nmero de trminos: "); scanf("%d",&N); } while (N<1); for(SUMA=0.0,I=1;I<=N;I++) SUMA+=(float)1/I; printf("La suma de los %d primeros trminos es: %f\n",N,SUMA); return 0; }

Realizar un programa que calcule mediante multiplicaciones sucesivas el valor de X ala n de los nmeros enteros naturales introducidos desde el teclado

Implementar un programa que calcule la suma, el producto y el promedio de una serie de nmeros no nulos introducidos desde el teclado, sabiendo que la serie se termina introduciendo un cero. Aceptar solamente los nmeros desde cero hasta nueve, efectuar una seal sonora si los datos salen de ese dominio.
# include <stdio.h> main () { int SUMA=0; int N=0; int X; long PROD=1; do { printf("introduzca el %d %s dato",(N+1),(!N||N==2)?"er":"o"); scanf("%d",&X); if(X<0||X>9) printf("\a"); else if(X) { N++; SUMA+=X; PROD*=X; } else if(!X&&N>0) { printf("La suma de los datos es %d\n",SUMA); printf("El producto de los datos es %ld\n",PROD); printf("El promedio de los datos es %f\n",(float)SUMA/N); } }

while (X); return 0; }

Implementar un programa que calcule el valor numrico de un polinomio de grado N para un valor de x (float) dado donde P(x)=AnX^n+A(n-1)X^(n-1)+..+A1X+A0 y los valores de n y los coeficientes (n, An,A(n-1),.,A0,X) sern introducidos desde el teclado.

#include <stdio.h> #include <conio.h> #define tam 15 int n,i; float A[tam],x,b,val; void lee_datos(void) { printf("\nIngrese el grado del Polinomio\t"); scanf("%d",&n); printf("\nIngrese los coeficientes del polinomio (empiece desde a0)\n\n"); for(i=0;i<=n;i++) { printf("a%d ",i); scanf("%f",&A[i]); }printf("\nIngrese el valor de x\t"); scanf("%f",&x); }float esquema(int t,float u,float U[tam])//(grado,incgnita,coeficientes) { int j; float y=0,z=0; b=U[t]; for(i=0;i<t;i++) { j=n-i; z=U[j-1]+u*b; b=z; }return(b); }void main(void) { printf("\t\tEsquema de Horner\n"); lee_datos(); val=esquema(n,x,A); printf("\nEl polinomio evaluado en %f es\t%f\n",x,val); getch(); }

Escribir un programa que muestre el mximo comn divisor de todos los enteros naturales introducidos desde el teclado utilizando el algoritmo de Euclides

#include <stdio.h> main() { int a,b,cociente,resto=1; printf("Introduzca dos numeros enteros separados por comas.\n"); scanf("%d,%d",&a,&b); if (a<b) { cociente=a; a=b; b=cociente; } while (resto>0) { cociente=a/b; resto=a%b; printf("%d = %dx%d + %d\n",a,b,cociente,resto); a=b; b=resto; } printf ("El m.c.d es %d\n",a); return 0; }

Implementar un programa que muestre un tringulo issceles de la forma * (***) (*****) (*******) N=4 Con N = nmero de lneas.

#include <stdio.h> main() { int alto; int f, c; printf("Ingrese el Alto: "); scanf("%d",&alto); for(f=1;f<=alto;f++) { for(c=1;c<=(alto-f);c++) { printf(" "); } for(c=1;c<=((2*f)-1);c++) { printf("*"); } printf("\n"); } return 0; }

Manejo de tablas.A) Vectores: Una tabla unidimensional A es una variable estructurada formada por un # entero N de variables simples del mismo tipo, llamadas las componentes de la tabla. El # de componentes (N) es llamada la dimensin de la tabla. En matemticas decimos que A es un vector de dimensin N.
int DIAS [7]={1,2,3,4,5,6,7}; int DIAS [7]={1(DIAS[0]),2,3,4,5,6,7(DIAS[6])};

Ejemplos:
int A [20]; long A[20]; float B[4]; double B[4]; char D[30];

En el lenguaje C, el nombre de una tabla representa la direccin del primer elemento de la tabla entonces las direcciones de las otras componentes se calculan directamente respecto de esa direccin.
short A[5]={1200,2300,3400,4500,5600}; dire3ccin |IE04|1200(IE06)|2300(IE08)|3400(IE0A)|4500(IE0C)|5600(IE0E)|IE10|

Si una tabla est formada por N componentes y si una componente necesita M octetos en bytes de memoria, entonces la tabla ocupara N*M octetos. Suponiendo que una variable del tipo long ocupa 4 octetos entonces la tabla t declarada reservara en total M*N octetos
long T[15]; -> M*N=15*4=60 OCTETOS

Inicializacin y reservacin automtica.A raz de la declaracin de una tabla se puede inicializar sus componentes, indicando la lista de los valores respectivos entre llaves.
int A[5]={10,20,30,40,50}; float B[4]={-1.05,3.33,8e-5,-12E4}; int C[6]={1,0,0,1,0,0};

Acceso a las componentes.int A[5]={10,20,30,40,50}; |10|20|30|40|50|

|A[0]|A[1]|A[2]|A[3]|A[4]|

Despliegue y afectacin de un vector.despliegue

#include <stdio.h> main () { int A[5]; int I; /*contador*/ for (I=0;I<5;I++) printf ("%d",A[I]); return 0; printf("\n"); }

Afectacin
main () { int A[5]; int I; /*contador*/ for (I=0;I<5;I++) scanf ("%d\n",&A[I]); return 0; }

Escribir un programa que lea la dimensin N en una tabla T de tipo entero de mximo 50 componentes llenando la tabla con valores introducidos desde el teclado y desplegar la tabla, calcular la suma de los elementos de la tabla.
# include <stdio.h> main() { /*Declaraciones*/ int T[50];/*Tabla dada*/ int N; /*Dimensin*/ int I;/*Indice actual*/ long SUMA; /*Suma de los elementos tipo long por talla del resultado*/ /*Introduccin de datos*/ printf("Dimension de la tabla (max 50):"); scanf("%d",&N); if (N>50) printf("Estas mal bruto\n"); else { for (I=0;I<N;I++) { printf("Elemento %d: ",I); scanf("%d",&T[I]); } /*Desplegar la tabla*/ printf("Tabla dada:\n");

for (I=0;I<N;I++) printf("%7d", T[I]); printf("\n"); /*Calcular la suma*/ for(SUMA=0,I=0;I<N;I++) SUMA+=T[I]; /*Mostrar el resultado*/ printf("Suma de los elementos: %ld\n",SUMA); } return 0; }

Escribir un programa que lea 50 caracteres introducidos desde el teclado y desplegar la tabla, borrar todos los ceros introducidos en la tabla, comprimir la tabla resultante y desplegar el resultado.
# include <stdio.h> main() { /*Declaraciones*/ int T[50];/*Tabla dada*/ int N; /*Dimensin*/ int J; int I;/*Indice actual*/ long SUMA; /*Suma de los elementos tipo long por talla del resultado*/ /*Introduccin de datos*/ printf("Dimension de la tabla (max 50):"); scanf("%d",&N); if (N>50) printf("Estas mal bruto\n"); else { for (I=0;I<N;I++) { printf("Elemento %d: ",I); scanf("%d",&T[I]); } /*Eliminar los ceros y comprimir*/ /*Copiar todos los elementos de I hacia J, e incrementar J para los elementos 0!*/ for (I=0,J=0;I<N;I++) { T[J]=T[I]; if (T[I])J++; } /*Nueva dimensin de la tabla*/ N=J; /*Mostrar el resultado*/ /*Desplegar la tabla*/ printf("Tabla dada:\n");

for (I=0;I<N;I++) printf("%7d", T[I]); printf("\n"); } return 0; }

Escribir un programa que lea la dimensin N de una tabla T del tipo entero, tal que los datos sean introducidos desde el teclado y mostrar la tabla, copiar las componentes estrictamente positivas en una segunda tabla TPOS y otra tabla con los valores estrictamente negativos TNEG,
# include <stdio.h> main() { /*Declaraciones*/ /*Tablas y sus dimensiones*/ int T[50],TPOS[50],TNEG[50]; int N, NPOS, NNEG; int I;/*Indice actual*/ /*Introduccin de datos*/ printf("Dimension de la tabla (max 50):"); scanf("%d",&N); if (N>50) printf("Estas mal bruto\n"); else { for (I=0;I<N;I++) { printf("Elemento %d: ",I); scanf("%d",&T[I]); } /*Desplegar la tabla*/ printf("Tabla dada:\n"); for (I=0;I<N;I++) printf("%7d", T[I]); printf("\n"); /*Inicializar las dimensiones de TPOS y TNEG*/ NPOS=0; NNEG=0; /*Transferir los elementos*/ for (I=0;I<N;I++) { if(T[I]>0) { TPOS[NPOS]=T[I]; NPOS++; } if(T[I]<0) { TNEG[NNEG]=T[I]; NNEG++; } }

/*Desplegar los resultados*/ printf("Tabla de datos positivos: \n"); for (I=0;I<NPOS;I++) printf("%7d",TPOS[I]); printf("\n"); printf("Tabla de datos negativos: \n"); for (I=0;I<NNEG;I++) printf("%7d",TNEG[I]); printf("\n"); } return 0; } Manejo de tablas en dos dimensiones o matrices.-

En C una tabla de dos dimensiones se interpreta como una tabla unidimensional de dimensin L (lneas) en donde cada componente es a su vez una tabla unidimensional de dimensin C (columnas), la tabla T tendr LxC elementos o componentes.
int NOTAS [10][5]= int NOTAS[10][5]= {{45,34,50,48,47},{39,25,49,23,33},.........{40,42,38,49,41}}; float B[2][20]; char D[15][25]; ...... long A[10][10];

Memorizacin.Igual que para los vectores, el nombre de la tabla representa la direccin del primer elemento de la tabla. Las componentes de una tabla se guardan lnea por lnea en la memoria. Una tabla de dimensiones LxC, formada por componentes tales que cada una necesita M (octetos o bytes), ocupar en total L*C*M octetos en total en la memoria.
#include <stdio.h> main () { int A[5][10]; int I,J; /*Para cada lnea.....*/ for (I=0;I<5;I++) { /*...considerar cada componente*/ for(J=0;J<10;J++) printf("%7d",A[I][J]); /*salto de linea*/ printf("\n"); } return 0; }

Escribir un programa que lea las dimensiones L y C de una tabla T de tipo entero mximo 50*50. Introducir los datos desde el teclado y mostrar la matriz T, adems calcular y mostrar la suma de todos los elementos de la matriz.
#include <stdio.h> main () { /*Declaraciones*/ int T[50][50];/*Tabla dada*/ int L,C;/*Dimensiones*/ int I,J;/*Indices actuales*/ long Suma;/*Suma de los elementos tipo long por talla del resultado*/ /*Introduccion de dimensiones*/ printf("Numero de lineas (max 50):"); scanf("%d",&L); printf("Numero de columnas (max 50):"); scanf("%d",&C); for (I=0;I<L;I++) for (J=0;J<C;J++) { printf("Elemento [%d][%d]:",I,J); scanf("%d",&T[I][J]); } /*desplegar tabla*/ printf("Tabla dada:\n"); for (I=0;I<L;I++) { for (J=0;J<C;J++) printf("%7d",T[I][J]); printf("\n"); } /*Calcualr la suma*/ for (Suma=0,I=0;I<L;I++) for (J=0;J<C;J++) Suma+=T[I][J]; /*mostrar el resultado*/ printf("La suma de los terminos es:%ld\n",Suma); return 0; }

Escribir un programa que lea las dimensiones L y C de una tabla T de tipo entero de max 50*50, introducir los datos desde el teclado y mostrar la tabla as como tambin la suma de cada lnea y cada columna
#include <stdio.h> main() { /*Declaraciones*/ int T[50][50];/*Tabla dada*/ int L,C; /*Dimensiones*/ int I,J; /*Indices actuales*/ long SUMA; /*Suma de los elementos tipo long por talla del restultado*/ printf ("Numero de lineas (max 50):"); scanf("%d",&L);

printf("Numero de columnas (max 50):"); scanf("%d",&C); for(I=0;I<L;I++) for(J=0;J<C;J++) { printf("Elemento [%d][%d]:",I,J); scanf("%d",&T[I][J]); } /*Desplegar la tabla*/ printf("Tabla dada:\n"); for(I=0;I<L;I++) { for(J=0;J<C;J++) printf("%7d",T[I][J]); printf("\n"); } /*Calcular la suma de las lneas*/ for (I=0;I<L;I++) { for (SUMA=0,J=0;J<C;J++) SUMA+=T[I][J]; printf("Suma - Linea %d: %ld\n",I,SUMA); } /*Calcular la suma de las columnas*/ for(J=0;J<C;J++) { for (SUMA=0,I=0;I<L;I++) SUMA+=T[I][J]; printf("Suma - Columna %d: %ld\n",J,SUMA); } return 0; }

Escribir un programa que transfiera una tabla M de dimensiones L y C de max 10*10 que transfiera a una tabla V de dimensiones L*C.
#include <stdio.h> main() { /*Declaraciones*/ int M[10][10];/*Tabla dada*/ int V[100]; /*Vector*/ int L,C; /*Dimensiones*/ int I,J; /*Indices actuales*/ /*Introduccion de datos*/ printf ("Numero de lineas (max 10):"); scanf("%d",&L); printf("Numero de columnas (max 10):"); scanf("%d",&C); for(I=0;I<L;I++) for(J=0;J<C;J++) { printf("Elemento [%d][%d]:",I,J); scanf("%d",&M[I][J]); } /*Desplegar la tabla*/

printf("Tabla dada:\n"); for(I=0;I<L;I++) { for(J=0;J<C;J++) printf("%7d",M[I][J]); printf("\n"); } /*Transferir los elementos linea por linea*/ for (I=0;I<L;I++) for (J=0;J<C;J++) V[I*C+J]=M[I][J]; printf("Vector resultante: "); for (I=0;I<L*C;I++) printf("%7d",V[I]); printf("\n"); return 0; }

Escribir un programa que calcule el producto escalar de dos vectores (V, U) de enteros de la misma dimensin.
#include <stdio.h> main() { /*Declaraciones*/ int U[50],V[50];/*Vectores dados*/ int N; /*Dimensin*/ int I; /*ndice actuales*/ float R;/*Producto escalar*/ /*Introduccion de datos*/ printf ("Dimension de los vectores (max 50):"); scanf("%d",&N); printf("**Primer Elemento**\n"); for(I=0;I<N;I++) { printf("Elemento %d:",I); scanf("%d",&U[I]); } printf("**Segundo vector**\n"); for(I=0;I<N;I++) { printf("Elemento %d:",I); scanf("%d",&V[I]); } /*El producto escalar*/ for (R=0,I=0;I<N;I++) R+=U[I]*V[I]; /*Mostar el resultado*/ printf("El producto escalar de los vectores es: %0f\n",R); return 0; }

Punteros Los punteros dan acceso a un sitio especfico de la memoria interna del computador.

Sin embargo hay una diferencia: Un puntero es una variable que puede apuntar a diferentes direcciones. El nombre de una variable est siempre ligada a la misma direccin. Los operadores bsicos con punteros Cuando trabajamos con punteros, necesitamos: 1. El operador direccin de &. 2. El operador contenido de * para acceder al contenido de una direccin. 3. Una sintaxis de declaracin para poder declarar un puntero. Direccin de &. Indica la direccin de una variable, ejemplo
int N; printf("Dar un entero:"); scanf("%d",&N);

Este operador & puede ser aplicado solamente a objetos que se encuentran en la memoria interna, es decir, a variables y tablas; no puede aplicarse a constantes o a expresiones. Representacin esquemtica En nuestra representacin esquemtica podemos demostrar el hecho de que P apunta hacia A.
*<Nombre puntero>

Esto designa el contenido de la direccin referenciada por el puntero.

P=&A; B=*P; *P=20;

Sintaxis.<Tipo>*<Nombre puntero> int *PNUM;

Esta declaracion puede ser interpretada como: *PNUM es de tipo int o tambien se puede interpretar PNUM es un puntero hacia enteros, PNUM puede contener la direccin de una variabble de tipo entero.

Luego de la declaracin de un puntero en C, est puntero est ligado explcitamente a un tipo de datos. As por ejemplo la variable PNUM declarada como puntero sobre int no puede recibir direcciones de otro tipo de variables que no sean int. Esto limita entonces y elimina una cantidad de errores, que pueden deslizarse, y nos permite tambin la realizacin de una serie de operaciones prcticas con enteros
main() { /*Declaraciones*/ short A=10; short B=50; short *P; /*Procediemeirnto*/ P=&A; B=*P; *P=20; return 0; } main() { /*Declaraciones*/ short A,B,*P; /*Procesamiento*/ A=10; B=50; P=&A; B=*P; *P=20; return 0; }

Operaciones con punteros.* y &,!,++,--

Si un puntero P apunta a una variable X, entonces este smbolo puede reemplazar en todo momento a la variable X, as, por ejemplo:
P=&x; y=*P+1 <-> y=x+1 *P=*P+10 <-> x=x+10 *P+=2 <-> ++x ++*P <-> ++x (*P)++ <-> x++

Hay un puntero nulo

int *P; P=0; int A; int *P; P=&A;

A INICIO P1=&A 1 1

B 2 2

C 3 3

P1 // &A

P2 // //

Ejemplo
#include <stdio.h> main() { int A=1; int B=2; int C=3; int *P1,*P2; P1=&A; P2=&C; *P1=(*P2)++; P1=P2; P2=&B; *P1-=*P2; ++*P2; *P1*=*P2; A=++*P2**P1; P1=&A; *P2=*P1/=*P2; return 0; }

P2=&C P1=(*P2)++ P1=P2 P2=&B *P1-=*P2 ++*P2 *P1*=*P2 A=++*P2**P1 P1=&A *P2=*P1/=*P2

1 3 3 3 3 3 3 24 24 6

2 2 2 2 2 3 3 4 4 6

3 4 4 4 2 2 6 6 6 6

&A &A &C &C &C &C &C &C &A &A

&C &C &C &B &B &B &B &B &B &B

Relacin punteros-tablas.Direccionamiento de los elementos de una tabla El nombre de una tabla es un puntero constante sobre el primer elemento de dicha tabla, ejemplo:
int A[20]; int *P; P=A; <-> P=&A[0]; P+i=A[i] P-i=A[i-1] *P contenido de A[0] *(P+1) contenido de A[1] *(P+2) contenido de A[2] .. *(P+i) contenido de A[i] float A[15],X; float *P; -> P=A; X=*(P+9); <-> A[9]

Hay una diferencia esencial entre un puntero y el nombre de una tabla:

Un puntero es una variable, mientras que el nombre de una tabla es una constante.

Resumiendo, si tenemos una tabla de cualquier tipo que sea y siendo i un ndice para las componentes de la tabla, entonces A designa la direccin de la primera componente, A+i indica la direccin de la componente i-sima.

Un programa en C puede ser escrito utilizando el formalismo de tablas y traducirlo a un programa que emplee el formalismo de punteros. Ejercicio: Copiar los elementos positivos de una tabla T y trasladarlos a otra tabla. Formalismo de tablas.#include <stdio.h> main () { int T[10]={-3,4,0,-7,3,8,0,-1,4,-9}; int POS[10]; int I,J;/*Indices actuales para T y POS*/ for (I=0,J=0;I<10;I++) if (T[I]>0) { POS[J]=T[I]; J++; } return 0; }

Formalismo de punteros.#include <stdio.h> main () { int T[10]={-3,4,0,-7,3,8,0,-1,4,-9}; int POS[10]; int I,J;/*Indices actuales para T y POS*/ for (I=0,J=0;I<10;I++) if (*(T+I)>0) { *(POS+J)=*(T+I); J++; } return 0; }

Aclaraciones.Variables

int A; -> A &A

Designa el contenido de A Designa la direccin de A

Tablas
int B[]; -> B B[i] &B[i] Designa la direccin del primer elemento de la tabla B Designa el contenido de la componente i de la tabla B Indica la direccin de la componente i de la tabla B

Formalismo de punteros
B+i *(B+i) Indica la direccin de la componente i de la tabla B Indica el contenido de la componente i de la tabla B

Punteros
int *P; P Declara un punetro sobre elementos de tipo entero Puede apuntar sobre variables simples de tipo entero o bien sobre las componentes de una tabla de tipo entero, designa la direccin contenida en P, siendo esta direccin variable Designa el contenido de la direccin de P

*P

Si P apunta a una tabla -> P designa la direccin de la primera Componente. P+i *(P+i) Designa la direccin de la componente i detrs de P Designa el contenido de la componente i detrs de P

Escribir un programa que lea 2 tablas A y B de dimensiones L y M introducidas desde el teclado y que aade los elementos de B al final de A. Utilizar el formalismo de punteros cuando sea posible
# include <stdio.h> main() { /*Declaraciones*/ int A[100], B[50];/*Tablas dadas*/ int N,M;/*Valores de tabla*/ int I;/*Indice actual*/ /*Introduccin de datos*/ printf("Dimensin de A(max 50):"); scanf("%d",&N); for (I=0;I<N;I++) { printf("Elemento %d:",I); scanf("%d",A+I); } printf("Dimensin de B(max 50):"); scanf("%d",&M);

for (I=0;I<M;I++) { printf("Elemento %d:",I); scanf("%d",B+I); } /*Mostrar tablas*/ printf("Tabla A:\n"); for (I=0;I<N;I++) printf("[%7d]",*(A+I)); printf("\n"); printf("Tabla B:\n"); for (I=0;I<M;I++) printf("[%7d]",*(B+I)); printf("\n"); /*Copiar B al final de A*/ for (I=0;I<M;I++) *(A+N+I)=*(B+I); /*Nueva dimensin de A*/ N+=M; /*Mostrar la tabla resultante*/ printf("Tabla resultante A:\n"); for (I=0;I<N;I++) printf("%7d",*(A+I)); printf("\n"); return 0; }

Aritmtica de punteros.Todas las operaciones con punteros tienen automticamente. Afectacin por un puntero sobre el mismo tipo
P1=P2; -> si P->A[i] P+n ->A[i+n] P-n ->A[i-n] -> Si P->A[i] P++; P->A[i+1] P+=n; P->A[i+n] P--; P->A[i-1] P-=n; P->A[i-n]

La adicin, sustraccin, incrementacin y decrementacin con punteros, estn definidas solamente al interior de una tabla. Si la direccin formada por el puntero y el ndice sale del dominio de la tabla, entonces el resultado no est definido. Sin embargo hay una excepcin: Se permite apuntar al primer octeto despus de una tabla (a condicin de que este octeto se encuentre en el mismo segmento de memoria que la tabla). Esto nos permite legalizar la definicin de bucles o lazos que incrementen el puntero antes de la evaluacin de la condicin de detenerse.

int A[10]; int *P; P=A+9; -> Si cumple (elemento 10) P=A+10; -> Si cumple (elemento 11) P=A+11; -> No cumple (elemento 12) P=A-1; -> No cumple (elemento 0)

Sustraccin de punteros.Si P1, P2, son dos punteros que apuntan en la misma tabla, entonces P1 - P2 indica el nmero de componentes comprendidos entre P1 y P1 Si P1 P2 es negativo: Indica que P1 precede a P2. Si P1 P2 es cero: Indica que P1 es igual a P2. Si P1 P2 es positivo: Indica que P2 precede a P1. Si P1 P2 es indefinido: Indica que P1 y P2 no apuntan a la misma tabla. Comparacin de dos punteros.Se pueden comparar dos punteros con los smbolos <, >, <=, >=, ==, !=. La comparacin de dos punteros que apuntan a la misma tabla es equivalente a la comparacin de3 los ndices correspondientes. Dar un ejemplo en donde se vea porque en el lenguaje C se legaliza el manejo de punteros sobre el primer elemento despus de la tabla
# include <stdio.h> main() { /*Declaraciones*/ int A[10];/*Tabla dada*/ int *P;/*Puntero sobra A*/ /*Introduccin de datos*/ printf("Introducir 10 enteros:\n"); for (P=A;P<A+10;P++) scanf("%d",P); /*Mostrar la tabla*/ printf("Tabla A:\n"); printf("["); for (P=A;P<A+10;P++) printf("%7d",*P); printf("]\t");

printf("\n"); return 0; }

Sea P un puntero que apunta sobre una tabla A

int A[9]={12,23,34,45,56,67,78,89,90};/*Tabla dada*/ int *P;/*Puntero sobra A*/ P=A;

Indicar que valores se obtienen con las siguientes expresiones: 1. *P+2 = 14 2. *(P+2) = 34 3. &P+1 = Elemento despus de la direccin del puntero 4. &A[4]-3 = &A[1] 5. A+3 = &A[3] 6. &A[7]-P = &A[7] 7. P+(*P-10) = &A[2] 8. *(P+*(P+8)-A[7]) = 23 Punteros y matrices.int M[4][5]={{0,1,2,3,4},{5,6,7,8,9},{10,11,12,13,14},{15,16,17,18,19}}; M[0] -> {0,1,2,3,4} M[1] -> {5,6,7,8,9}

Se debe aadir una conversin automtica

int *P; P=M,/*Conversin automtica*/

En C se utiliza una conversin forzada

P=(int*)M;/*Concversin forzada*/

Realizar la suma de todos los elementos de la matriz

# include <stdio.h> main() { int M[4][10]={{0,1,2,3,4,5,6,7,8,9},{10,11,12,13,14,15,16,17,18,19},{20,21,22 ,23,24,25,26,27,28,29},{30,31,32,33,34,35,36,37,38,39}}; int *P; int I,SUMA;

P=(int*)M; SUMA=0; for (I=0;I<40;I++) SUMA+=*(P+I); printf("%d\n",SUMA); return 0; }

Escribir un programa que lea una matriz A de dimensiones N*M introducidas desde el teclado utilizando el formalismo de punteros siempre que sea posible.
# include <stdio.h> main() { int A[50][50];/*Matriz dada*/ int N,M;/*Dimensiones de la matriz*/ int I,J;/*Contador actual*/ /*introduccin de datos*/ printf("filas A(max 50):"); scanf("%d",&N); printf("Columnas A(max 50):"); scanf("%d",&M); for (I=0;I<N;I++) for (J=0;J<M;J++) { printf("Elemento [%d][%d]:",I,J); scanf("%d",(int*)A+I*50+J); } /*Mostrar la matriz*/ printf("Matriz dada:\n"); for(I=0;I<N;I++) { for(J=0;J<M;J++) printf("%5d",*((int*)A+I*50+J)); printf("\n"); } /*Calcular y mostrar la transpuesta de A*/ printf("Matriz transpuesta:\n"); for (J=0;J<M;J++) { for(I=0;I<N;I++) printf("%5d",*((int*)A+I*/*numero de columnas*/50/*numero de columnas*/+J)); printf("\n"); } return 0; }

Examen
# include <stdio.h> main() { int N,M,P;/*Dimensiones*/

int I,J,K;/*Contadores*/ int A[50][40],B[50][40],C[50][50]; printf("introducir el # de filas de la matriz A:"); scanf("%d",&N); printf("Introducir el # de columnas de A (filas de B):"); scanf("%d",&M); for (I=0;I<N;I++) for (J=0;J<M;J++) { printf("Elemento [%d][%d]:",I,J); scanf("%d",(int*)A+I*40+J); } printf("Introducir el # de columnas de B:"); scanf("%d",&P); for (I=0;I<M;I++) for (J=0;J<P;J++) { printf("Elemento [%d][%d]:",I,J); scanf("%d",(int*)B+I*40+J); } /*Mostrar tablas*/ printf("Matriz A:\n"); for(I=0;I<N;I++) { for(J=0;J<M;J++) printf("%5d",*((int*)A+I*40+J)); printf("\n"); } printf("Matriz B:\n"); for(I=0;I<M;I++) { for(J=0;J<P;J++) printf("%5d",*((int*)B+I*40+J)); printf("\n"); } /*Matriz final*/ for(I=0;I<N;I++) { for(J=0;J<P;J++) { C[I][J]=0; for(K=0;K<M;K++) { C[I][J]=(C[I][J]+A[I][K]*B[K][J]); } } } printf("Matriz final:\n"); printf("\n"); for(I=0;I<N;I++) { for(J=0;J<P;J++) printf("%5d",C[I][J]); printf("\n"); } return 0; }

Supletorio.# include <stdio.h> main() { float X;/*Real multiplicativo*/ int M,N;/*Dimensiones*/ int I,J;/*Contadores*/ int A[50][40]; printf("introducir el # de filas de la matriz A:"); scanf("%d",&M); printf("Introducir el # de columnas de A:"); scanf("%d",&N); for (I=0;I<M;I++) for (J=0;J<N;J++) { printf("Elemento [%d][%d]:",I,J); scanf("%d",(int*)A+I*40+J); } /*Mostrar tablas*/ printf("Matriz A:\n"); for(I=0;I<M;I++) { for(J=0;J<N;J++) printf("%5d",*((int*)A+I*40+J)); printf("\n"); } printf("Introduzca el # real:"); scanf("%f",&X); /*talba multiplicada*/ printf("Matriz Multiplicada:\n"); for(I=0;I<M;I++) { for(J=0;J<N;J++) printf("%10.4f",X*(*((int*)A+I*40+J))); printf("\n"); } return 0; }