Lenguaje C, Manual de Programacion - M.C. Enrique Ruiz Diaz

Autor: M.C. Enrique Ruiz Díaz Lenguaje de Programación C - (Materia: ‘Programación I’)

1

Manual de Lenguaje C Cubre la Materia ‘Programación 1’

Autor: M.C. Enrique Ruiz Díaz

Visite: http://www.scribd.com/enriqueruizdiaz

Asimismo: http://sites.google.com/site/enriqueruizdiaz/


2

LENGUAJE DE PROGRAMACION C

______________________________________________________________________________________ # include <stdio.h> # define PI 3.141596 float Area (int radio); float Area (int radio) { float area; area=PI*radio*radio; return area; } void main() { int r = 5; float a; a = Area(r); printf ("Area del circulo %f\n",a); getch(); } ______________________________________________________________________________________ # include Declara las cabeceras del programa # include <stdio.h> Permite incluir al programa una función de nombre <stdio.h>

Standard Input Output “funciones de entrada salida” (hace que el programa funcione)

# include <math.h> También puede haber una línea con esta instrucción, la cual

permite usar en el programa funciones matemáticas tales como exponenciación, seno, coseno, tangente, etc.

# include <stdio.h> Las < > quiere decir que los archivos del subdirectorio include

están en esta ruta C:\TC\INCLUDE # include “stdio.h” Se utilizan las “ “ cuando la libreria (archivos del subdirectorio

include) este en el directorio de trabajo. C:\TC # define PI 3.141596 Esta instrucción que se encuentra en la parte inicial del programa

permite crear una constante valida para todo el programa. En este caso la constante se llama “PI” y toma un valor de 3.141596. (vea que no lleva el signo de = )

float Area (int radio); Esta línea se llama “DECLARACIÓN DE PROTOTIPOS” Declara al programa que función buscará, como se llama dicha función, que tipo de dato va a regresar, cuantos parámetros tiene y cuales son.


3

DECLARACIÓN DE PROTOTIPOS

float Area (int radio); Observe que esta línea termina con un punto y coma, en la definición anterior nos dice que se declara que función va a buscar, en este caso la función se llama “Area” (Entendamos que función es un pequeño subprograma que realiza una tarea). Nos dice también que tipo de dato va a regresar la función “Area”; vea que le precede la palabra “float” esto es que regresara una valor numérico flotante o número real. En este caso la declaración del prototipo solo tiene un parámetro que es “radio” que es una variable que se utiliza para transferir información a la función, y el dato que se transferirá es un numero entero, esto nos lo indica la palabra “int” float Area (int radio) { ... ... }

En esta línea tenemos la “DEFINICIÓN DE LA FUNCIÓN” es decir, cuando realmente empieza a realizar la tarea para la cual fue diseñada. Vea que es casi idéntica a la línea de Declaración, solo que esta no termina con punto y coma, y entre corchetes se escribe el cuerpo de esta función de nombre “Area”

void main( ) { ... ... }

Todos los programas deben tener la función main() que es el cuerpo principal del programa. Aunque en nuestro programa de ejemplo la función main() se encuentra después de la función Area, en realidad el programa siempre se dirige primero al cuerpo del main() y luego se ejecutara la función secundaria, en este caso “Area” cuando esta sea llamada. a = Area(r); Esta instrucción dentro del main() es la que llama la ejecución de la función “Area” y de paso le transfiere el valor que tiene “ r ” que es de 5, y este valor será recibido por el parámetro (variable) “radio” de la función

return area; Al terminar de ejecutarse la función “Area” desaparecen todas

sus variables y sus valores. Sin embargo, esta instrucción permite regresar el valor de la variable area y, este valor será recibido por la variable “a” de main()

DEFINICIONES LIBRERIA: Una Libreria contiene funciones especificas. En el programa se usa una libreria con la linea: # include ejemplo: Contiene seno() LIBRERIA funciones coseno() math.h como: sqrt() pow()


4

TIPOS DE DATOS EN C char Caracter int valor númerico entero float valor número flotante (real) double flotante de doble presición void Sin valor

Tipo Tamaño aproximado en bits Rango minimo Char 8 -127 a 127 unsigned char 8 0 a 255 signed char 8 -127 a 127 Int 16 -32,767 a 32,767 unsigned int 16 0 a 65,535 signed int 16 -32,767 a 32,767 short int 16 -32,767 a 32,767 unsigned short int 16 0 a 65,535 signed short int 16 -32,767 a 32,767 long int 32 -2,147,483,647 a

2,147,483,647 unsigned long int 0 a 4,294,967,295 signed long int 32 -2,147,483,647 a

2,147,483,647 Float 32 6 dígitos de precisión Doublé 64 10 dígitos de precisión Nota: Como en el caso de unsigned char ya no usa el primer bit reservado al signo por lo que hay mas capacidad de almacenamiento. Observe como en otros casos, también se elimina el signo (se deja solo como positivo) y se aumenta la capacidad. Ejemplo de cantidad de bytes ocupado por diferentes variables (8 bits = 1 byte) char sexo, nombre[31]; 32 bytes int edad; 2 float estatura 4 double masa_atomica; 8 total de bytes ocupados 46 Nota: en el caso de la variable caracter char sexo, ya sabemos que ocupa 8 bits = 1 byte, pero a la variable char nombre se le asigna un espacio de 31, es decir, 31 bytes, de ahi la suma de 32 bytes.


5

NOMBRE DE IDENTIFICADORES Los nombres usados para referenciar las variables, las funciones, las etiquetas y otros objetos definidos por el usuario se conocen como identificadores. Las reglas para escribir los nombres de los identificadores son: 1. Se pueden usar las letras del alfabeto tanto mayúsculas y minúsculas; así como también los

dígitos del 0 al 9 y el caracter de subrayado o “underline” 2. Los nombres de los identificadores deben de comenzar con una letra seguida de 1 o mas

letras ó los dígitos del 0 al 9 3. Cuando un nombre de identificador contenga mas de una palabra, entonces deberán ser

unidas por el caracter de subrayado. 4. No podrán ser usadas como identificadores las siguientes palabras reservadas: auto

break rase char const continue default do double else enum extern float

for goto if int long register return short signed sizcuf switch typedef union

unsigned void volatile while struct

VARIABLE : Una variable es una posición de memoria con nombre que se usa para mantener que puede ser modificado por el programa. La característica de la variable es que tiene una dirección en memoria y un contenido. Su forma general es: tipo lista_ de_variables; donde: tipo: Es un tipo de dato valido de C con cualquier modificador. Ejemplo de tipo: char (caracter) int (número entero) lista_de_variables: Puede consistir en uno o mas identificadores separados por comas: ejemplo: nombre, domicilio, sexo, etc.


6

DIFERENTES TIPOS DE VARIABLES VARIABLES LOCALES: Son definidas por una función y solo dentro de ella es reconocida. Por ejemplo, en el programa siguiente: ______________________________________________________________________________________ void f (void) 1 { int t ; 2 scanf (“%d”, &t); if (t = = 1) { char s[80]; 3 printf (“Introduzca el nombre:”); gets(s); } } ______________________________________________________________________________________ 1 Tenemos una función de nombre ‘f ’ que no devuelve ningún valor (primer void), ni recibe ningún valor (segundo void)

2 ´t ´ es una Variable local de tipo entero. Es variable local porque solo existe mientras se ejecuta la función, al terminar de ejecutarse, la variable se destruye.

3 ´s ´ es una variable de tipo caracter con 80 posiciones (80 bytes), es variable local porque existe dentro de la función ´f ´ pero a la vez solo es reconocida si se entra al ciclo if ... si no se entrara al ciclo if entonces no se crea la variable ´s ´ PARAMETROS FORMALES: Sirven para transferir información hacia las funciones, en la definición de la función. ______________________________________________________________________________________ esta_en 1 ( char * s, char c ) 2 { while ( * s ) if ( *s = = c ) return 1; else { s + +; return 0; } }


7

______________________________________________________________________________________ 1 Esta función se llama “esta_en” y vea que no tiene un tipo de dato, entonces devuelve un entero int esta_en ... 2 ( char * s, char c ) estos son dos parametros formales los cuales han de recibir valores provenientes de otra parte del programa. los dos parametros son de tipo char (caracter). PARAMETROS ACTUALES: 3 Son usados en el llamado de la función, dentro de main( ). ______________________________________________________________________________________ void main( ) { int valor; valor = esta_en (“LA CASA BLANCA”, “B”)3 ; if (valor = = 1) printf (“Esta en la cadena”); else printf (“No esta en la cadena”); } ______________________________________________________________________________________ VARIABLES GLOBALES: Estas variables estan fuera de main() y fuera de cualquier otra función y son reconocida en todo el programa. ______________________________________________________________________________________ # include “stdio.h” int cuenta; 4 void func1 (void); void func2 (void); void func1 (void) { int temp; 7 temp = cuenta; 7 func2( ); 8 printf (“La cuenta es %d”, cuenta); 1 1 } void func2 (void) { int cuenta; 9 for (cuenta=1; cuenta<10; cuenta ++) 1 0 putchar(‘ . ’); } void main ( ) { cuenta = 100; 5 func1 ( ); 6 } ______________________________________________________________________________________


8

4 int cuenta; en esta línea vemos una variable de tipo entero (int) que se llama “cuenta” y como esta fuera de main ( ) y fuera de cualquier otra función es variable global, es decir, que será reconocida en cualquier parte del programa. 5 Recuerde que no importa en que parte del programa se encuentre la función main () (principal) el programa siempre ejecuta esta función antes que otras funciones (en este caso ejecuta primero main() antes que func1 y func2). La variable global cuenta toma un valor de 100. 6 Se hace un llamado para ejecutar la función “func1” 7 Dentro de la función func1( ) se crea la variable local “temp” y vea que en la siguiente línea la variable local “temp” toma el valor de la variable global “cuenta”. Por lo que “temp” vale 100 8 En esta línea se hace un llamado a la función “func2” 9 Se crea una variable local de nombre “cuenta” es variable local porque esta creada dentro de la función func2() y solo tiene validez para ella. Recuerde que tenemos también una variable global de nombre “cuenta” y que vale 100. pero dentro la función func2 se creo una variable local del mismo nombre, entonces dentro de esta función la variable que existe es la variable local. 1 0 Este es un ciclo repetitivo for en la cual la variable local “cuenta” toma un valor de 1 hasta 10. 1 1 Al terminar de ejecutarse la función func2 regresamos a la función func1, y se imprime el valor de la variable global “cuenta” que vale 100. Cuando salimos de la función func2 todas sus variables locales se destruyeron.

OPERADORES ARITMETICOS SUMA + RESTA - MULTIPLICACION * RESIDUO ENTERO % RAIZ CUADRADA sqrt ( ) POTENCIACION pow (base, exponente) ¿Que es el Residuo Entero? En algoritmo al residuo entero se le llama “mod ó modulo” Por ejemplo: 5 mod 2 = 1 ó 5 % 2 = 1 porque: 2 2 5 1 Residuo o Modulo


9

PRIORIDAD DE LOS OPERADORES EN GENERAL

1. ( ) 2. ^ 3. *, /, mod, div, NOT 4. +, -, AND 5. >, <, <=, >=, < >, =, OR ¿Cuando se usan los parentesis ? Cuando se quiere dar prioridad a cierta operación sobre otras. Por ejemplo: m = y2 - y1 = Expresarlo en forma correcta para programación ... x2 - x1 m = y2 - y1 / x2 - x1 No es correcto !!! m = (y2 - y1) / (x2 - x1) Si es correcto FUNCIÓN DE C PARA LA POTENCIA. pow (base, exponente) Por ejemplo: 1. X2 = pow (X,2) 2. h = a2 + b2 = h = pow (a,2) + pow (b,2) 3. (a (b + c))2 = pow (a*(b + c), 2); porque : (a*(a + c)) es la base y 2 es el exponente FUNCIÓN DE C PARA LA RAIZ: sqrt ( ) Por ejemplo: 1. x = a x = sqrt (a) 2. a = a + b a = sqrt ( a + b) 3. A = P(P - A)(P - B)(P - C)


10

A = sqrt ( P * (P - A) * (P - B) * (P - C) ) Expresar en forma correcta para programación lo siguiente 1. x = - b + - b2 - 4ac 2a x1 = (-b + sqrt (pow(b,2) - 4*a*c)) / (2*a) x2 = (-b - sqrt (pow(b,2) - 4*a*c)) / (2*a) 2. despejar m de : pv = m( t + 460) pv = m (t + 460) m = pv = (t + 460) m = (p*v) / (t + 460) 3. Expresar para programación: d = (X2 - X1)2 + (Y2 - Y1)2 d = sqrt ( pow((X2 - X1), 2 ) + pow (( Y2 - Y1), 2)) 4. h2 = a2 + b2 h = a2 + b2 h = sqrt ( pow(a,2) + pow(b,2) ) 5. d = x2 + y2 d = sqrt ( pow (x,2) + pow (y,2) )


11

OPERADORES LOGICOS 1. NOT ! 2. AND && 3. OR || Los operadores logicos se utilizan para establecer condiciones compuestas TABLA DE VERDAD DE LOS OPERADORES LOGICOS

NOT A !A Comentario

V F

F V

El NOT convierte de verdadero a falso y, de falso a verdadero.

AND A B A && B Comentario

V V F F

V F V F

V F F F

Para el AND con uno de sus dos elementos que sea falso, el resultado es falso.

OR A B A || B Comentario V V F F

V F V F

V V V F

Para el OR con uno de sus dos elementos que sea verdadero, el resultado es verdadero.

OPERADORES RELACIONALES: Establecen condiciones en un programa 1. Mayor que > 2. Mayor o igual que >= 3. Menor que < 4. Menor o igual que <= 5. Igual que = = 6. Diferente ! =


12

El signo igual que = = En algoritmo ponemos ... Si a = b entonces ... ... fin_si En progración debemos poner .. if (a = = b) ... Ya que en if (a = b), para C es un error ya que a toma el valor que tenga b, no funciona. Para C el signo de = es de Asignación, es decir, la variable toma el valor de lo que tenga enfrente, por ejemplo: x = a; ‘x ’ toma el valor de lo que valga ‘a’ a = b + c; ‘a ‘ toma el valor del resultado de la suma de b + c A la utilización del signo = se le llama Asignación. Pero ... Si queremos Comparar dos valores, bien en un ciclo if, while, u otro entonces usaremos el signo de Comparación o igual que ... = = if ( c = = b ) “ Si c es igual a b entonces ... “ while ( a = = d ) “ Hacer mientras a sea igual a d “ El signo diferente != En algoritmo poniamos ... Si a < > b entonces ... ... fin_si En programación utilizaremos .. if ( a != b) ... ... Es decir, “si a es diferente de b” entonces se entra al ciclo if


13

OPERADORES ESPECIALES:

Son monarios porque solo se aplican a un operando. 1. De incremento + + 2. Decremento - - Su uso: 1. Modo prefijo (pre - antes) + + a 2. Modo posfijo (pos - después) a + + MODO PREFIJO + + a Se incrementa ‘a’ en 1 y despues se usa. MODO POSFIJO a + + Primero se usará ‘a’ luego su valor se incrementará en 1 Por ejemplo: ______________________________________________________________________________________ a = 5; ++a; 1 printf ( “%d”, a); 2 a ++; 3 printf (“%d”, a); 4 printf (“%d”, a); 5 ______________________________________________________________________________________ 1 Inmediatamente se incrementa ‘a’ en 1 (o sea, a = 6) 2 Se imprime el valor de ‘a’, se imprime 6 3 Primero debera ser usado ‘a’, luego su valor se incrementará en 1 4 Se imprime el valor de a que es 6, en ese momento se ha usado ‘a’ por lo que se incrementa ‘a’ en 1 ( a = 7) 5 Se imprime el valor actual de a que es 7

FUNCIONES BASICAS FUNCION scanf (“ formato “, nombre_ver) ; Especificadores de Formato % c Caracter % d Entero decimal


14

% i Entero decimal % e flotante % f flotante % g flotante % o octal % s Cadena de caracteres % x Hexadecimal Especificamos cualquiera de los “Especificadores de formato” dependiendo de lo que se vaya a leer (El dar un dato por teclado significa “leer” ). Ejemplos: scanf (“ % c ”, &sexo); Nos pide que tecleemos (leamos) el sexo de la persona, el

“ %c “ significa que sexo es una variable de tipo caracter, y vea que al utilizar el scanf, a la variable se le antepone el &, lo cual significa que guarde en la dirección en la cual esta almacenada la variable.

scanf (“ % d “ , &edad); Nos pide que tecleemos la edad de la persona, el “ % d “

significa que debe ser un valor numérico entero en decimal (es decir, no octal, no hexadecimal).

scanf (“ % o “, &numero); Nos pide que leamos un número, pero en octal, por ejemplo

si capturo 10 en realidad es un 108 (diez en octal). scanf (“ % x “, &numero); Nos pide que leamos un número, pero en hexadecimal, por

ejemplo si capturo 10 en realidad es un 1016 (diez en hexadecimal).

scanf (“ % f ”, &estatura); Nos pide que tecleemos la estatura, el “ % f ” significa que

debe ser un valor numérico flotante ( numero real ) scanf (“ % e ”, &estatura); Nos pide que tecleemos la estatura, el “ % e ” significa que

debe ser un valor numérico en notación exponencial. Por ejemplo para un número como 0.0325 deberé teclear 3.25 e - 2 que es igual a 3.25 x 10-2

scanf (“ % s “, nom); Nos pide que tecleemos una cadena de caracteres. Por

ejemplo “Felipe de Jesus” . El problema con esta instrucción es que solo guardaría la palabra “Felipe” se requiere la instrucción siguiente para guardar la siguiente palabra “de”. (Esta instrucción no es apropiada para guardar cadena de caracteres, se debe usar la función gets ( ) como veremos mas adelante).

scanf (“ % i “, &peso); Toma lo que haya en el buffer de memoria ( en este caso la

palabra “de” ) y lo guarda en &peso


15

FUNCION gets ( ) Permite leer cadena de caracteres completas incluyendo espacios en blanco. gets (nom_var_cadena); Ejemplo: char nom[31] .... .... gets (nom); FUNCIÓN printf ( ) Visualiza mensajes, así como valores de variables. printf ( cadena_de_control ); La cadena de control esta formada por dos tipos de elementos. El primer tipo esta compuesto por los caracteres que se mostrarán en la pantalla. El segundo tipo contiene especificadores de formato que define la forma en que muestran los argumentos posteriores. Un especificador de formato empieza con un signo de porcentaje y sigue con el codigo de formato debe haber exactamente el mismo número de argumentos que de especificadores de formato y ambos deben coincidir en su orden de aparición de izquierda a derecha. Especificadores de Formato % c Caracter % d Enteros decimales con signo % i Enteros decimales con signo % e Notación cientifica ( e minuscula) % E Notación cientifica ( E mayuscula) % f flotante (despues del punto decimal tiene 6 digitos de precisión) % g Usar % e ó % f, el más corto (selecciona automaticamente la expresión mas corta) % G Usar % E ó % F, el más corto % o octal sin signo % x Hexadecimal sin signo (letras minusculas) % X Hexadecimal sin signo (letras mayusculas) % s Cadena de caracteres % U Enteros decimales sin signo % p Muestra un puntero


16

Por ejemplo: int numero = 25; printf ( “ % d “, numero); imprime 25 printf ( “ % i “, numero); imprime 25 printf ( “ % o “, numero); imprime 31 (numero octal) printf ( “ % x “, numero); imprime 19 printf (“ % u “, numero); imprime 25 printf ( “ % X “, numero + 6); imprime 1F (numero hexadecimal) Nota: Si no hubiera avance de línea entonces imprimiria 25253119251F así pues, se requiere especificar un “avance de Línea” con \n Por ejemplo: printf (“ % d \n ”, numero); Con la instrucción printf ( ) también puede imprimirse un texto y a la vez el valor de una variable, vea como: int num = 15; printf (“ La variable num vale: % d “, num); se imprime en pantalla: 15 Vea como el texto: “ La variable num vale: ” esta dentro de las comillas, y también el especificador de formato % d, y fuera de las comillas va una coma y la variable que se va a imprimir, en este caso num. Si voy a imprimir una variable entonces necesito un especificador de formato. otro ejemplo: int a = 2, b = 8, c; c = a + b; printf (“%d + %d = %d \n”, a, b, c); Se imprime en pantalla: 2 + 8 = 10 Observaciones: considere los signos +, = como simple texto que se imprime, vea como tenemos tres especificadores de formato que afectan a tres variables respectivamente. Imprimir un número real con una cantidad determinada de decimales Si queremos imprimir un numero real con una cierta cantidad de decimales usaremos el siguiente formato:


17

printf (“ % 5.2 f “, numero); Se imprimaran en total 5 números dos de los cuales serán para caracteres, así: XXX.XX Elaborar un programa que dado un número de cuatro cifras, lo presente invertido en su orden. Por ejemplo se le lee el numero 4895 debe imprimirse el numero 5984 ______________________________________________________________________________________ # include <stdio.h> # include <math.h> void main() { int A, B, C, X1, X2, X3, Num2, Num; printf ("Dame un numero de 4 digitos:"); scanf ("%4d", &Num); A=Num % 1000; X1=Num / 1000; B=A % 100; X2=A / 100; C=B % 10; X3=B / 10; Num2 = (C*1000) + (X3*100) + (X2*10) + X1; printf ("El resultado es: %d\n", Num2); getch(); } ______________________________________________________________________________________ Tres personas desean establecer una empresa para la cual cada una de ellas hace una aportación económica para integrar el capital social de dicha empresa. Hacer un programa determina el porcentaje de participación que tendrán en la empresa. ______________________________________________________________________________________ # include <stdio.h> void main() { float cap1, cap2, cap3, capsocial, part1, part2, part3; printf ("Importe del primer inversionista:");


18

scanf ("%f", &cap1); printf ("Importe del segundo inversionista:"); scanf ("%f", &cap2); printf ("Importe del tercer inversionista:"); scanf ("%f", &cap3); capsocial = cap1 + cap2 + cap3; part1 = (100/capsocial) * cap1; part2 = (100/capsocial) * cap2; part3 = (100/capsocial) * cap3; printf ("Porcentaje del primer inversionista: %3.0f \n", part1); printf ("Porcentaje del segundo inversionista: %3.0f \n", part2); printf ("Porcentaje del tercer inversionista: %3.0f \n", part3); getch(); } ______________________________________________________________________________________ Hacer un programa que determine la distancia que hay entre dos puntos de una línea recta en el plano cartesiano. Así como también la pendiente de esa línea recta. Utilizando las siguientes fórmulas: d = (x2 - x)2 + (y2 - y1)2 m = y2 - y1 x2 - x1 ______________________________________________________________________________________ # include <stdio.h> # include <math.h> void main() { float x2, x1, y2, y1, d, m; printf ("El valor de x2:"); scanf ("%f", &x2); printf ("El valor de x1:"); scanf ("%f", &x1); printf ("El valor de y2:"); scanf ("%f", &y2);


19

printf ("El valor de y1:"); scanf ("%f", &y1); d = sqrt (pow((x2-x1),2) + pow((y2-y1),2)); m = (y2-y1) / (x2-x1); printf ("El valor de d es: %f \n", d); printf ("El valor de m es: %f \n", m); getch(); } ______________________________________________________________________________________

SENTENCIAS SELECTIVAS FUNCION if ( ) Sintaxis: a) if (expresión) sentencia; b) if (expresión) { ... sentencias; ... } ¿Que entendemos por “expresión” ? En algoritmo (y en C) para entrar a un ciclo sea if u otro, utilizaremos una condición tal como if (a > b) ... , if ( x = = 0) ... etc. Lo que hemos visto son condiciones (que si a es mayor a b, que si x es igual a cero entonces se entra al ciclo) pero en lenguaje C no tan solo puede haber condiciones sino expresiones tales como ... if ( a ) En esta expresión “ ( a ) ” significa que si ‘a’ tiene un valor previo de 0 entonces la expresión es falsa y no se entra al ciclo, si ‘a’ tiene un valor de 1 en adelante entonces la expresión es cierta y si se entra al ciclo. Otro ejemplo de “expresión”. if ( a + 5)


20

En esta expresión “ (a + 5) “ si la suma de lo que vale ‘a’ mas 5 es igual a 0 entonces la expresión es falsa y no se entra al ciclo, si la suma de ‘a’ mas cinco da 1 ó mas entonces la expresión es verdadera y se entra al ciclo. Otro ejemplo de “expresión”. if ( digito(num) ) El programa se dirige a la función “dígito” si en esta función el valor de “num” es cero entonces la expresión es falsa, si “num” vale 1 ó mas entonces la expresión es verdadera. Observación sobre el uso del signo de comparación de igualdad en los ciclos Recuerde que para C el signo = es de “asignación” y la comparación de igualdad se efectúa con el signo = = de tal forma que si por ejemplo tengo : 1. if ( a = 0 ) 2. if ( a = = 0 ) El primer ejemplo es incorrecto, ya que ‘a’ toma el valor de cero, no funciona el ciclo ya que si ‘a’ siempre vale cero entonces la expresión siempre será falsa. El segundo ejemplo esta bien expresado, si a es igual con 0 entonces el ciclo toma una valor de 1, o sea es verdadero y si se entra al ciclo. Si ‘a’ no es igual a 0 entonces el ciclo toma un valor de 0, o sea es falso y no se entra al ciclo. ANALISIS DE LA SINTAXIS DE LA FUNCION if ( ) Sintaxis: a) if (expresión) sentencia; b) if (expresión) { ... sentencias; ... } Observe que cuando hay una sola sentencia (una sola línea de instrucción) entonces no habrá llaves al principio y final de dicha sentencia. Y al no haber llaves el lenguaje C entiende que solo hay una sentencia que pertenece al if.


21

Si hay mas de una sentencia (dos o más) entonces debe haber llave que abre al principio y una llave que cierra al final de la sentencias. Funcion if ( ) ... else Sintaxis: a) if (expresión) sentencia; else sentencia; b) if (expresión) { ... sentencias; ... } else { ... sentencias; ... } c) if (expresión) { ... sentencias; ... } else sentencia; d) if (expresión) sentencia; else { ... sentencias; ... }


22

En la función if ( ) ... else Si para el cuerpo del if no se abre llave, el lenguaje C entiende que solo hay una sentencia que pertenece a la parte del if, igual ocurre con la parte del else, si no se abren llaves se entiende que solo le corresponde una sola sentencia. Si para un bloque sea este el if o el else le corresponden dos o mas sentencias, entonces debe haber llaves que cubran todas las sentencias que les pertenece. Programa: En un supermercado se hace una promoción, mediante la cual el cliente obtiene un descuento dependiendo de un numero que se escoge al azar. Si el numero escogido es menor que 74 el descuento es del 15 % sobre el total de la compra, si es mayor o igual a 74 el descuento es del 20%. Obtener cuanto dinero se le descuenta ______________________________________________________________________________________ # include <stdio.h> void main() { int num; float compra, desc; printf ("Valor del numero:"); scanf ("%d", &num); printf ("Importe de la compra:"); scanf ("%f", &compra); if (num< 74) desc = compra * .15; else desc = compra * .20; printf ("Descuento efectuado: %5.2f ", desc); getch(); } ______________________________________________________________________________________


23

SENTENCIA SWITCH( ) ... CASE Es una sentencia de control selectiva, es decir, de un menú previo se elige solo una opción, y solo se ejecutara el bloque correspondiente a la opción elegida. Sintaxis switch (expresion) { case <valor_1>: ... sentencias; ... break; case <valor_2>: ... sentencias; ... break; case <valor_n>: ... sentencias; ... } Donde: valor_ Es un valor constante o fijo break Significa que no se revisen los otros casos, que una vez que el programa ha seleccionado y ejecutado un determinado bloque, después de ello debe salirse del ciclo. Observe que en el ultimo bloque ya no requiere un break porque si el programa entra a este ultimo bloque, lo ejecuta y luego sigue la salida del programa. Programa: Este permite al usuario llevar a cabo el calculo del área de cualquier de las siguientes figuras geométricas: 1. Cuadrado 2. Rectángulo 3. Triángulo 4. Circulo ______________________________________________________________________________________ # include <stdio.h> # define PI 3.141596


24

void main( ) { int l, b, h, r, opc; float a; printf ("Menu de figuras geometricas \n"); printf ("1.- Cuadrado \n"); printf ("2.- Rectangulo \n"); printf ("3.- Triangulo \n"); printf ("4.- Circulo \n"); printf ("Opcion:"); scanf ("%d",&opc); switch (opc) { case 1: printf ("Calculo del area de un cuadrado\n"); printf ("Longitud del lado:"); scanf ("%d", &l); a = l * l; printf ("Area = %f \n", a); break; case 2: printf ("Calculo del area del rectangulo \n"); printf ("Longitud de la base"); scanf ("%d", &b); printf ("Longitud de la altura:"); scanf ("%d", &h); a = b * h; printf ("Area = %f \n", a); break; case 3: printf ("Calculo del area del triangulo:"); printf ("Longitud de la base:"); scanf ("%d", &b); printf ("Longitud de la altura:"); scanf ("%d", &h); a = b * h / 2; printf ("Area = %f \n", a); break; case 4: printf ("Calculo del area del circulo:"); printf ("Valor del radio:"); scanf ("%d", &r); a = PI * r * r; printf ("Area = %f \n", a); } getch(); } ______________________________________________________________________________________


25

SENTENCIA DE CONTROL DE CICLOS 1. SENTENCIA while ( ) Hacer mientras la condición sea cierta, en el momento que la condición sea falsa se sale. Si la condición fuera falsa desde un principio entonces nunca entra. Sintaxis: 1. while (expresión) sentencia; 2. while (expresión) { ... sentencias; ... }

Condición

Sentencias

V F


26

Observe que el ciclo while al igual que el if, si solo le pertenece una sentencia, no se usan llaves, el lenguaje C entiende que solo hay una sola sentencia para el ciclo. Si al ciclo le corresponden dos o mas sentencias entonces estas deberán estar cubiertas con llaves que abran y cierren, como en el segundo caso. Programa: Se desea obtener cual fue la mayor, la menor y el promedio de calificaciones obtenido por un grupo de 20 alumnos. ______________________________________________________________________________________ # include <stdio.h> # define max 20 void main() { int ca=1, scal=0, cal, may, men; float prom; while (ca <= max) { printf ("Introduzca la calificacion del %d alumno:", ca); scanf ("%d", &cal); if (ca == 1) { may = cal; men = cal; } else if (cal > may) may = cal; else if (cal < men) men = cal; scal+ = cal; ++ca; } prom = scal / max; printf ("Promedio: %5.2f \n", prom); printf ("Calificacion mayor: %d \n", may); printf ("Calificacion menor: %d \n", men); getch( ); } ______________________________________________________________________________________


27

Programa: Una persona debe realizar un muestreo con 50 personas para determinar el promedio de peso de los niños, jóvenes, adultos y viejos que existen en una zona habitacional. Se determina la categoría con base en la siguiente tabla. Categoría Edades Niños 0 - 12 Jóvenes 13 - 29 Adultos 30 - 59 Viejos 60 ... ______________________________________________________________________________________ # include <stdio.h> void main( ) { float edad, ninos=0, suma1=0, joven=0, suma2=0, adultos=0; float suma3=0, viejos=0, suma4=0; float prom_n, prom_j, prom_a, prom_v; int c = 0; while (c < 50) { printf ("Edad de la persona:"); scanf ("%f", &edad); if (edad <=12) { suma1+=edad; ninos+=1; } else if (edad <=29) { suma2+=edad; joven+=1; } else if (edad <=59) { suma3+=edad; adultos+=1; } else { suma4+=edad; viejos+=1; } c+=1; }


28

prom_n=suma1/ninos; prom_j=suma2/joven; prom_a=suma3/adultos; prom_v=suma4/viejos; printf ("Promedio de peso de los niños %5.2f \n", prom_n); printf ("Promedio de peso de los jovenes %5.2f \n", prom_j); printf ("Promedio de peso de los adultos %5.2f \n", prom_a); printf ("Promedio de peso de los viejos %5.2f \n", prom_v); getch(); } ______________________________________________________________________________________ Observaciones: 1. En este programa vea que en los ciclos if ... else las instrucciones que corresponden a cada if están cubiertas por llaves, pero cuando a un else le sigue un if no se usan llaves para cubrir a este if, dado que no es necesario, ya que se toma por una sola instrucción, independientemente de todas las instrucciones que dentro de ese if estén, pero esas instrucciones ya corresponden al if interno y no al else 2. El programa funciona, pero si por ejemplo no hubiera niños, entonces niños=0, y suma1=0, y 0/0 es un error para C. Programa: Un entrenador le ha propuesto a un atleta recorrer una ruta de 5 km. durante 10 días, para determinar si es apto para la prueba de 5 km. o debe buscar otra especialidad. Para considerarlo apto debe cumplir por lo menos una de las siguientes condiciones. 1. Que en ninguna prueba haga un tiempo mayor a 16 minutos. 2. Que al menos en una prueba realice un tiempo mayor de 16 minutos. 3. Que su promedio de tiempo sea menor o igual a 15 minutos. ______________________________________________________________________________________ # include <stdio.h> void main() { int c=0, x=0, r1=1, r2=1, r3=1; float suma=0, tiempo=0, prom; while (c<10) { printf ("Tiempo hecho:"); scanf ("%f", &tiempo); if (tiempo <=16 && r1==1) r1=1; else r1=0;


29

if (tiempo>16 && x<1) { r2=1; x+=1; } else if (tiempo <=16 && r2==1) r2=1; else r2=0; suma+=tiempo; c+=1; } prom=suma/10; if (prom<=15) r3=1; else r3=0; printf ("Prom. es: %f, prueba1= %d, prueba2 = %d, prueba3 = %d \n", prom, r1,r2, r3 ); if (r1==1 || r2==1 || r3==1) printf ("El deportista es APTO"); else printf ("El deportista NO es Apto"); getch(); } ______________________________________________________________________________________ Programa: El mismo problema anterior se resuelve con el siguiente programa de una forma mas sencilla. Analícelo. ______________________________________________________________________________________ # include <stdio.h> void main() { float tiempo, prom, capto=0, cnapto=0, c=0, total=0;


30

while (c<10) { printf ("Cual es el tiempo:"); scanf ("%f", &tiempo); if (tiempo<=16) capto=capto + 1; else cnapto=cnapto + 1; total=total + tiempo; c+=1; } prom=total/10; printf ("Su promedio es %f ", prom); printf ("Contador de apto %f, Contador no apto %f\n ", capto, cnapto); if ( capto==10 || cnapto==1 || prom<=15) printf ("El deportista es APTO"); else printf ("El deportista NO es Apto"); getch(); } ______________________________________________________________________________________ Programa: El gobierno del estado de México desea reforestar un bosque que mide determinado número de hectáreas. Si la superficie del terreno excede un millón de m2 entonces decidirá sembrar de la siguiente manera: 1. 70 % de arboles de pino 2. 20 % de arboles de hóyameles 3. 10 % de arboles de cedro Si la superficie del terreno es menor o igual a 1 millón de m2 entonces decidirá sembrar de la siguiente manera: 1. 50 % de arboles de pino 2. 30 % de arboles de hóyameles 3. 20 % de arboles de cedro El gobierno desea saber el numero de pinos, hóyameles y cedros que tendrá que sembrar en el bosque, si se sabe que en 10 m2 cabe 8 pinos, en 15 m2 cabe 15 hóyameles y en 18 m2 cabe 10 cedros. También se sabe que una hectárea equivale a 10,000 m2 ______________________________________________________________________________________ # include <stdio.h>


31

void main() { float superf, b, pinos, hoya, ced; printf ("Programa que determina la cantidad de arboles a sembrar\n"); printf ("Cual es la superficie del terreno:?"); scanf ("%f", &superf); if (superf>1000000) { b=((1.25/1)*7) + ((1/1)*2) + ((1.8/1)*1); pinos=(7/b)*superf; hoya=(2/b)*superf; ced=(1/b)*superf; } else { b=((1.25/1)*5) + ((1/1)*3) + ((1.8/1)*2); pinos=(5/b)*superf; hoya=(3/b)*superf; ced=(2/b)*superf; } printf ("Cantidad de pinos a sembrar: %8.2f \n", pinos); printf ("Cantidad de hoyameles a sembrar: %8.2f \n", hoya); printf ("Cantidad de cedros a sembrar: %8.2f \n", ced); getch(); } ______________________________________________________________________________________ Nota: La constante ‘b’ de la formula: b=((1.25/1)*7) + ((1/1)*2) + ((1.8/1)*1) Donde: b = ((10 m2 /8 pinos * 1 pino)* 7) + (( 15 m2 / 15 hoya * 1 hoya)* 2) + ((18 m2/ 10 ced * 1 ced)* 1) = b = 12.55 m2 Vea que dentro de los paréntesis internos lo que ocurre son simples conversiones y nos queda un resultado en metros cuadrados, dichos resultados en m2 son multiplicados por 7, 2, y 1 que equivalen al porcentaje de 70%, 20% y 10% respectivamente. De esta forma se crean las constantes: 7/b, 2/b, 1/b para pinos, hoya y cedros, respectivamente. Donde podemos despejar para una determinada superficie. pinos= (7/b)*superf; hoya= (2/b)*superf; ced= (1/b)*superf;


32

2. SENTENCIA do ... while ( ) Sintaxis: 1) do sentencia; while (expresión); 2) do { ... sentencias; ... } while (expresión); En el ciclo do ... while ( ) las sentencias se realizan cuando menos una vez, ya que la evaluación de la expresión se da hasta el final del ciclo. El ciclo continua mientras la expresión sea verdadera.

expresion

sentencias

F V


33

Con una sola sentencia no se usan llaves, con dos o mas sentencias estas deben ser cubiertas por llaves. Observe que el último renglón del ciclo while (expresión); termina con un punto y coma. Programa: Leer 12 calificaciones de un grupo de alumnos e imprima el porcentaje de aprobados. La calificación mínima aprobatoria es de 70. Utilizar el ciclo do ... while(). ______________________________________________________________________________________ # include <stdio.h> void main() { int ca=0, capro=0, cal; float pa; do { ++ca; printf ("Calificacion del %d alumno:", ca); scanf ("%d", &cal); if (cal>=70) capro=capro+1; } while (ca<12); printf ("capro vale: %d ", capro); pa=capro*100/12; printf ("Porcentaje de aprobados: %f\n", pa); getch(); } ______________________________________________________________________________________ Observaciones: El ciclo do ... while () se realiza mientras sea verdadero, y se ejecuta cuando menos una vez.


34

3. SENTENCIA for ( ) Donde: V Es una variable que actúa como contador Vi Valor inicial (constante o variable) Vf Valor final (constante o variable) Sintaxis: a) for ( expresión1; expresión2; expresión3) sentencia; b) for ( expresión1; expresión2; expresión3) { ... sentencias; ... } Donde: expresión1; Es generalmente una expresión de inicialización expresión2; Es generalmente una expresión condicional expresión3; Es generalmente una expresión de incremento

V=Vi

V=V+1 V<=Vf

Sentencias

V

F


35

Ejemplos: 1) for (i = 1; i<=20; i ++) 1 sn+ = i; 2) i = 1; 2 for ( ; i<=20; i ++) sn+ =i; 3) i = 1; 3 for ( ; i<=20; ) { sn+=i; i++; } 4) i = 1; 4 for ( ; ; ) { ns+=i; if (i<=20) i++; else break; 5 }


36

1 En el ejemplo No. 1, supongamos que la variable ‘sn’ tiene un valor inicial de 0, de tal forma que al ejecutarse este ciclo for la variable ‘sn’ primero vale 1, luego vale la suma de 1 mas 2, luego vale la suma de 3 mas 3 y así sucesivamente hasta que ‘i ’ vale 19 se termina el ciclo. sn+=i; es lo mismo que sn = sn + i El ciclo for le da un valor inicial de 1 a ‘i ‘ y se incrementa su valor de 1 en 1 2 Vea que antes de iniciar el ciclo for tenemos la expresión de inicialización (i = 1), de tal forma que esta ya no aparece como primera expresión del for, quedando en su lugar solo el punto y coma (;) El programador puede quitar de la sentencia for esta expresión de inicialización o cualquier otra, o las tres, pero queda a su responsabilidad anotarlas en el lugar correcto 3 En el tercer caso, no tan solo queda fuera la expresión de inicialización, sino también la tercera expresión que es la de incremento del ciclo (i ++) - Cuando la variable ‘i ‘ incrementa su valor de 1 en 1 con cada vuelta del ciclo - . Observe que aunque se han quitado dos expresiones, estas quedan representadas por puntos y comas. Y como ya se había mencionado en estos casos queda bajo responsabilidad del programador poner dichas expresiones en el lugar adecuado. 4 En el cuarto caso se han quitado de la sentencia for las tres expresiones, quedando en la sentencia dos puntos y comas - for (; ;) - y expresándose fuera de dicha sentencias las expresiones del ciclo. 5 La palabra “break” permite salir del ciclo NOTA: Al igual que con otros ciclos, si al ciclo for le corresponde una sola sentencia entonces no se usan llaves, si le corresponden dos o mas sentencias entonces el cuerpo del ciclo va cubierto por llaves. Programa: Se crea un ciclo for, para ejecutarse diez veces (x=0; x<10) y los incrementos son de uno en uno ( x++) Se va a imprimir “valor de x:” en varias ocasiones donde x toma un valor desde 0 hasta 7 y no llega a 10 dado que la instrucción (x == 7) “si x es igual a 7 ” entonces x=10 y cuando el programa regresa a la sentencia for, ya x no es menor a 10 y se sale del ciclo ______________________________________________________________________________________ # include <stdio.h> void main() { int x; for (x=0; x<10; x++) { printf ("valor de x: %d \n", x); if (x==7) x=10; } getch(); } ______________________________________________________________________________________


37

En la parte del programa: if (x==7) x=10; Cuando x toma valor de 10 y por lo tanto se sale del ciclo, pudimos haber salida con la instrucción break, así. if (x==7) break; Programa: Realizar un programa que permite calcular una elevación a una potencia, por ejemplo si dada una base de 2 y dado un exponente de 3 el resultado debe ser 8 porque 23 =8 ______________________________________________________________________________________ # include <stdio.h> void main() { int a,n,i; long int pot=1; 1 printf ("Valor de la base:"); scanf ("%d",&a); printf ("Valor de la potencia:"); scanf ("%d",&n); for (i=1;i<=n;i++) pot*=a; 2 printf ("%d elevado a la %d es: %d \n",a,n,pot); getch(); } ______________________________________________________________________________________ 1 La palabra long int significa que la variable “pot” no este limitada a un rango de -32,767 a 32,767 ya que long int asigna a “pot” la capacidad de tomar un valor de -2,147,483,647 a 2,147,483,647 2 La sentencia pot*=a; es lo mismo que pot=pot * a, es decir, conforme el ciclo for se ejecuta una y otra vez pot vale primeramente el resultado de multiplicar 1 por la base que se por ejemplo: base =2, exponente =3 entonces mientras se ejecuta el ciclo for ocurre que: (pot=pot*a) pot a (base) n (exponente) i (del ciclo for: i<=n) por * = a 1 2 3 1 1 * 2 = 2 2 2 2 * 2 = 4 4 3 4 * 2 = 8 8 Resultado final de “pot”


38

Programa: Dada una determinada cantidad de materias, obtener el promedio. ______________________________________________________________________________________ # include <stdio.h> void main() { int suma=0, cal, prom, c, i; printf ("dame la cantidad de materias a las que sacara promedio:"); scanf ("%d", &c); for (i=0; i<c; i++) { printf ("Dame la calificacion de la %d materia:", i +1); 1 scanf ("%d", &cal); suma+=cal; 2 } prom=suma/c; 3 printf ("Promedio obtenido: %d ", prom); getch(); } ______________________________________________________________________________________ 1 Cuando dice “Dame la calificación de la ... materia” lo que aparece en pantalla es: “Dame la calificación de la 1 materia, de la 2 materia, de la 3 materia, etc. la expresión i +1 no altera el valor de ‘ i ‘ solo que para efectos de presentación en pantalla no conviene que aparezcan “Dame la calificación de la 0 materia, sino de la 1 materia y así sucesivamente conforme ‘i ‘ incrementa su valor. 2 Recuerde que suma+=cal es lo mismo que decir suma=suma + cal, es decir, la variable ‘suma’ que tiene una valor inicial de cero, funciona como variable acumulador (o sumador) sumando todas las calificaciones. 3 Un promedio siempre se obtendrá dividiendo la suma acumulada entre la cantidad de materias, en este caso. De tal forma que prom=suma/c; el promedio es igual a la suma acumulada entre ‘c‘ que es la cantidad de materias.


39

Programa: Se tiene un grupo de n alumnos en donde cada uno de ellos cursa un cierto número de materias. Hacer un programa que determine. a) El promedio por alumno b) El alumno que obtuvo el mayor promedio c) El alumno que obtuvo el menor promedio d) El promedio del grupo c) Por cada alumno obtener en que materia obtuvo la menor calificación ______________________________________________________________________________________ # include <stdio.h> void main() { int na,ca,nm,cm,alumay,alumen,matmen; float cal, calmen, calmay,scal=0,prom, promay, promen; float promgpo, sprom=0; printf ("Numero de alumnos:"); scanf ("%d", &na); for (ca=1; ca<=na; ca++) { float scal=0; printf ("Cantidad de materias a las que sacara promedio?:"); scanf ("%d", &nm); for (cm=1;cm<=nm;cm++) { printf ("Dame la calificacion de la %d materia:", cm); scanf ("%f", &cal); scal+=cal; if (cm==1) { calmen=cal; matmen=cm; } else if (cal<calmen) { calmen=cal; matmen=cm; } }


40

prom=scal/nm; printf ("Promedio obtenido del %d alumno: %5.2f\n",ca, prom); printf ("Materia en la que obtuvo la menor calificacion %d\n",matmen); if (ca==1) { promay=promen=prom; alumay=alumen=ca; } else if (prom>promay) { promay=prom; alumay=ca; } else if (prom<promen) { promen=prom; alumen=ca; } sprom+=prom; } printf ("Promedio mayor %5.2f del alumno %d \n", promay, alumay); printf ("Promedio menor %5.2f del alumno %d \n", promen, alumen); promgpo=sprom/na; printf ("Promedio del grupo %5.2f\n:", promgpo); getch(); } ______________________________________________________________________________________


41

ARREGLOS (ARRAYS)

Un arreglo es una colección de variables del mismo tipo que se referencian utilizando un nombre común. En turbo C, un arreglo o array consta de posiciones de memoria contiguas. La dirección más baja corresponde al primer elemento y la más alta al último. Un arreglo puede tener una o varias dimensiones. Para acceder a un elemento especifico de un arreglo se usa un índice. En resumen, un Arreglo es un conjunto de posiciones contiguas, que tienen un nombre. Donde cada elemento del arreglo es de un mismo tipo (char, int, float, etc.). Una Variable almacena un solo valor, un Arreglo almacena un conjunto de valores. Arreglos unidimensionales El formato general para la declaración de un arreglo unidimensional es tipo nombre_var[tam]; Aquí tipo declara el tipo base del arreglo. El tipo base determina el tipo de datos de cada elemento del arreglo. El tam define cuántos elementos guardará. Por ejemplo, lo siguiente declara un arreglo de enteros llamado “ejemplo” de diez elementos: int ejemplo[10]; En C, todos los arreglos usan cero como índice del primer elemento. Por tanto, el ejemplo anterior declara un arreglo de enteros - int - de diez elementos: ejemplo[0] a ejemplo[9]. Arreglo “ejemplo” con 10 posiciones

0 1 2 3 4 5 6 7 8 9

En C, la primera posición no es 1, sino 0, y termina en n - 1.

0 1 2 3 . . .

n - 1

Observe que el arreglo contiene 10 posiciones, y la primera posicion del arrego es 0

Arreglo


42

Por ejemplo, el programa siguiente carga un arreglo de enteros con los numeros del del 0 al 9: ______________________________________________________________________________________ main () { int x[10]; int i for (i=0; i<10; i++) x[i] = i; } ______________________________________________________________________________________ Advertencia: Lenguaje C no da la comprobación de contornos El lenguaje C no realiza comprobación de contornos en los arreglos: así no detiene la escritura fuera del final del arreglo. Si se sobrepasa el final durante una operación de asignación, entonces se asignarán valores a otra variable o a un trozo del código del programa. Hay otra manera de ver este problema: se puede indexar un arreglo de tamaño N por encima de N sin provocar ningún mensaje de error en tiempo de compilación o ejecución, incluso aunque probablementese provoque el fallo del programa. Como programador, se es responsable de asegurar que todos los arreglos sean lo suficientemente grandes para guardar lo que pondrá en ellos el programa y de proporcionar las comprobaciones de contorno cuando sea necesario. Por ejemplo, C compilará y ejecutará este programa incluso aunque se sobrepase el arreglo. (No intentar este ejemplo; puede dañar el sistema.) ______________________________________________________________________________________ main() { int crash[10], i; for (i=0; i<100; i++) crash[i]=i; } ______________________________________________________________________________________ Observe que el arreglo “crash” fue declarado para almacenar solo 10 elementos - int crash[10] -, sin embargo, el ciclo for le introduce 100 elementos !!, es decir, se desborda el arreglo “crash”. Esto hace que se sobreescriba información importante, ocasionando un fallo en el programa.


43

Representación en memoria Como conocer la dirección de una determinada posición en un arreglo Suponga que tiene una Arreglo con números enteros que empiezan a partir de la dirección @ 142 ¿Cual seria la dirección de la posición 5? Dirección = Dirección de inicio + Tamaño de dato en bytes * (posición - 1) Donde: Tamaño de dato en este caso es 2 (bytes) por ser de tipo int - entero - . 142 + 2 * ( 5 - 1 ) = 142 + 2 * (5 - 1) = = 142 + 2 * 4 = 142 + 8 =@150

0 @142 1 @144 2 @146 3 @148 4 @150 5 6 7 8 9

CLASIFICACIÓN DE LOS ARREGLOS Según las dimensiones que tengan se clasifican en: 1. Unidimensionales, listas o vectores 2. Bidimensionales, también llamados tablas o matrices [Renglón, Columna] 3. Tridimensionales o cubos (Se puede ver como un arreglo de matrices) 4. Multidimensionales: de mas de tres dimensiones

Variable: Tiene una posición (dirección) y un contenido.

Arreglo: Conocemos la dirección de inicio. El arreglo tiene contenidos en posiciones contiguas de memoria

La Dirección de la quinta posicion es @150. Recuerde que C empieza en 0 y la quinta posición realmente sera en n - 1 = 4


44

Vector Matriz Cubo

DECLARACIÓN DE UN ARREGLO tipo nom_arreglo [n] donde: n Número máximo de elementos que puede tener el arreglo y es un valor constante. Ejemplos: int edad [30]; char cadena[81]; Aquí tenemos la Declaración de los arreglos float produccion[12]:

0 0 0 1 1 1 2 2 2 . . . . . . . . .

28 79 10 29 80 11

edad cadena produccion

Como es de tipo entero, cada posicion ocupa 2 bytes. Total 60 bytes

Como es de tipo flotante, cada posicion ocupa 4 bytes. Total 48 bytes

Como es de tipo char, cadaposicion ocupa un solo byte. Total 81 bytes


45

Observaciones: En el caso del vector “edad” puede ser un grupo de edades de 30 alumnos. En el vector “cadena” dado que es tipo char, no es mas que precisamente una cadena de caracteres cualquier tal como “Tuxtepec, Oax. “ que no necesariamente debe ocupar las 80 posiciones, de hecho el último byte de una cadena de caracteres, se reserva para un caracter nulo. En el caso del vector “producción” puede ser cantidades que se refieran a la producción de los 12 meses del año. Decíamos que un arreglo de caracteres requiere la última posición del arreglo para una caracter nulo. Así que si en el vector cadena introducimos la expresión: T u x t e p e c , O a x . \0 14 posiciones realmente ocupadas + una posición para un caracter nulo Y dado que nuestro vector “cadena” tiene una capacidad de 81 posiciones, en este caso todo las demás posiciones fueron desaprovechadas. Programa: Crear un vector con 10 elementos, y una vez hecho que este vector genere otro automáticamente con los elementos capturados en forma inversa al primer vector. Y visualizar ambos vectores. ______________________________________________________________________________________ # include <stdio.h> void main() { int vect1[10], vect2[10], i,x; for (i=0; i<10; i++) /*En este ciclo nosotros capturamos el vector con 10 elem*/ { printf ("Introduzca el %d valor:", i+1); scanf ("%d", &vect1[i]); } i = 9; for (x=0; x<10; x++) /*Este ciclo genera automaticamente el otro vector, inversamen*/ { vect2[x]=vect1[i]; i = i - 1; } for (i=0; i<10; i++) /* Este ciclo visualiza el primer vector */ printf ("Vector 1: %d \n", vect1[i]); for (i=0; i<10; i++) /* Este ciclo visualiza el segundo vector */ printf ("Vector 2: %d \n", vect2[i]); getch(); } ______________________________________________________________________________________


46

PROGRAMAS CON VECTORES Programa: Hacer un programa que determine si un vector a de 20 posiciones que esta almacenado en memoria se encuentra ordenado ascendentemente. ______________________________________________________________________________________ # include <stdio.h> void main() { int a[20], i, ordenado=1; for (i=1; i<20 && ordenado==1; i++) if (a[i - 1] > a[i]) 1 ordenado=0; if (ordenado) 2 printf ("Esta ordenado \n"); else printf ("No esta ordenado"); getch(); } ______________________________________________________________________________________ 1 La sentencia if compara el valor que se encuentra en el vector ‘a’ en la posición de i - 1 con el valor que se encuentra en el mismo vector ‘a’ en la posición siguiente, es decir, la posición i. Si el primer valor es mayor al segundo entonces la variable bandera “ordenado” toma un valor de 0 lo que origina la salida del ciclo for. 2 Esta sentencia if tiene una expresión - ordenado - si ésta tiene un valor de 1 entonces el if es verdadero y se imprime “Esta ordenado”. De lo contrario si “ordenado” tiene un valor de 0 se imprime “No esta ordenado” Programa: Calcular el promedio de 50 valores almacenados en un vector. Determinar además cuantos son mayores que el promedio, imprimir el promedio y una lista de los valores mayores que el promedio. ______________________________________________________________________________________ # include <stdio.h> void main() { int vect[50], i, cmay=0, suma=0, prom;


47

for (i=0; i<50; i++) suma+=vect[i]; prom=suma/50; printf ("El promedio es: %d\n", prom); for (i=0; i<50; i++) if (vect[i] > prom) { cmay+=1; printf ( " Valor mayor al promedio %d, en posicion %d\n", vect[i], i+1); } printf ("Cantidad de valores mayores al promedio: %d", cmay); getch(); } ______________________________________________________________________________________ Programa: Llenar 2 vectores A y B de 45 elementos cada uno, sumar el elemento uno del vector A con el elemento uno del vector B y así sucesivamente hasta 45, almacenar el resultado en un vector C, e imprimir el vector resultante. ______________________________________________________________________________________ #include <stdio.h> void main() { int a[45], b[45], c[45], i; for (i=0; i<45; i++) { printf ("Introduzca el %d elemento del vector 'a':\n",i+1); scanf ("%d", &a[i]); printf ("Introduzca el %d elemento del vector 'b':\n",i+1); scanf ("%d", &b[i]); c[i] = a[i] + b[i]; } printf ("Vector resultante: \n"); for (i=0; i<45; i++) printf ("%d\n", c[i]); getch(); } ______________________________________________________________________________________


48

Programa: Llenar un vector con 20 elementos, imprimir la posición y el valor del elemento mayor almacenado en el vector, suponga que todos los elementos del vector son diferentes. ______________________________________________________________________________________ # include <stdio.h> void main() { int vect[20], i, mayor, pos; for (i=0; i<20; i++) { printf ("Valor del %d elemento del vector:", i+1); scanf ("%d", &vect[i]); } for (i=0; i<20; i++) 1 if (i==0) { mayor=vect[i]; pos=i+1; } else if (vect[i] > mayor) { mayor=vect[i]; pos=i+1; } printf ("Valor mayor: %d, en posicion %d", mayor, pos); getch(); } ______________________________________________________________________________________ Observaciones: 1 Para este ciclo for solo hay una sentencia o instruccion que le pertenece; la cual es la linea del if siguiente. Por lo mismo, no hay llaves que cubran a todo este bloque del if. Recuerde todo lo que esta dentro del if, incluyendo al mismo else es parte interno del if, o sea, ya no pertenece al ciclo for. En otras palabras, pudimos haber hecho esto:


49

for (i=0; i<20; i++) 1 { if (i==0) { mayor=vect[i]; pos=i+1; } else if (vect[i] > mayor) { mayor=vect[i]; pos=i+1; } } Programa: Almacenar 500 números en un vector, elevar al cuadrado cada valor almacenado en el vector, almacenar el resultado en otro vector. Imprimir el vector original y el vector resultante. ______________________________________________________________________________________ # include <stdio.h> # include <math.h> void main() { int vec1[500], vec2[500], i; for (i=0; i<500; i++) { printf ("Introduzca el %d valor:", i+1); scanf ("%d", &vec1[i]); vec2[i] = pow(vec1[i], 2); } printf ("Valores del primer vector: \n"); for (i=0; i<500; i++) printf ("%d\n", vec1[i]); printf ("Valores del vector resultante: \n"); for (i=0; i<500; i++) printf ("%d\n", vec2[i]); getch(); }

Usar esta llaves, no afecta, pero no es necesario dado si existe un solo if se toma como una sola instrucción. Lo que este dentro del if (incluyendo al else ) pertenece al if ya no son sentencias del for.


50

______________________________________________________________________________________ Programa: Almacenar 300 números en un vector, imprimir cuantos son ceros, cuantos son negativos, cuantos positivos. Imprimir además la suma de los positivos y la suma de los negativos. ______________________________________________________________________________________ # include <stdio.h> void main() { int vec[300], i, cc=0, cp=0, cn=0, sumpos=0, sumneg=0; for (i=0; i<300; i++) { printf ("Introduzca el %d valor:", i+1); scanf ("%d", &vec[i]); } for (i=0; i<300; i++) if (vec[i] == 0) cc+=1; else if (vec[i]>0) { sumpos+=vec[i]; cp+=1; } else { sumneg+=vec[i]; cn+=1; } printf ("Cantidad de ceros: %d\n", cc); printf ("Cantidad y suma de negativos: %d, %d \n", cn,sumneg); printf ("Cantidad y suma de positivos: %d, %d \n", cp, sumpos); getch(); } ______________________________________________________________________________________ Donde: cc .- Es el contador de ceros. cp.- Es el contador números de positivos. cn.- Es el contador de números negativos. sumpos.- Suma valores positivos. sumneg.- Suma valores negativos.


51

Programa: Almacenar 150 números en un vector, almacenarlos en otro vector en orden inverso al vector original e imprimir el vector resultante. ______________________________________________________________________________________ # include <stdio.h> void main() { int vect1[150], vect2[150], i, x; for (i=0; i<150; i++) { printf ("Introduzca el %d valor:", i+1); scanf ("%d", &vect1[i]); } x = 149; for (i=0; i<150; i++) { vect2[i] = vect1[x]; x = x - 1; } for (i=0; i<150; i++) printf ("Vector 1: %d\n", vect1[i]); for (i=0; i<150; i++) printf ("Vector 2: %d\n", vect2[i]); getch(); } ______________________________________________________________________________________ Programa: Se tienen almacenados en la memoria1 2 vectores M y N de 100 elementos cada uno. Hacer un algoritmo que escriba la palabra “iguales” si ambos vectores son iguales y “Diferentes” si no lo son. ______________________________________________________________________________________ # include <stdio.h> void main() { int m[100], n[100], i, r=1; for (i=0; i<100 && r==1; i++) 2 if (m[i] == n[i]) r = 1; else r = 0;


52

if (r) 3 printf ("Vectores iguales"); else printf ("Vectores diferentes"); getch(); } ______________________________________________________________________________________ Observaciones: 1 El problema nos dice que se tienen ya previamente almacenado en memoria dos vectores de 100 elementos, así pues damos por hecho que ya existen. 2 El ciclo for se ejecutará mientras i sea menor a 100 y (&&) ‘r ‘ sea igual con 1. así ‘r ’ será igual a 1 mientras los elementos de ambos vectores sean iguales, de caso contrario ‘ r ‘ será igual con 0 y se sale del ciclo for. 3 Aquí tenemos una expresión - if (r) - que dice “si r tiene un valor de 1 ... entonces” de lo contrario si ‘r ‘ vale 0 entonces se ejecuta el else Programa: Se tiene el vector A con 100 elementos almacenados. Diseñe un algoritmo que escriba “Si” si el vector esta ordenado ascendentemente o “No” si el vector no esta ordenado. ______________________________________________________________________________________ # include <stdio.h> void main() { int a[100], i, r = 1; for (i=0; i<100 && r==1; i++) if (i > 0) if (a[i] > a[i-1]) r = 1; else r = 0; if (r) printf ("Si"); else printf ("No"); getch(); } ______________________________________________________________________________________


53

Programa: Diseñe un algoritmo que lea un número cualquiera y lo busque en el vector X, el cual tiene almacenados 80 elementos. Escribir la posición donde se encuentra almacenado el número en el vector o el mensaje “No” si no lo encuentra. Búsqueda secuencial. ______________________________________________________________________________________ # include <stdio.h> void main() { int vecx[80], i, r = 0, pos, num; printf ("Dame un numero:"); scanf ("%d", &num); for (i=0; i<80 && r==0; i++) if (num == vecx[i]) { pos = i; r = 1; } else r = 0; if (r) printf ("Posicion donde se encuentra %d:", pos); else printf ("NO encontrado"); getch(); } ______________________________________________________________________________________ Programa: Almacena en un vector llamado FIB los primeros 100 números de la serie FIBONACI: 0, 1, 1, 2, 3, 5, 8, 13, ... ______________________________________________________________________________________ # include <stdio.h> void main() { int i; long fib[100], a=0, b=1, c; fib[0] = a; fib[1] = b;


54

for (i=2; i<100; i++) { c = a + b; fib[i] = c; a = b; b = c; } printf ("Impresión de la serie fibonaci: \n"); for (i=0; i<100; i++) printf ("%d, ", fib[i]); getch(); } ______________________________________________________________________________________ Observación (solo para el programador). El programa funciona bien, hasta los primeros 24 números, siendo el ultimo valor correcto 28,657 después arroja incorrectamente valores negativos, como si la capacidad numérica fuera insuficiente (a pesar de que el vector fib[100] y sus variables: a, b, c fueron declarados como enteros de capacidad superior a 32,767 con long). Nota: Asunto pendiente para investigar.


55

M A T R I C E S

Matriz Cuadrada Aquella que tiene el mismo número de renglones y columnas: 3x3, 4x4, 2x2 Representación en memoria Declaración de una Matriz Tipo nom_matriz[n][m] donde: n No. de Renglones (Constante) m No. de Columnas (Constante) Ejemplos de declaración de Matrices. Vea las palabras en negrillas, este es el tipo de Matriz que se declara, es decir, si almacenará numeros enteros - int -, letras - char - , o numeros reales - float - int calificacion [30][5]; 1 char sexo[20][5]2 , nombre[10][31]; 3 float cosecha[12][3]; 4 Posibles usos: 1 Esta matriz nos puede servir para guardar calificaciones de 30 alumnos cada uno con 5 materias 2 Podemos almacenar el sexo (M ó F) de 20 personas en 5 deptos. diferentes. 3 Para almacenar 10 nombres de 30 caracteres cada uno. 4 Para almacenar las cosechas de los 12 meses del año en 3 años diferentes En una Matriz siempre se expresa primero el numero de renglones, y en segundo termino el numero de Columnas. Nunca al revés: Matriz [R][C]

La Matriz en Memoria: Toma la forma de un vector, es decir en posiciones contiguas de memoria.


56

PROGRAMAS CON MATRICES Programa: Genera una Matriz Unidad de 5x5. La Matriz Unidad es aquella que su diagonal principal esta compuesta por 1’s y por arriba y debajo de ella 0’s. ______________________________________________________________________________________ # include <stdio.h> # define R 5 # define C 5 void main() { int a[R][C], i, j; 1 for (i=0; i<R; i++) for (j=0; j<C; j++) if (i == j) 2 a[i][j] = 1; else a[i][j] = 0; printf ("Matriz generada: \n"); for (i=0; i<R; i++) /* Ciclo for para imprimir la matriz */ { for (j=0; j<C; j++) printf ("%d", a[i][j]); printf ("\n"); } getch(); } ______________________________________________________________________________________ 1 Para las Matrices la variable ‘i ‘ será la que controle la posición en los renglones y la variable ‘j ‘ será la que controle la posición en las columnas.


57

2 Para este problema cuando i es igual a j, es decir, el número de renglón es el mismo al número de columna, entonces estamos en la Diagonal principal ponemos 1’s en caso contrario -else- ponemos 0’s. Programa: Crear una matriz cuadrada de 4x4, En la diagonal principal unos, en la parte superior ceros, y en la inferior llenar con 2’s ______________________________________________________________________________________ # include <stdio.h> # define R 4 # define C 4 void main() { int mat[R][C], i, j; for (i=0; i<R; i++) for (j=0; j<C; j++) { if (i == j) mat[i][j] = 1; else { if (i > j) 1 mat[i][j] = 2; if (j > i) 2 mat[i][j] = 0; } } for (i=0; i<R; i++) /* Se imprime la Matriz generada */ { for (j=0; j<C; j++) printf ("%d", mat[i][j]); printf ("\n"); } getch(); } ______________________________________________________________________________________ 1 Si i es mayor que j entonces estamos en la parte inferior de la diagonal principal y llenamos con 2’s


58

2 Si j es mayor que i entonces estamos en la parte superior de la diagonal principal y llenamos con 0’s Programa: Que permite capturar una matriz de 9x5, obtiene el promedio de los números capturados, el número mayor, y el menor. ______________________________________________________________________________________ # include <stdio.h> # define R 9 # define C 5 void main() { int matriz[R][C], i, j, mayor, menor; long int suma=0; float prom; for (i=0; i<R; i++) for (j=0; j<C; j++) { printf ("Introduzca valor para matriz en posicion:%d, %d,", i+1, j+1); scanf ("%d", &matriz[i][j]); suma = suma + matriz[i][j]; if (i==0 && j==0) 1 { mayor = matriz[i][j]; menor = matriz[i][j]; } else 2 { if (matriz[i][j] > mayor) mayor = matriz[i][j]; if (matriz[i][j] < menor) menor = matriz[i][j]; } } printf ("la suma es: %d\n", suma); prom=suma/45; printf ("el promedio es: %f\n", prom); printf ("el numero mayor es: %d\n", mayor); printf ("El numero menor es: %d\n", menor); getch(); } ______________________________________________________________________________________


59

1 Cuando i=0 y j=0 quiere decir que estamos en el primer renglón y en la primer columna. Recordar que para C la primera posición es 0 y no 1. Así pues estamos en el primer cuadro de la matriz. Por eso, las variables “mayor” y “menor” se cargan con ese primer valor que fue capturado. 2 Después de que las variables “mayor” y “menor” tomaron el primer valor capturado, se establecen comparaciones con los nuevos valores capturados para cambiar los valores de estas variables cuando los nuevos valores capturados sean mas grande a lo que tiene “mayor” o mas pequeño a lo que tienen “menor” Programa: Se debe llenar una matriz de 7x7 calcular la suma de cada renglón y almacenarla en un vector, la suma de cada columna y almacenarla en otro vector. ______________________________________________________________________________________ # include <stdio.h> # define R 7 # define C 7 void main() { int mat[R][C], vect1[7], vect2[7], i, j, suma; for (i=0; i<R; i++) for (j=0; j<C; j++) { printf ("Dame valor para la posicion %d,%d: ", i+1, j+1); scanf ("%d", &mat[i][j]); } for (i=0; i<R; i++) /*La suma de cada renglon se guarda en el vector 1 */ { suma=0; for (j=0; j<C; j++) suma=suma + mat[i][j]; vect1[i]=suma; } for (j=0; j<C; j++) /* La suma de cada columna se guarda en vector 2 */ { suma=0; for (i=0; i<R; i++) suma=suma + mat[i][j]; vect2[j]=suma; }


60

printf ("Valores del vector 1 con la suma de cada renglon:\n"); for (i=0; i<5; i++) printf ("%d \n", vect1[i]); printf ("Valores del vector 2 con la suma de cada columna:\n"); for (i=0; i<5; i++) printf ("%d \n", vect2[i]); getch(); } ______________________________________________________________________________________ Programa: Se debe llenar una matriz de 20x20. Sumar las columnas e imprimir que columna obtuvo la máxima suma y la suma de esa columna. ______________________________________________________________________________________ # include <stdio.h> # define R 20 # define C 20 void main() { int matriz[R][C], i, j, suma, colmayor, sumayor; for (i=0; i<R; i++) for (j=0; j<C; j++) { printf ("Dame valor para posicion %d,%d: ", i+1, j+1); scanf ("%d", &matriz[i][j]); } for (j=0; j<C; j++) { suma=0; for (i=0; i<R; i++) suma=suma + matriz[i][j]; if (j == 0) { sumayor=suma; colmayor=j+1; } else if (suma > sumayor) { sumayor=suma; colmayor=j+1; } } printf ("La %d Columna tiene la maxima suma, con: %d ", colmayor, sumayor); getch(); } ______________________________________________________________________________________


61

Programa: Se debe llenar una matriz de 5x5 y que almacena la diagonal principal en un vector. Imprimir el vector resultante. ______________________________________________________________________________________ # include <stdio.h> # define R 5 # define C 5 void main() { int mat[R][C], i, j, vec[5]; for (i=0; i<R; i++) for (j=0; j<C; j++) { printf ("Dame valor para la posicion: %d,%d", i+1, j+1); scanf ("%d", &mat[i][j]); if (i == j) vec[i]=mat[i][j]; } printf ("Vector resultante: \n"); for (i=0; i<5; i++) printf ("%d\n",vec[i]); getch(); } ______________________________________________________________________________________ Programa: Que permita capturar una matriz de 6x8 y que almacene toda la matriz en un vector. Imprimir vector resultante. ______________________________________________________________________________________ # include <stdio.h> # define R 6 # define C 8 void main() { int mat[R][C], i, j, vec[48], x=0; for (i=0; i<R; i++) for (j=0; j<C; j++) { printf ("Dame valor para posicion %d,%d: ", i+1, j+1); scanf ("%d", &mat[i][j]);


62

vec[x] = mat[i][j]; x = x + 1; } printf ("Vector resultante: \n"); for (i=0; i<48; i++) printf ("%d\n",vec[i]); getch(); } ______________________________________________________________________________________ Programa: Que llene una matriz de 5x4, y se almacenara la suma de los renglones y la suma de las columnas en un vector, que se imprime el vector resultante. ______________________________________________________________________________________ # include <stdio.h> # define R 5 # define C 4 void main() { int mat[R][C], i, j, vec[9], x=0, suma; for (i=0; i<R; i++) /* Captura de la matriz */ for (j=0; j<C; j++) { printf ("Dame cantidad para posicion %d,%d:",i+1,j+1); scanf ("%d", &mat[i][j]); } for (i=0; i<R; i++) /* Se suma cada renglon y las sumas se guardan en vec*/ { suma=0; for (j=0; j<C; j++) suma=suma+mat[i][j]; vec[x]=suma; x=x+1; } for (j=0; j<C; j++) /*Se suma cada columna y se agrega cada suma al vector */ { suma=0; for (i=0; i<R; i++)


63

suma=suma+mat[i][j]; vec[x]=suma; x=x+1; } printf ("Vector resultante \n:"); for (i=0; i<9; i++) printf ("%d\n", vec[i]); getch(); } ______________________________________________________________________________________ Programa: Que llena una matriz de 5x6, y que imprima cuantos de los números almacenados son 0, cuantos positivos y cuantos negativos ______________________________________________________________________________________ # include <stdio.h> # define R 5 # define C 6 void main() { int matriz[R][C], i, j, cceros=0, cpos=0, cneg=0; for (i=0; i<R; i++) for (j=0; j<C; j++) { printf ("Dame cantidad para posicion %d,%d:",i+1,j+1); scanf ("%d", &matriz[i][j]); if (matriz[i][j] == 0) cceros = cceros+1; else if (matriz[i][j] > 0) cpos = cpos + 1; else cneg = cneg + 1; } printf ("Cantidad de ceros: %d, positivos: %d, negativos: %d", cceros, cpos, cneg); getch(); }


64

______________________________________________________________________________________ Programa: Se debe generar un arreglo almacenando las calificaciones de 6 alumnos en 5 materias diferentes. Determinar: a) Promedio por alumno, b) Promedio por materia c) Guardar estos resultados en dos vectores diferente e imprimirlos ______________________________________________________________________________________ # include <stdio.h> # define R 6 # define C 5 void main() { int i, j; float matriz[R][C], promalum[R], promat[C], suma; for (i=0; i<R; i++) /*Captura de las calificaciones */ for (j=0; j<C; j++) { printf ("Cal. del %d alumno, en la %d materia: ",i+1,j+1); scanf ("%f", &matriz[i][j]); } for (i=0; i<R; i++) /* Calculo del promedio por alumno */ { suma=0; for (j=0; j<C; j++) suma=suma+matriz[i][j]; promalum[i]=suma/C; } for (j=0; j<C; j++) /* Calculo del promedio por materia */ { suma=0; for (i=0; i<R; i++) suma=suma+matriz[i][j]; promat[j]=suma/R; } printf ("Promedios de los alumnos:\n"); for (i=0; i<R; i++) printf ("Promedio del %d alumno: %5.2f \n",i+1, promalum[i]); printf ("Promedios por materias:\n"); for (i=0; i<C; i++) printf ("Promedio de la %d materia: %5.2f\n",i+1, promat[i]); getch(); } ______________________________________________________________________________________


65

PROGRAMAS CON CADENAS DE CARACTERES

Programa: Hacer un programa que lea una cadena de caracteres y lo imprima en forma inversa a como se introdujo. ______________________________________________________________________________________ # include <stdio.h> # include <string.h> void main() { char cadena[81]; 1 int i; printf ("Introduce una cadena de caracteres:"); gets (cadena); for (i=strlen(cadena) -1; i>=0; i--) 2 printf ("%c", cadena[i]); 3 getch(); } ______________________________________________________________________________________ 1 En esta línea tenemos la declaración del arreglo que guardara la cadena de caracteres - char - donde se dispondrá de un total de 80 posiciones. Recordar que el la última posición de la cadena la utiliza C para un caracter nulo. 2 La variable ‘i ‘ toma un valor inicial igual a la longitud de la cadena de caracteres (cada espacio en blanco cuenta como un caracter). Se le resta 1 para que no se incluya al caracter nulo. Por ejemplo para una cadena de caracteres que tenga 18 caracteres, la variable ‘i ’ toma ese valor inicial de 18. 3 A partir de esa posición ultima de la cadena, se empieza a imprimir la cadena, y por cada caracter impreso ‘i ‘ disminuye en 1. ( i--). Programa: Hacer un programa que lea una cadena de caracteres que este integrada por puras letras e imprima la frecuencia con la cual aparece cada letra ______________________________________________________________________________________ # include <stdio.h> # include <string.h> # include <ctype.h>


66

void main() { char cadena[81]; int frecuencia[26], i; printf ("Introduce cadena de caracteres (letras) :"); gets (cadena); for (i=0; i<26; i++) /* Inicializacion vector de frecuen*/ frecuencia[i]=0; for (i=0; cadena[i]; i++) 1 /*Determinacion de la frecuencia */ if (!isspace(cadena[i])) 2 ++frecuencia [toupper(cadena[i]) - 65]; 3 for (i=0; i<26; i++) /*Imprime la frecuencia de las letras */ if (frecuencia[i]!=0) printf ("%c = %d \n", i+65, frecuencia[i]); 4 getch(); } ______________________________________________________________________________________ 1 Vea en el ciclo for, i se iniciala con 1, como se hace generalmente. La segunda expresión del ciclo for es precisamente una “expresión”: cadena[i]; Significa que se va a ejecutar el ciclo mientras no se llegue al caracter nulo - \0 -. Se pudo haber expresado de esta manera cadena for (i=0; cadena[i] != \0; i++)

2 La sentencia if tiene una expresión que dice “Si NO es espacio en la posición actual de la cadena - if (!isspace(cadena[i])) - De No ser espacio entonces se entra al if. 3 Para empezar a analizar esta sentencia: ++frecuencia[toupper(cadena[i]) - 65]; Observar que previamente se inicializo el vector “frecuencia” con 26 posiciones, en todo el vector se almaceno 0’s. ++frecuencia nos dice que una determinada posición de este vector, se incrementará el valor almacenado en 1. ( y solo existen 26 posiciones). toupper(cadena[i]) La palabra “toupper” convierte la letra a mayúscula, la que se encuentre en ese momento en la posición actual - cadena[i] - . Dado que toda letra será convertida a mayúscula, y estas dentro del código ASCII tienen un valor desde el 65 al 90 es necesario restar 65 para se de un incremento en 1 en la posicion que resulte para el vector frecuencia[26]. Porque éste vector solo tiene 26 posiciones. Por ejemplo: si cadena[i] = ‘e ’ La ‘e ‘ tiene un valor en ASCII de 101, pero ... toupper cadena[i] Convierte la ‘e ‘ en ‘ E ’ que tiene una valor en ASCII de 69 y ha este valor se le restan 65, tal que 69 - 65 = 4 ++frecuencia significa que el valor actual de la posición 4 del vector frecuencia se incrementa en 1. Y esta posición 4 del vector frecuencia incrementará su valor en 1 cada que se encuentre en cadena[i] una ’ e ’ ó ‘ E ‘.


67

Ilustración a la explicaciones anteriores: Vector “frecuencia”

0 0 1 0 2 0 3 0 4 1 5 0 . 0 . 0 . 0

25 0 4 La línea printf ("%c = %d \n", i+65, frecuencia[i]); Nos dice que se imprime el valor actual de ‘i ’ incrementándosele previamente 65, lo que resulte se imprime pero en %c, es decir, el valor numérico se convierte en letra. También se imprime el valor almacenado en la posición frecuencia[i] que representa la cantidad de veces que fue encontrada la letra. Por ejemplo: Tomando la ilustración anterior, se imprimiría: E 1 CONCEPTOS UTILIZADOS EN EL MANEJO DE CADENA DE CARACTERES

# include <string.h> Nos permite usar funciones como strlen que nos permite saber cuantos caracteres tiene una cadena i = strlen(var_de_caracteres) La variable i que es de tipo numerico recibe como valor el total de caracteres de una variable de caracteres. Esta cantidad numerica incluye al caracter nulo. Por lo que hay que restar 1 para obtener el valor neto de la cadena. # include <ctype.h> Incluye funciones de conversion para cadena de caracteres. if (!isspace(cad_caract[i])) !isspace significa “Si no es espacio”. De tal forma que si en la posición actual de la cadena de caracteres no es espacio, entonces la sentencia if toma un valor de 1 o verdadero y se entra al mismo. toupper (cad_caract[i]) El caracter que se encuentre en la posicion actual de la cadena de caracteres se convierte a mayuscula.

La posición 4 del vector frecuencia se ha incrementado en 1 (++frecuencia) Representando a la primera ‘E’ encontrada. Así pues cada casilla representa a una letra, y solo hay incremento en 1 sí se encuentra su respectiva letra.


68

PUNTEROS

El correcto entendimiento y uso de los punteros es critico para una fructífera programación en C y C++. La razón es triple: 1. Primero, los punteros proporcionan los medios con los cuales las funciones pueden modificar sus argumentos de llamada. 2. Segundo, se utilizan como soporte de las rutinas de asignación dinámica de C. 3. Tercero, el uso de punteros puede mejorar la eficiencia de ciertas rutinas. Los punteros son una de las características mas poderosas de C, aunque también una de las más peligrosas, por ejemplo, los punteros no inicializados pueden provocar el fallo del sistema, quizás pero, es fácil utilizar punteros de forma incorrecta, y el uso incorrecto puede causar fallos muy difíciles de encontrar. ¿QUE SON LOS PUNTEROS? Un puntero es una variable que contiene una dirección de memoria. Esa dirección es la posición de otro objeto. (Normalmente otra variable) en memoria. Por ejemplo, si una variable contiene la dirección de otra variable entonces se dice que la primera variable apunta a la segunda.

@148 @150 @152 20 @154

.

.

. @160 @152

Advertencia: No es lo mismo que el puntero almacene la dirección de memoria de una variable, a que almacene por error su contenido. En el ejemplo anterior, si por error el puntero almacena 20 lo que hace es apuntar a una dirección desconocida @20 !! error !! Entonces el contenido del puntero es siempre una dirección @xxx. Sea que se le asigne voluntaria o involuntariamente.

La Variable.- Tiene una Dirección (@152) Asignada por la PC, y un contenido (20) asignado por el usuario.

El puntero.- Tiene una Dirección propia (@160) y un contenido el cual es una dirección de una variable (@152) que se va a buscar.


69

VARIABLES Y PUNTEROS

Si una variable va a contener un puntero, entonces tiene que declararse como tal. Una declaración de puntero consiste en un tipo base y un nombre de variable. La forma general de declaración de una variable puntero es: tipo *nombre; donde tipo es el tipo base de puntero y puede ser cualquier tipo valido de C ( int, char, float, etc.). El nombre de la variable puntero se especifica con nombre. Ejemplo. int edad, *p; char sexo, *q; *p El puntero “ *p “ tiene la capacidad de apuntar a variables de 2 bytes o menos bytes, porque es de tipo int. *q Este puntero tiene la capacidad de apuntar solo a variables de 1 byte, porque es de tipo char. Por ejemplo, el puntero *p (capacidad 2 bytes) puede apuntar a la variable sexo (de 1 byte), pero *q (capacidad 1 byte) no puede apuntar a la variable edad (2 bytes).

OPERADORES CON DIRECCIONES 1) & Dirección 2) * Contenido Ejemplo: ______________________________________________________________________________________ int num=201 , *p2 ; p = &num;3 *p = 40; 4 printf (¨” %d \n”, *p); 5 printf (“%d \n”, num);6 printf (“%p \n”, p); 7 printf (“%p \n”, &p); 8 ______________________________________________________________________________________


70

@150 @152 @154 20 @156 @158 @160 @162 @164 @154 @166 @168

4 *p = 40; En la dirección a la que apunta el puntero ‘p’ se asigna el valor de 40, es decir, ‘num’ ya no vale 20, sino 40. 5 printf (¨” %d \n”, *p); Esta línea visualiza el contenido de la dirección a la que apunta ‘p’, es decir, visualiza el valor de ‘num’ que es 40. 6 printf (“%d \n”, num); Esta línea visualiza el contenido de la variable ‘num’ que es 40. 7 printf (“%p \n”, p); Esta línea imprime el contenido del puntero ‘p ’ que es la dirección de la variable ‘num’; @154 8 printf (“%p \n”, &p); Esta línea imprime la dirección del puntero ‘p ‘ que es @164

PROGRAMAS CON ACCESO A UN ARREGLO USANDO UN PUNTERO Programa: Que permite capturar un vector con 10 elementos y usando un puntero visualiza los elementos en forma inversa a como fueron capturados. ______________________________________________________________________________________ # include <stdio.h> void main() { int num[10], i, *p; for (i=0; i<10; i++) { printf ("Introduce el %d numero:", i+1); scanf ("%d", &num[i]); }

1 Se crea la variable ‘num’ , la PC le asigna la dirección @154 y el usuario le asigna a ‘num’ un contenido de 20

2 Se crea el puntero *p el cual no tiene en ese momento relación alguna con la variable ‘num’. 3 En la segunda línea del programa p=&num; En ese momento se relaciona el puntero con la variable. el puntero toma como contenido la dirección de ‘num’ (@154). El & permite dar como contenido al puntero la dirección de la variable, y no el contenido de esta, es decir, p=num, entonces p=20. error!! (@20 Dirección desconocida !!)


71

p=&num[9]; 1 for (i=0; i<10; i++) { printf ("%d \n", *p); 2 --p; } getch(); } ______________________________________________________________________________________ Supongamos que nuestro vector ‘num’ fue llenado con las siguientes cantidades, y con una dirección inicial supuesta. Direccion Elems. Posicion

@150 8 0 @152 10 1 @154 60 2 @156 5 3 @158 45 4 @160 18 5 @162 35 6 @164 20 7 @166 90 8 @168 2 9

.

.

. @184 @168

1 p = &num[9]; Esta línea asigna al puntero la dirección de memoria de la posición 9 del vector. 2 printf ("%d \n", *p); Imprime el contenido de la dirección a la que primeramente apunta el puntero (@168). Imprime 2. 3 - -p; El puntero tiene un decremento en su contenido (@168 - decremento). Este decremento no es en 1 sino en 2 porque el puntero ‘p’ es de tipo int (2 bytes). Entonces en su primer decremento p vale @166. Regla sobre punteros: La aritmética de los punteros esta en función de su tamaño. o sea: - -puntero Afecta al contenido del puntero, el contenido de un puntero siempre es una dirección de alguna variable. El decremento será en 1 si el puntero es de tipo char, será en 2 si el puntero es de tipo int.

Vector ‘num’

Puntero ‘p ‘ con direccion supuesta @184


72

Programa: Hacer un programa que reciba una cadena de caracteres, y determine si es un “palíndromo”, es decir, si se lee igual al revés y al derecho como ‘oso’, ‘ala’, etc. ______________________________________________________________________________________ # include <stdio.h> # include <string.h> # define MAX 81 void main() { char cadena[MAX], *apun; 1 int band=1, i; printf ("Introduce cadena de caracteres:"); gets (cadena); apun = &cadena[strlen(cadena)-1]; 2 for (i=0; i<=strlen(cadena)/2 && band; i++) if (cadena[i] != *apun) band = 0; else --apun; 3 if (band) printf ("Es un PALINDROMO"); else printf ("NO es PALINDROMO"); getch(); } ______________________________________________________________________________________ 1 Si un determinado puntero va ser usado para manejar una cadena de caracteres - char - entonces el puntero debe ser declarado del mismo tipo - char - como en este programa. De lo contrario no da resultado. 2 apun = &cadena[strlen(cadena)-1]; Vea que el puntero ‘apun’ va a tomar como contenido la dirección de una posición de la variable cadena. Esa posición será dada por el total de caracteres realmente capturados, incluyendo espacios en blanco - strlen - y se resta 1 para no considerar el caracter nulo. Así pues, ‘apun’ tendrá la dirección del ultimo caracter introducido. 3 --apun; La dirección que tiene como contenido ‘apun’ disminuye en 1, es decir, la primera vez que ‘apun’ tenga un decremento apuntará al penúltimo caracter. NOTA: Cuando queramos apuntar a la dirección de inicio de un arreglo usaremos: puntero = &vector[0] ó puntero = vector (siempre que estemos hablando de un vector).


73

Programa: (Como ejemplo de lo último explicado). ______________________________________________________________________________________ # include <stdio.h> void main() { char cadena[81], *p; printf ("Introduce cadena:"); gets (cadena); /* Primera opcion */ p = &cadena[0]; printf (" Direccion contenido del puntero: %p\n", p); printf ("Contenido de la direccion a la que se apunta: %c\n",*p); /* Segunda opcion */ p = cadena; printf ("- B - Direccion contenido del puntero: %p\n", p); printf ("Contenido de la direccion a la que se apunta: %c\n",*p); getch(); } ______________________________________________________________________________________ Si por ejemplo se introduce “ala” tanto en la primera como segunda opción arroja los mismos resultados: se imprime primeramente una dirección (la que tiene como contenido el puntero) y luego se imprime la letra ‘a’ (el contenido de la dirección hacia la que apunta el puntero). Ilustracion: Direccion Elems. Posicion

@150 a 0 @152 l 1 @154 a 2

. .

. .

En este supuesto como contenido del puntero - (“%p\n", p); - se imprime @150 Como contenido de la dirección hacia la que apunta el puntero - (“%c\n", *p) - se imprime la letra ‘a’.


74

FUNCIONES Las funciones son los bloques constructores de C y el lugar donde se produce toda la actividad del programa. Son unas de las características más importantes de C. formato general: tipo nom_funcion (lista de parámetros) { . . cuerpo de la función . } El tipo.- Especifica el tipo de valor que devuelve la función. Una función puede devolver cualquier tipo de dato excepto un arreglo. Si no se especifica ningún tipo, el compilador asume que la función devuelve como resultado un entero. La lista de parámetros.- Es la lista de nombres de variables separados por comas con sus tipos asociados que reciben los valores de los argumentos cuando se llama a la función. Una función puede no tener parámetros, en cuyo caso la lista de parámetros esta vacía. Sin embargo, incluso cuando no hay parámetros se requieren los paréntesis. Ejemplo: ______________________________________________________________________________________ int1 suma2 (int x, int y)3 { int z; 4 z = x + y; return z; 5 } void main() { printf (“%d \n”, suma(10, 20)); 6 getch(); } ______________________________________________________________________________________ 1 El tipo de dato que devuelve la función es entero - int -. 2 Nombre de la función ”suma” su lista de parámetros: x, y 3 Observe que cada parámetro tiene su tipo de dato asociado. Es decir, no puede hacerse esto: (int x, y) sino (int x, int y) 4 La variable ‘z’ es una variable local porque solo la reconoce la función ‘suma’ 5 return z; Esta línea retorna el valor de ‘z’, es decir, se transporta su valor a main() 6 Dentro del main() la línea suma( ); hace un llamado a la función ‘suma’ para que ésta se ejecute.


75

Ejemplo de función sin parametros ______________________________________________________________________________________ int suma (void) { int x, y, z; printf (”valor de x:”); scanf (”%d”, &x); printf (“Valor de y:”); scanf (“%d”, &y); z = x + y; return z; } ______________________________________________________________________________________ Ejemplo de función que no devuelve ningún valor (void) ______________________________________________________________________________________ void suma (void) { int x, y, z; printf (“valor de x:”); scanf (“%d”, &x); printf (“Valor de y:”); scanf (“%d”, &y); z = x + y; printf (“%d + %d = %d \n”, x, y, z); getch(); } ______________________________________________________________________________________ La función anterior cuando deje de ejecutarse, las variables x, y, z ya no existirán, la función no devuelve ningún valor; No hay una sentencia return. Si no devuelve un valor - void - aunque para C es una función más bien es solo un “Procedimiento”. En las declaraciones de variables se pueden declarar múltiples variables del mismo tipo mediante una lista con los nombres de las variables separados por comas, en cambio, en las funciones todos los parámetros deben declararse individualmente incluyendo para cada uno tanto el tipo como el nombre, es decir, la lista de declaración de parámetros de una función tiene la siguiente forma general: funcion (tipo var1, tipo var2, ... tipo varN)


76

Observe 2 formas diferentes de Hacer el llamado de una función dentro de main() 1) ______________________________________________________________________________________ # include <stdio.h> void main() { printf ("%d \n", suma(10, 20)); getch(); } int suma (int x, int y) { int z; z = x + y; return z; } ______________________________________________________________________________________ 2) ______________________________________________________________________________________ # include <stdio.h> void main() { int a; a = suma(10,20); printf ("%d \n", a); getch(); } int suma (int x, int y) { int z; z = x + y; return z; } ______________________________________________________________________________________ Definición de Función La función hace algo y puede devolver un valor. También son funciones: strlen() Que devuelve la longitud de la cadena de caracteres isspace() Determina si en determinada posición de una cadena es un espacio en blanco. pow() Eleva al cuadrado sqrt() Raíz cuadrada etc., etc., ...


77

Í N D I C E

CONCEPTO BÁSICOS DEL LENGUAJE C ...................................................................... 1 TIPOS DE DATOS EN C ...................................................................................................... 3 NOMBRE DE IDENTIFICADORES .................................................................................... 4 DIFERENTES TIPOS DE VARIABLES ............................................................................... 5 Variables Locales .................................................................................................................. 5 Parametros Formales ............................................................................................................ 5 Parametros Actuales ............................................................................................................. 6 Variables Globales ................................................................................................................ 6 OPERADORES ARITMETICOS .......................................................................................... 7 Prioridad de los operadores en general .............................................................................. 8 Función de c para la potencia ............................................................................................ 8 Función de c para la raiz ...................................................................................................... 8 Diferentes formulas expresadas para programacion ........................................................ 9 OPERADORES LOGICOS ................................................................................................... 10 Tabla de Verdad de los operadores logicos ........................................................................ 10 OPERADORES RELACIONALES ...................................................................................... 10 OPERADORES ESPECIALES .............................................................................................. 12 Modo prefijo .......................................................................................................................... 12 Modo posfijo ......................................................................................................................... 12 FUNCIONES BASICAS ....................................................................................................... 12 Funcion scanf ........................................................................................................................ 12 Funcion gets ( ) ..................................................................................................................... 14 Función printf ( ) ................................................................................................................... 14 SENTENCIAS SELECTIVAS ............................................................................................... 18 Funcion if ( ) .......................................................................................................................... 18 ¿Que entendemos por “expresión” ? .................................................................................. 18 Analisis de la sintaxis de la funcion if ( ) ............................................................................ 19 Sentencia switch( ) ... case .................................................................................................. 22 SENTENCIA DE CONTROL DE CICLOS ......................................................................... 24 Sentencia while ( ) ................................................................................................................. 24 Sentencia do ... while ( ) ................................................................................................ 31 Sentencia for ( ) .............................................................................................................. 33


78

ARREGLOS (ARRAYS) ....................................................................................................... 40 Advertencia: Lenguaje C no da la comprobación de contornos ....................................... 41 Clasificación de los Arreglos ............................................................................................... 42 Declaración de un Arreglo ................................................................................................... 43 Programas con Vectores ....................................................................................................... 45 MATRICES ............................................................................................................................ 53 Declaración de una Matriz ................................................................................................... 53 Programas con Matrices ....................................................................................................... 54 PROGRAMAS CON CADENAS DE CARACTERES ....................................................... 64 Conceptos utilizados en el manejo de cadena de caracteres ............................................. 66 PUNTEROS ........................................................................................................................... 67 ¿Que son los Punteros? ........................................................................................................ 67 Variables y Punteros ............................................................................................................ 68 Operadores con direcciones ................................................................................................. 68 Programas con acceso a un Arreglo usando un Puntero .................................................. 69 Regla sobre punteros ............................................................................................................ 70 FUNCIONES ......................................................................................................................... 73 Definición de Función .......................................................................................................... 75

Lenguaje C, Manual de Programacion - M.C. Enrique Ruiz Diaz

Documents

Transcript of Lenguaje C, Manual de Programacion - M.C. Enrique Ruiz Diaz