Primer día de clases.
Programación de Computadoras I.
Introducción Personal. (Identificar a los alumnos e identificarme con ellos). Datos personales. Lista de asistencia, llenado de datos generales del alumno. Introducción a la Asignatura de Programación de computadoras I. (Materias Antecedentes y Consecuentes). Carta descriptiva. Breve motivación a los alumnos de la materia en curso. Presentación de metodología de evaluación, reglas del juego. Entrega del Programa de la asignatura. 1.-INTRODUCCIÓN A LA PROGRAMACIÓN. (5 HRS=1 SEMANAS=2 CLASES). 1.1.-Historia de los Lenguajes de programación:
Clase No.1 Introducción a los lenguajes de programación. 1.- Que es una computadora? Dispositivo capaz de ejecutar cálculos y tomar decisiones lógicas a velocidades de millones o miles de millones de veces mas rápido que lo que los seres humanos lo pueden hacer. Puntos a considerar: Como saber si un humano se equivocó al hacer miles de operaciones?. El tiempo que tardaría una persona en ejecutar millones de operaciones? Posibles décadas. Una computadora solo un segundo. En la actualidad computadoras hacen operaciones de trillones de operaciones por seg. Las computadoras procesan datos bajo el control de un conjunto de instrucciones que se conocen como programas de computación. Estos guían a la computadora a través de conjuntos ordenados de acciones especificados por personas conocidas como programadores de computadoras. A los varios dispositivos que conforman un sistema de computación se le denominan hardware. Los programas de computación que se ejecutan en una computadora se conocen como software. Organización de una computadora (arquitectura). Todas las computadoras pueden dividirse en 6 unidades lógicas o secciones: 1) Unidad de entrada.-Sección de recepción de la computadora. Obtiene información (datos y programas) a partir de los dispositivos de entrada y pone la información a disposición de otras unidades para su procesamiento. 2) Unidad de salida.- Toma la información que ha sido procesada y la coloca en varios dispositivos de salida para su uso fuera de la computadora. 3) Unidad de memoria (memoria principal).- Sección de almacén de rápido acceso. Retiene información que ha sido introducida a través de la unidad de entrada, para que la información este de inmediato disponible para su proceso cuando sea necesario. También retiene información ya procesada, hasta que llegue al dispositivo de salida por medio de la unidad de salida. 4) Unidad aritmética lógica.-Sección de fabricación de la computadora. Responsable de la ejecución de cálculos como suma, resta, multiplicación, división. Contiene mecanismos de decisión (por ejemplo: comparar dos elementos para saber si son iguales). 5) Unidad de procesamiento central.- Sección administrativa de la computadora. Es el coordinador de la computadora responsable de la supervisión de la operación de las demás secciones. El CPU indica a la unidad de entrada cuando debe leerse la información y colocarse en la memoria. Indica al ALU cuando utilizar información de la unidad de memoria en cálculos, y le indica a la unidad de salida cuando enviar información de la unidad de la memoria los dispositivos de salida. 6) Unidad de almacenamiento secundario.- Sección de almacén a largo plazo de alta capacidad. Los programas o los datos que no se estén utilizando de forma activa por otras unidades se almacenan aquí hasta que vuelvan a ser utilizadas.
Arquitectura de Von Newmann. MEMORIA RAM,ROM
SISTEMA ENTRADA
SISTEMA SALIDA
CPU
______ ______ ______ ______ ______ ______ ______ ______ ______ REGISTROS
UNIDAD DE CONTROL Diagrama de la arquitectura de Von Newmann. La arquitectura de von Neumann es una familia de arquitecturas de computadoras que utilizan el mismo dispositivo de almacenamiento tanto para las instrucciones como para los datos (a diferencia de la arquitectura Harvard). La mayoría de computadoras modernas están basadas en esta arquitectura. Las computadoras con esta arquitectura constan de la ALU, unidad de control, memoria, dispositivos de E/S y el bus de datos. Todo se controla por una plataforma, que es un sistema operativo (S.O.). Un sistema operativo es una serie de herramientas que administran y controlan los recursos de un sistema o una computadora (memoria, disco, teclado, monitor). Es el núcleo y sobres de el están todas las aplicaciones (word, excel, access, explorer). Es un intermediario para llegar al CPU.
S.O. CPU Aplicaciones
Procesamiento por lotes, multiprogramación, tiempo compartido. Procesamiento por lotes.-Al principio las computadoras eran capaces de ejecutar un solo trabajo o tarea a la vez. La computadora ejecuta un programa a la vez al procesar datos en grupos o en lotes (tarjetas perforadas). Multiprogramación.- Muchos trabajos o tareas pueden compartir los recursos de la computadora para una mejor utilización. Implica la operación simultanea de muchos trabajos en una computadora. La computadora comparte sus recursos entre los trabajos que compiten por su atención. Tiempo compartido.- Caso de la multiprogramación en donde los usuarios tienen acceso a la computadora a través de dispositivos de entrada/salida o terminales. La computadora no ejecuta las ordenes de todos los usuarios en forma simultanea, sino que ejecuta una porción del trabajo de un usuario, y a continuación pasa a darle servicio al usuario siguiente. Lo hace tan aprisa que puede darle servicio a cada usuario varias veces por segundo, que pareciera que los trabajos se están ejecutando de forma simultanea. Ver sistemas multiprocesamiento, cliente-servidor. Una computadora pues en la actualidad realiza o emula pasos secuencialmente. Modularización.- Modular (en partes), en secciones o módulos.
compilar
Compilador o traductor S.O. UNIX DOS
Lenguaje de maquina
Compilador C/C++ Un compilador genera archivos ejecutables, un interprete no genera archivos ejecutables. Investigar que es un compilador, un interprete y diferencia entre ambos. Lenguajes maquina, lenguajes ensambladores y lenguajes de alto nivel. Lenguaje.- Es un sistema de comunicación. Conjunto de códigos o símbolos estructurados que llevando un orden y un conjunto de reglas existe la comunicación con significado coherente. Un lenguaje de programación es un idioma artificial diseñado para expresar computaciones que pueden ser llevadas a cabo por máquinas como las computadoras. Son herramientas que nos permiten crear programas y software. Los lenguajes de programación de una computadora en particular se conoce como código de máquinas o lenguaje de máquinas. Los programadores escriben instrucciones en diferentes lenguajes de programación, algunos comprensibles de forma directa por la computadora, y otros requieren pasos intermedios de traducción. Hoy en día existen cientos de lenguajes distintos. Los lenguajes de programación se categorizan en tres diferentes lenguajes: Lenguajes maquina, lenguajes ensambladores y lenguajes de alto nivel.
Lenguajes maquina.- Las computadoras solo entienden directamente su propio lenguaje maquina. Este es el lenguaje natural de una computadora particular. Se relaciona íntimamente con el diseño de hardware de esa computadora. Consisten en cadenas de números, que instruyen a las computadoras para que ejecuten sus operaciones mas elementales una a la vez. Los lenguajes maquina son dependientes de la maquina, es decir un lenguaje maquina particular puede ser utilizado en un solo tipo de computadora. Difícilmente manejados por los seres humanos. Lenguaje ensamblador (bajo nivel).- La programación anterior era demasiado lenta, y tediosa para los programadores, y en lugar de utilizar cadenas de números, se comenzaron a usar abreviaturas similares al inglés (nemotécnicos) para representar las operaciones elementales de la computadora. Estos formaron la base de los lenguajes ensambladores. Se desarrollaron programas de traducción llamados ensambladores para convertir los programas de lenguaje ensamblador a lenguaje de maquina a la velocidad de las computadoras. Lenguaje de alto nivel.- Con los lenguajes anteriores aun se necesitaban de muchas instrucciones para llevar a cabo aun así las tareas mas sencillas y se desarrollaron los lenguajes de alto nivel. En estos se pueden escribir simples enunciados para poder llevar a cabo tareas sustanciales. Estos lenguajes permiten escribir instrucciones que parecen prácticamente como el ingles de todos los días y contiene notaciones matemáticas por lo común utilizadas. Los programas de traducción que convierten los programas de lenguaje de alto nivel al lenguaje maquina se llaman compiladores. Para el tema de “Introducción al lenguaje C principios e historia”, se efectuará la Tarea No. 1 como investigación. Esta se especifica en la siguiente hoja. Breve historia del lenguaje C. Nació en los laboratorios de Bell Telephone y esta asociado al sistema operativo UNIX, porque esta desarrollado en este sistema. El lenguaje C esta inspirado en el lenguaje B, creado por Ken Thompson en 1970, y este a su vez se inspiro en el lenguaje BCPL (Basic Combined Programming Language), creado por Martin Richard en 1967. En 1972 Dennis Rithchie modifica el B, creando el lenguaje C y el cambio de B a C fue el diseño de tipos y estructuras de datos.
Ver cronología de los lenguajes de programación para ubicar los lenguajes antecesores y posteriores al lenguaje C y observar y analizar cuales existen.
1.-INTRODUCCIÓN A LA PROGRAMACIÓN. (5 HRS=1 SEMANAS=2 CLASES). 1.1.-Historia de los Lenguajes de programación:
Tarea No. 1. Fecha de Entrega:_____________________________________________________ Investigación.• Se investigará todo lo relacionado con la historia de los lenguajes de programación. o Historia de los principales lenguajes de programación y para que eran utilizados, y si siguen utilizándose en la actualidad. o Cronología de los lenguajes de programación (antecesores del C). o Antecedentes históricos del lenguaje C. • ANSI, qué es y qué tiene que ver con el lenguaje C. Porqué fue necesario el ANSI con el lenguaje C. • Características del lenguaje C y conceptos generales o Proceso de edición, compilación, enlazado. o Entorno del lenguaje C. o Ejemplos de aplicaciones de la actualidad escritas en lenguaje C. • Qué es un intérprete y qué es un compilador. Diferencias entre ambos.
Notas acerca de que deben contener las tareas y trabajos de entrega. •
La fecha de entrega, es el día estipulado y acordado por el grupo y el maestro.
•
Portada completa. (Incluye, logo, datos del alumno, la materia, carrera, profesor, TEMA, FECHA).
•
El trabajo deberá contar con la bibliografía consultada y de ser necesario citar párrafos con su bibliografía.
•
Deberá realizarse con limpieza y orden.
•
El contenido escrito del trabajo deberá ser una síntesis de lo consultado, en donde el autor será usted mismo (alumno).
•
El Internet es buena fuente de consulta, mas se debe tener cuidado de donde se consulte, y no solamente incluir aspectos de Internet, deberá complementar sus investigaciones con la bibliografía sugerida, o libros de lenguaje C.
•
Eliminar la paja en el contenido del trabajo, mas no dejar fuera aspectos importantes que crea que se deben incluir.
•
El contenido deberá encontrarse libre de errores ortográficos y de contexto.
* 1.1 Breve Introducción al lenguaje C (Ver). (Presentación Office PowerPoint).
Procedimiento para resolver un problema por medio de una computadora. 1.- Definir el problema. 2.-Análisis del problema. 3.-Diseño del programa. a) por medio de un algoritmo b) prueba de escritorio (diagrama de flujo) 4.- Codificación del programa. (C ). 5.- Implementación del programa. 6.- Mantenimiento (Actualización). Ejemplo: 1.- Definir el problema. Sumar dos números. 2.- Análisis del problema.- obtener 1er numero, obtener 2do numero, que sean reales, enteros, y después por medio de ellos obtener el resultado. 3.- Diseño.- a) Por medio de algoritmo (serie de pasos que dan resultado a la solución del problema). 1) leer un numero x 2) leer un numero y 3) sumar x + y 4) almacenar resultado en c 5) imprimir c 6) fin. ` b) Por medio de diagrama de flujo (representación gráfica de un algoritmo). inicio
X
Y
C=X+Y
C
fin
4.- Codificación (en el lenguaje que se este realizando, en este caso lenguaje C: #include <stdio.h> int main( ) { float x,y,c; scanf(“%f %f, &x, &y); c=x+y; printf(“%2f”, c); return 0; } 5.-Implementación del programa. 6.-Mantenimiento. Notas: Ver apunte con los alumnos de ESPECIFICACIONES PARA EL DESARROLLO DE PROGRAMAS. Mandar apunte a sus correos. ESPECIFICACIONES PARA EL DESARROLLO DE PROGRAMAS Instrucciones. Cada uno de los ejercicios en clase así como de las prácticas deberán seguir como mínimo la siguiente metodología para el desarrollo de un programa. Paso 1. Análisis del problema Este paso consiste en analizar la problemática que se desea resolver, si no cuenta con suficiente información es importante aclarar dudas investigando más acerca del problema. Paso 2. Diseño En este paso, una vez comprendida la problemática se pasa a a la fase de diseño, en la cual se puede hacer uso de un lenguaje de diseño como lo es el pseudocódico, diagrama de flujo u otro. Si se empleará un TDA (Tipo de dato abstracto) es importante realizar el diseño lógico del mismo. Para poder validar el diseño requiere que se le realicen pruebas, por ejemplo las pruebas de escritorio son útiles para revisar que nuestro algoritmo es correcto. Paso 3. Desarrollo En este paso, el programador se dispone a realizar el código, se recomienda pues comenzar con el o los archivos de cabecera (.h), en el que estarán definidas las clases. Posteriormente la implementación de los métodos en otro archivo (cpp) y por último la aplicación, la cual resuelve la problemática analizada y plasmada en el paso 1. Paso 4. Pruebas El código rara vez esta libre de errores. Los errores detectarse en tiempo de compilación, en tiempo de enlazado o en tiempo de ejecución. Lo ideal es que tengamos un código libre de errores, por lo que debemos detectar tanto los errores de sintaxis como los errores de lógica, incluso en ocasiones se detecta algún error que implica regresar a hacer modificaciones a las fases anteriores.
Es importante que revisemos todos los casos posibles que se pueden dar en la problemática abordada, ya que de no hacerlo es muy probable que nuestro programa no se comporte en forma adecuada o se produzcan errores. Paso 4. Entrega y Liberación Paso 5 Mantenimiento 1.2.- Proceso de Edición, Compilación y Enlazado. Todos los sistemas en C se dividen principalmente en el entorno, el lenguaje y la biblioteca estándar de C. Los programas pasan por 6 fases principales para llegar a su ejecución. 1) Edición.- Se ejecuta en un programa de edición para que el programador escriba un programa en C en el editor, y si es necesario hace correcciones. 2) El programa se almacena en un dispositivo secundario. Los nombres de los primeros archivos creados tienen una extensión .c (en el C estándar) en este caso estudiaremos c/c+ +, por lo que se almacenan con la extensión .cpp. Esta es la creación de lo que se conoce como código fuente. 3) A continuación el programador manda llamar el comando compilar el programa. El compilador traduce el programa con extensión c o cpp a código de lenguaje de maquina, también conocido como código objeto. En un sistema en C un preprocesador ejecuta de forma automática antes de la fase de traducción. El preprocesador C obedece comandos especiales que se llaman directrices de preprocesador, que indican que antes de su compilación se deben de ejecutar ciertas manipulaciones sobre el programa. Estas manipulaciones consisten en inclusiones de otros archivos en el archivo a compilar y reemplazo de símbolos especiales con texto de programa. 4) Enlazado.- Los programas en C por lo general tienen referencias a funciones definidas en algún otro lugar como en bibliotecas estándar o en bibliotecas de un grupo de programadores que trabajan en un proyecto en particular. Entonces el código objeto producido por el compilador C típicamente contendrá huecos debido a estas partes faltantes. Un enlazador vincula el código objeto con el código de las funciones faltantes para producir una imagen ejecutable (sin ninguna parte faltante). Si el programa compila y enlaza de forma correcta se produce un archivo con el mismo nombre pero con la extensión .x, .out , .exe (ejecutable). Esta es la imagen ejecutable de nuestro programa .cpp 5) Cargar.- Antes de que un programa pueda ser ejecutado, el mismo debe ser colocado en memoria. Esto lo hace el conocido como cargador. Este toma la imagen ejecutable de disco y la transfiere a la memoria. 6) Ejecución.- Por ultimo se lleva a cabo la ejecución bajo el control del cpu. Esto se ejecuta una instrucción a la vez. En la actualidad mandando llamar al .exe o ejecutable con un simple doble clic, antes se mandaba llamar escribiendo nombre del archivo.out (para UNIX).
ENCADENADOR Y EJECUCION
COMPILADOR gcc, tcc, vc
EDITOR
Permite crear archivos fuentes (codigo fuente .c o .cpp)
crea el .obj
.EXE o .x
*
EDITOR
COMPILADOR
ERRORES ? •
Notas: Analizar los diferentes tipos de errores posibles en el programa.
SI
.OBJ
ENCADENADOR (O LINKER)
.EXE
COMPILAR A MEMORIA Y EJECUTAR
NO FIN
ERRORES DE LOGICA ?
SI *
Estructura general de un programa en C. #define Área de directivas del procesador de C #include FUNCIONES AREA DE DECLARACION DE VARIABLES GLOBALES main( ) (función principal) elementos { de léxico inicio del programa. DECLARACION DE VARIABLES LOCALES INSTRUCCIONES . .
Todo lo que se encuentre fuera de las llaves de main se considera global y fuera de main.
cuerpo del programa. } FIN DEL PROGRAMA. FUNCIONES NOTAS IMPORTANTES: • • • • • • •
Las palabras reservadas generalmente se escriben en minúsculas (ver que son las palabras reservadas). Un programa en C consta de funciones, la función principal es main( ) y es donde se da inicio a la ejecución del programa. Los comentarios se inician /*TEXTO*/ Ejemplo: /*UACJ*/ /*programa elaborado por..*/ Para terminar una linea se escribe e indica con “;” (punto y coma). Inicio de un bloque { Fin de un bloque } Todas las variables en C tienen que ser declaradas de un tipo (ver los tipos de datos mas delante).
Ejemplo de un programa empleando la estructura general. Preprocesador -> procesador -> resultado (#include <stdio.h>) velocidad de proceso. #include <stdio.h> int main ( ) { /*inicio*/ printf(“HOLA MUNDO”); return 0; cuerpo del programa. } /*fin*/ C es el mundo de las funciones.
Como se identifica una función en C. Nombre (argumentos); Variables. Todas las variables dijimos que se tienen que declarar de cierto tipo. Una variable es un conjunto de letras o caracteres que generalmente cambian su valor durante la ejecución de un programa. Reglas para uso de variables. a) Deberán iniciar con letra mayúscula o minúscula o el carácter único aceptado ( _ ) de subrayado. Ejemplos: nombre_personal; _xyz; A043988; Ejemplos no permitidos: 1ABX; #XYZ; .r3; b) La longitud máxima del nombre de la variable es de 256 caracteres. Constantes. Un numero o valor que no cambia durante la ejecución de un programa. Ejemplo: 3.1416 Como se definen las constantes en C: #define PI 3.1416 Nota importante: C es sensitivo a las letras mayúsculas y minúsculas. Por lo que no seria lo mismo: PI, pi, Pi cada una actuaria como diferente constante o variable según sea el caso. Tipos de datos. Tipos enteros char signed
int short
long
Tipos reales (punto flotante o decimal) unsigned enum
float
double
longdouble
MEMORIA - - - - char - - - -
1 byte - - - - - - - - - - - - - 2 byte
int
- - - - - - - - - - - - - 3 byte - - - - - - - - - - - - - 4 byte - - - - - - - - - - - - - 5 byte - - - - - - - - - - - - - 6 byte - - - - - - - - - - - - - 7 byte - - - - - - - - - - - - - 8 byte
float
Asignar tipos de datos: nombre char nom [40]; edad int edad; matricula long matricula; pago x hora float pago; no de créditos int creditos; área circulo float area; . . .
Construcción de expresiones: ( Expresión ) paréntesis (
(
(
)
)
)
Ejemplo: x= ( y * z + ( ( n-4 ) * 3 ) ) ; 1 2 3
z= x + 4 * 3 + 2 x + 12 + 2
OPERADORES ARITMETICOS.
+
SUMA
-
RESTA
*
Multiplicación
/
DIVISION
%
Módulo
El módulo es el residuo de una división entera. •
•
Ejemplo
x=5%2
x=1
En C una expresión se escribe: VARIABLE = (expresión); asignación. Para tener un bloque de soluciones es necesario tener una delimitación. { - Bloque }
OPERADORES RELACIONALES. MAYOR QUE >
<
MENOR QUE
>=
MAYOR O IGUAL QUE
<=
MENOR O IGUAL QUE
!=
DIFERENTE
==
IDENTICO A
OPERADORES LOGICOS.
&&
AND
||
OR
!
NOT
TABLA AND X
Z
TABLA OR X
Y
Y
Z
0
0
0
0
0
0
0
1
0
0
1
1
1
0
0
1
0
1
1
1
1
1
1
1
TABLA NOT X
Y
0
1
1
0
OPERADORES DE ASIGNACION. ASIGNAR A =
+=
SUMA + ASIGNACION
*=
Multiplicaci贸n + ASIGNACION
/=
DIVISION + ASIGNACION
++
INCREMENTO 1 UNIDAD
--
DECREMENTO 1 UNIDAD
Ejemplos: x=y2 + 1 ; . . . . . . suponga que y=2; z+=1; => z=z+1; n * = z+2; => n = n * (z+2); x=2; x++; x++; printf(x); => x=? , 4
x=10 x--; x--; printf(x); => x=? , 8
x=5.
Si n=1 y z=2 x=(n!=z); printf(x); => x=? , 1 (verdadero)
Si x=4 y z=2 m=(z==(x-2); printf(m); => m=?, 1(verdadero)
INSTRUCCIONES DE E/S (ENTRADA/SALIDA). FUNCION DE SALIDA printf( ); printf( palabra reservada
); argumentos de la función.
Argumentos de la función. Son caracteres ordinarios , secuencias de escape, especificadores de formato, caracteres especiales. (ver ejemplos de cada uno). Ejemplo: printf(“HOLA!”);
printf(“UACJ, IIT”);
cadena de caracteres ESPECIFICADORES DE FORMATO (Los mas comunes). %d números enteros 5 dígitos. %f números flotantes 7 dígitos. %c un solo carácter 'c' %s cadena de caracteres “cadena” Ejemplos: 1) printf(“%s”,”UACJ”); printf(“%s %f”, “PI”, 3.1416); Imprime PI 3.1416 2) x=8.33333; printf(“%.2f”,x); /*ver sin punto .2f*/ 3) y=432; printf(“y=%d”,y); 4) printf(“EL AREA DEL CIRCULO ES IGUAL A...%f CON UN RADIO DE...%f”,area,radio); /*ver ejemplos con .1f y .2f para el área*/. 5) Ver con el grupo algunos ejemplos y casos mas. Las secuencias de escape inician con el caracter de ( \ ) (backslash o diagonal invertida). Las secuencias de escape son caracteres no imprimibles que solo ejecutan acción o acciones sobre los datos (salida de los datos). Sirven para darle formato a lo que se imprime en pantalla y se escriben dentro de las comillas de los argumentos de la función. \n --> nueva linea \t --> tabulador \r --> retorno de carro \a--> beep (alerta) \b--> retroceso
\” --> comillas simples \f --> forma continua (alimentación de pagina).
Ejemplos: printf(“UACJ \n IIT \t 2011”); /*El tabulador son 8 espacios*/ printf(“HOLA BUENOS DIAS \b\b”);
HOLA BUENOS DI_
printf(“CANTIDAD \tCOSTO\tSUCURSAL\n”); printf(“--------\t-------\t--------\n”); FUNCION DE ENTRADA scanf( ); scanf( palabra reservada
); argumentos de la función.
En donde los argumentos son especificadores de formato, variables y el operador de dirección (&). Ejemplo: printf(“INGRESE EL VALOR DEL DATO:\n”); scanf(“%f”, &variable); especificador de formato, operador de dirección, variable. El &, en el area de datos guarda el valor de la variable. & conoce el lugar donde almacena el valor. Si no se escribe &, si se almacena el valor pero el compilador no sabe donde se almaceno en la memoria, hablando de alguna localidad. Sintaxis: scanf(“especificador de formato”,&var1,&var2...,&var-n); float x; int y; char z; scanf(“%f %d %c”, &x, &y, &z); DELIMITADORES. a->5 b->31 c->1 1) ENTER 2) BARRA ESPACIADORA 3) TABULADOR
Se recomienda mejor usar el 1 o el 2.
DECLARACION DE VARIABLES. Tipos de datos { enteros, reales, otros tipos} Estructura: declaracion de variables globales int main( ){ declaracion de variables locales instrucciones } Declaración: tipo nombre de la variable,nombre de la variable, nombre de la variable,.....; Ejemplo: int a,b,d,x; o puede ser: int a; int b; int d; int x; /*o bien puede ser una en cada linea*/ char c; int a; float x,m,z; char nombre[30]; Ejemplo de un programa para sumar dos números enteros. #include<stdio.h> #include<conio.h> void main( ){ int x,num1,num2; clrscr( ); /*explicar función clrscr en turbo c y diferencia con otros compiladores*/ printf(“Introduce el primer numero:\n”); scanf(“%d”,&num1); /*pudiera ser un solo printf( ); y un solo scanf( ); analizar*/ printf(“Introduce el segundo numero:\n”); scanf(“%d”,&num2); x=num1+num2; printf(“\nLa suma de %d + %d es:%d”,num1,num2,x); getch( ); } /*Analizar algunos errores de compilación debido a falta de especificadores de formato, declaraciones de variables erróneas, falta del &*/ /*Analizar y explicar el uso de getch( );*/
Ejemplo de un programa para elevar un numero entero al cuadrado, al cubo, y a la cuarta potencia. #include<stdio.h> #include<conio.h> void main( ){ int num,x,y,x; clrscr( ); printf(“Introduce el numero que quieres elevar:\n”); scanf(“%d”,&num); x=num*num; y=x*num; z=y*num; /*podría ser x*x*/ printf(“\nEl numero %d elevado al cuadrado es:%d\nAl cubo es:%d\nA la cuarta es:%d”,x,y,z); getch( ); } /*comentar las diferentes formas de elaborar este programa, pudiendo ser elevar todo en el printf( ); sin la necesidad de declarar 4 variables, declarando solo la del numero a elevar. */ Practica.-Elaborar un programa para calcular el área y perímetro de un circulo de radio r. PRIORIDAD Y ORDEN DE EVALUACION DE EXPRESIONES. (
)
de izquierda a derecha
( ( (
) ) )
del mas interno al mas externo
Ejemplos: 2*8+3*5 = 16+15 = 31 (2*8)+(3*5) 2*5+5*3+4*10 = 10+15+40 = 65 (2*5)+(5*3)+(4*10) -8*5/3*2 -40 / 3*2 (-40/3) * 2 -13*2= -26 4%2+3-4*5 (4%2)+3-(4*5) 0 +3-20 = -17 5*4-12/2 (5*4)-(12/2) 20-6 =14 Orden: Multiplicación, División Modulo. Son principales. Luego Suma, Resta.
CONTROL SECUENCIAL. El control secuencial permite la ejecución de bloques de instrucciones de forma no simultanea, es decir ejecuta una instrucción y luego otra instrucción. Nota: La ejecución de instrucciones se realiza a muy altas velocidades. Secuencia Conjunto de sentencias que se ejecutan en orden . CONTROL DE FLUJO CONTROL SELECTIVO TOMA DE DECISIONES. Selección Elige qué sentencias se ejecutan en función de una condición. Ejemplos: Estructuras de control condicional if-then-else y case/switch Sentencia IF.
Resultado lógico al evaluar
EXPRESION
NO
ACCION(ES)
SI
ACCION(ES) Sintaxis: if(expresión) { --- bloque de instrucciones -(acción o acciones) }
SIGUIENTE INSTRUCCION
El bloque de acciones es ejecutado solo si la expresión es verdadera, de lo contrario continua con la siguiente instrucción. Ejemplo: A=3; B=2; if((A-1)==B) { printf(“A-1 ES IDENTICO A B”); } ...
Ejemplos mediante el uso de la sentencia if ( ). 1) Elaborar un programa que lea dos números y determine el mayor de ellos (considerar si son iguales). #include<stdio.h> #include<conio.h> void main( ){ int num1,num2; clrscr( ); printf(“Introduce el primer numero:\n”); scanf(“%d”,&num1); printf(“Introduce el segundo numero:\n”); scanf(“%d”,&num2); if(x>y) { printf(“\nEL NUMERO %d ES MAYOR QUE EL NUMERO %d”,x,y); } if(y>x) { printf(“\nEL NUMERO %d ES MAYOR QUE EL NUMERO %d”,y,x); } if(x==y) { printf(“\nEL NUMERO %d Y EL NUMERO %d SON IGUALES”,y,x); } printf(“\nFIN DEL PROGRAMA”); getch( ); } /*ver las diferencias formas de efectuar las comparaciones con los operadores relacionales*/ 2.-Elaborar un programa que lea tres calificaciones, obtenga su promedio y determine si en base al promedio el alumno se encuentra aprobado o reprobado. #include<stdio.h> #include<conio.h> void main( ){ float cal1,cal2,cal3,prom; clrscr( ); printf(“Introduce la primera calificación:\n”); scanf(“%f”,&cal1); printf(“Introduce la segunda calificación:\n”); scanf(“%f”,&cal2); printf(“Introduce la tercera calificación:\n”); scanf(“%f”,&cal3); prom=(cal1+cal2+cal3)/3; if(prom>=7) { printf(“\nEL ALUMNO ESTA APROBADO CON UN PROMEDIO DE: %f”,prom); } if(prom<7) { printf(“\nEL ALUMNO ESTA REPROBADO CON UN PROMEDIO DE: %f”,prom); } getch( ); }
Programa para leer un numero entero y determinar si es negativo, positivo o si es cero. #include<stdio.h> #include<conio.h> void main( ){ int num; clrscr( ); printf(“Introduce el numero:\n”); scanf(“%d”,&num); if(num>0) { printf(“\nEL NUMERO %d ES POSITIVO”,num); } if(num<0) { printf(“\nEL NUMERO %d ES NEGATIVO”,num); } if(num==0) { printf(“\nEL NUMERO ES CERO”); } getch( ); } Sentencia if-else. Resultado lógico al Bloque acciones cierto 1
evaluar
EXPRESION
Siguiente instrucción
falso
Bloque acciones 2
Sintaxis: if(expresión) { ---palabras } reservadas else { --} Si la expresión del if es verdadera ejecuta el bloque de acciones o instrucciones del if, de lo contrario ejecuta el bloque de acciones o instrucciones del else.
Ejemplo breve: if(x>y) { printf(“x>y”); } else { printf(“x no es > que y”); } Ejercicios: Cambiar los programas vistos con el if, ahora con la utilización del if-else. OPERADOR TERNARIO ?: ?: --> if-else Sintaxis: expresión ? acción 1 : acción 2; En base a la evaluación de la expresión que arroja como resultado un valor lógico. Si es verdadero ejecuta la acción 1, si es diferente a verdadero ejecuta la acción 2. Ejemplo: x=2; (x>5) ? printf(“x>5”) : printf(“x no es > 5”); Otro ejemplo: x=2; y=3; z=x+2; ((x+z)==(y+z)) ? printf(“%d”,x+z) : printf(“%d”,y+z); % MODULO Este operador obtiene el residuo de una división entera. Practica: Escribir un programa que determine si un numero entero es par o impar. x=10%2; por lo tanto x=0; entonces, x=num%2; Practica resuelta: #include<stdio.h> int main( ){ int x,z; printf(“\nINTRODUCE UN NUMERO”); scanf(“%d”,&y); z=y%2; if(z==0){ printf(“\nEL NUMERO %d ES PAR”,num); } else{ printf(“\nEL NUMERO %d ES IMPAR”,num);} return 0; getch( ); }
Sentencia switch-case estructura switch
Caso A
Bloque acciones de A
Caso B
Bloque acciones de B
break
Bloque acciones de B
break
break
* * * Caso Z
accion(es) por omision
Sintaxis: Siguiente switch (expresión) { instruccion case constante: acción(es) break; case constante: tipo entero o caracter acción(es) break; ... default: /*este default es opcional*/ acción(es) } fin
Los case pueden ser numéricos: case 1: o con un caracter: case 'A': Nota: El switch no es un ciclo, es selección múltiple.
Ejemplos: 1) Diseñar un programa que lea un numero e indique a que mes del año pertenece. #include<stdio.h> #include<conio.h> void main( ){ int opcion; clrscr( ); printf(“Introduce el numero:\n”); scanf(“%d”,&opcion); switch (opcion) { case 1: printf(“\nEL NUMERO %d PERTENECE A ENERO”,opcion); break; case 2: printf(“\nEL NUMERO %d PERTENECE A FEBRERO”,opcion); break; ... /* ASI CON CADA UNO DE LOS MESES HASTA EL 12*/ default: printf(“\nEL NUMERO %d ES INCORRECTO”,opcion); break; } getch( ); } 2) El uso de la sentencia switch se utiliza mucho para la cuestión de los menús y seleccionar alguna de las opciones mostradas. Ejemplo: #include<stdio.h> #include<conio.h> void main( ){ char opcion; clrscr( ); printf(“MENU PRINCIPAL:\n”); printf(“<A>LTAS DE MATERIAS:\n”); printf(“<B>AJAS DE MATERIAS:\n”); printf(“<C>AMBIOS DE GRUPOS:\n”); printf(“<S>ALIR DEL PROGRAMA:\n”); printf(“***PRESIONE LA OPCION DEL MENU DESEADA***:\n”); scanf(“%d”,&opcion); switch (opcion) { case 'A': case 'a': printf(“\nBIENVENIDO AL PROGRAMA PARA DAR DE ALTA UNA MATERIA”); break; case 'B' case 'b': printf(“\nBIENVENIDO AL PROGRAMA PARA DAR DE BAJA UNA MATERIA”); break; ... /* ASI CON CADA UNA DE LAS OPCIONES HASTA LA <S> SALIR DEL PROGRAMA*/ default: printf(“\nOPCION NO VALIDA VUELVA A INTENTAR, GRACIAS”,opcion); break; } getch( ); }
3) Elaborar un programa que pida una calificación y determine en su forma inglesa si pertenece a una A, B, C D, E, F. #include<stdio.h> #include<conio.h> void main( ){ int calificacion; clrscr( ); printf(“Introduce la calificacion:\n”); scanf(“%d”,&calificacion); switch (calificacion) { case 10: printf(“\nLA CALIFICACION %d EQUIVALE A UNA \“A\””,calificacion); break; case 9: printf(“\nLA CALIFICACION %d EQUIVALE A UNA \“B\””,calificacion); break; ... /* ASI CON CADA UNA DE LAS CALIFICACIONES HASTA LA F DE REPROBATORIA*/ default: printf(“\nLA CALIFICACION QUE DIGITO ES INCORRECTA”); break; } getch( ); }
CONTROL REPETITIVO. Ciclos iterativos. Instrucciones repetitivas, permite que se ejecuten un grupo de acciones un numero determinado o indeterminado de ocasiones. C CICLOS DEFINIDOS
INDEFINIDOS
El conjunto de instrucciones que se ejecuta repetidamente se llama ciclo o bucle . En el lenguaje C se manejan 3 clases de ciclos: ciclos
while ( ) mientras for ( ) para do-while ( ) ejecutar-mientras
Ciclo iterativo while. ESTRUCTURA ciclo Sintaxis: while(expresión) { inicio bloque de instrucciones } siguiente instrucción.
loop expresión
si
acción(es)
no Siguiente instruccion
Instrucción continue; Expresión que transfiere el control del ciclo al inicio de este. while (expresión) { break; /*aqui el break pasa al fin*/ ... continue;.. } siguiente instrucción
Ejemplo: int x=1; while(x<=10) { printf(“\n%d”,x); x++; } /*también se podría escribir printf(“\n%d”,x++); */ Ejemplo No2.- Escribir un programa que imprima los numeros pares del 2 al 100. int x=2; while(x<=100) { printf(“\n%d”,x); x+=2; } La instrucción de salto continue siempre se usa para interrumpir (romper) la ejecución normal de un bucle. La instrucción continue salta (no ejecuta) las instrucciones que existan después de ella, en la iteración de un bucle. Break; La sentencia break se usa para forzar un salto hacia el final de un ciclo controlado por for o por while. La función rand( ) y srand( ); En C, para obtener números aleatorios, tenemos la función rand(). Esta función, cada vez que la llamamos, nos devuelve un número entero aleatorio entre 0 y el RAND_MAX (un número enorme, como de 2 mil millones). El primer problema que se nos presenta es que no solemos querer un número aleatorio en ese rango, sería un dado muy curioso el que tenga tantas caras. Podemos querer, por ejemplo, un número aleatorio entre 0 y 10. O de forma más general, entre 0 y N. El calculo que nos permite hacer esto es: La función rand() ( utiliza math.h ) genera un número entero aleatorio entre 0 y 32767 . x=rand ( ) % N+1; Si queremos un numero aleatorio entre un rango [N,M] con M < N determinado entonces hacemos lo siguiente:
y=rand ( ) % (N – M+1) + M; Ejemplo del uso de rand( ) y srand( ); Escriba un programa que simule el lanzamiento de un dado. #include <stdio.h> int main() { int x; system("clear"); srand ( time(NULL) ); /*semilla para iniciar el temporizador*/ printf ("Pulsa enter para tirar el dado:.\n"); x=(rand( )%6)+1; printf ("El numero del dado dio:%d.\n",x); return 0; } /*puede que se tenga que incluir la librería stdlib.h*/
Ejemplo No3.Calcule e imprima la suma y el producto de los números nones del 7 al 21. #include <stdio.h> int main( ){ int x,y; x=7; y=0; z=1; while (x<=21) { y=x+y; z=z*x; x+=2; } printf(“LA SUMA DEL 7 AL 21 ES %d \n”,y); printf(“EL PRODUCTO DEL 7 AL 21 ES %d \n”,z); getch( ); return 0; } CONTADORES. Un contador es una variable la cual incrementa su valor o lo decrementa, segun sea el caso, en cantidades constantes. VAR=VAR+CONSTANTE; Ejemplos: x=x+1; x++; ++x;
y=y+100; z=z+500; n=n-1;
b+=100; b=b+100;
USO DE CONTADORES Los contadores en C se inicializan con un valor, para determinar de donde comenzara a contar los incrementos o decrementos. ACUMULADORES Un acumulador es una variable que incrementa o decrementa su valor en cantidades variables. Ejemplos: acum=acum+x; x=x+y; l=l+(a*b);
z=z*(x+y); a=a+b;
Una analogía para el uso de acumuladores seria una caja registradora. Carrito de mandado.
FUNCIONES DE CARACTERES. La función getchar( ); sirve para obtener un caracter del teclado. En el momento que el compilador encuentra la función, detiene el cursor para capturar un caracter. int main( ) { ... getchar( ); .... Ejemplo: Elaborar un programa para determinar el numero de caracteres que se teclearon en un párrafo. #include<stdio.h> int main( ){ char x; x=getchar( ); int cuenta=0; while ((c=getchar( ))!='\n') while( ) { { if(cuenta>10){ printf(“YA SE TECLEARON...”); } cuenta ++; else { cuenta++; } }; } printf(“\nEL TOTAL DE CARACTERES TECLEADOS ES...%d”,cuenta); getch( ); return 0; } EOF = End Of File, indica fin de la cadena. Se representa por el '\n'. Escribir un programa que indique si se han tecleado 10 caracteres o no. #include<stdio.h> int main( ){ char x; int cuenta=0; while ((x=getchar( ))!='\n') { cuenta ++; } if(cuenta==10) { printf(“\nSE ESCRIBIERON POR LO MENOS 10 CARACTERES...%d”,cuenta); } getch( ); return 0; }
Ejercicios.Para contar dígitos del 0 al 9: Función isdigit( ); while ((x=getchar( )) != '\n') { if (isdigit(x)) { digitos++; } } Para contar mayúsculas: Función isupper( ); while ((x=getchar( )) != '\n') { if (isupper(x)) { mayuscula++; } } La función ispunct( ); se utiliza de la misma forma pero su utilización es para determinar si es un signo de puntuación, y la función islower( ); para minúsculas. Práctica: Elaborar un programa que deje capturar un párrafo o enunciado y determine cuantos caracteres tiene, cuantos de esos caracteres son mayúsculas y cuantos minúsculas, cuantos son dígitos, cuantos son signos de puntuación y cuantas vocales y cuantas consonantes existen en el escrito, y finalmente cuantas palabras contiene. (tip: analizar cuantos espacios existen). Para palabras basta con comparar si encuentra '\n' while((x=getchar( ))!='\n') { if(x=='\n' || x==' ' || x=='\t') { espacios++; }
' '
o '\t'
CICLO for ( ) es una estructura de control en la que se puede indicar el número máximo de iteraciones. Está disponible en casi todos los lenguajes de programación imperativos. Este ciclo es uno de los mas usados para repetir una secuencia de instrucciones, sobre todo cuando se conoce la cantidad exacta de veces que se quiere que se ejecute una instrucción simple o compuesta. for( ) significa para... SINTAXIS: for(exp1;exp2;exp3) { inicio bloque de instrucciones }
inicio
Inicio de variable inicial
{ si expresión
Bloque de acciones o instrucciones
Incrementa Variable de control
} no Siguiente instrucción
En donde: exp1: Es el inicio o arranque de la variable de control del ciclo. Ejemplo: for(x=1;exp2;exp3) { Nota exp3 no lleva ( ; ). exp2: Es la expresión que valida el inicio o fin del ciclo, al ser evaluada esta expresión arroja un resultado lógico. Ejemplo: Ejemplo: for(x=1;x<=10;exp3) { exp3: Esta expresión es el incremento de la variable de control del ciclo. Ejemplo: for(x=1;x<=10;x++) {
FUNCION gets( ); Esta función sirve para capturar una cadena de caracteres. gets (arreglo) obtener
string cadena
arreglo de caracteres
Ejemplo: ... char materia[30]; printf(“Nombre de la materia”); gets(materia); scanf(“%s”,&materia); printf(“%s”, materia); GETS.- Esta función nos permite introducir frases enteras, incluyendo espacios. Por el contrario scanf trata el espacio en blanco como un separador de datos. Nota: No conviene mezclar scanf con gets en una misma función. Ejercicio: Solución a la practica del conteo de caracteres. #include<stdio.h> #include<ctype.h> int main( ){ int digitos=0,mayusculas=0,minusculas=0,vocales=0; char car; clrscr( ); printf(“\nINGRESE UN TEXTO Y TERMINARLO CON <ENTER> \n”); while((car=getchar( ))!='\n') { if(isdigit(car)){ digitos++; } if(isupper(car)){ mayusculas++; } if(islower(car)){ minusculas++; } if(car=='a' || car=='A' || car=='e' || car=='E' || car=='i' || car=='I' || car=='o' || car=='O' || car=='u' || car=='U') { vocales++;} printf(“\nEL NUMERO TOTAL DE DIGITOS ES...%d”,digitos); printf(“\nEL NUMERO TOTAL DE MAYUSCULAS ES...%d”,mayusculas); printf(“\nEL NUMERO TOTAL DE MINUSCULAS ES...%d”,minusculas); printf(“\nEL NUMERO TOTAL DE VOCALES ES...%d”,vocales); getch( ); return 0; }
Elaborar el mismo programa anterior de forma estadística, en donde el programa imprima en pantalla una gráfica de barras de forma horizontal, apoyándose del ciclo for para dibujar cada cuadro de la barra y que despliegue el numero de ocurrencias de cada tipo de caracteres. Ejemplo: vocales mayúsculas minúsculas dígitos
***** ******* ** *****
Tip: alt + 220 = imprime un cuadro para este uso
Nota : también se puede escribir while ((c=getchar( ))!=EOF) { .... OTRAS VERSIONES DEL CICLO FOR EN SU SINTAXIS PERMITIDA.
1) for(exp1;exp2;exp3) { bloque de instrucciones }
2) exp1; for(;exp2;exp3) { bloque de instrucciones }
3) exp1; for(;exp2;) { bloque de instrucciones exp3; }
4) for( ; ; ) { bloque de instrucciones }
/*CICLO INFINITO*/
Ejemplo. Ciclo for( ). Elabore un programa que obtenga la suma y el producto de los números pares que se encuentren entre 10 y 20. #include<stdio.h> int main( ){ int producto=1,suma=0,x; clrscr( ); for(x=10;x<=20;x+=2){ producto=producto*x; suma=suma+x; } printf(“\nEL PRODUCTO TOTAL DEL 10 AL 20 ES...%d”,producto); printf(“\nLA SUMATORIA TOTAL DEL 10 AL 20 ES...%d”,suma); getch( ); return 0; } Ejemplo 2. Ciclo for( ). Elabore un programa que calcule una serie de armonías. 1 + 1/2 + 1/3 + 1/4 + ... + 1/Num. #include<stdio.h> int main() { float x,numero,suma=0; system("clear"); printf("INTRODUCE EL NUMERO HASTA EL CUAL DESEAS SUMAR LA SERIE:"); scanf("%f",&numero); for(x=1;x<=numero;x++) { suma=suma+(1/x); printf("1/%.0f",x); if(x<numero){ printf(" + "); } } printf(" = %f\n",suma); printf("\n"); return 0; }
CICLOS ANIDADOS. Los ciclos anidados son aquellos en que un ciclo esta dentro de otro ciclo y este ciclo podría ser que este dentro de otro y así sucesivamente. ciclos while, do_while y for, estos ciclos se pueden anidar uno en otro ya sea el mismo ciclo o uno diferente. Cuando se anida un ciclo dentro de otro siempre se terminan de realizar primero el ciclo que esta más anidado, por ejemplo en caso de que anidáramos dentro de un ciclo do while a un ciclo for, el ciclo for se terminaría primero.
Ejecución del ciclo. ciclo ciclo ciclo ciclo while( ) { while( ) { bloque de instrucciones } }
for( {
) for( ) { bloque de instrucciones }
}
Ejemplo: Elaborar un programa que obtenga las tablas de multiplicar del 1 al 10. #include<stdio.h> int main( ){ int x,y; clrscr( ); for(x=1;x<=10;x++) { for(y=1;y<=10;y++) { printf(“%d * %d = %d”); } printf(“\n”); } getch( ); return 0; Practica. Escribir un programa que pida como dato de entrada las coordenadas de un cuadro, (columna inicial, renglón inicial, columna final y renglón final) y con ello dibuje en pantalla un cuadro lleno de asteriscos, con esas coordenadas.
Practica. Escribir un programa que simule la ejecución de un cronometro en milisegundos, segundos, minutos. #include<stdio.h> int main( ){ int ms=0,seg=0,min=0; clrscr( ); for(min=0;min<=2;min++) { for(seg=0;seg<=59;seg++) { for(ms=0;ms<=99;ms++) { gotoxy(20,20); printf(“%d:%d:%d”,min,seg,ms); } } } getch( ); return 0; }
CICLO ITERATIVO DO-WHILE( ); El ciclo do-while( ) primeramente ejecuta un bloque de instrucciones antes de evaluar la condición de salida. Si la condición de salida es verdadera, entonces continua con el ciclo, si no es verdadera continua con la siguiente instrucción.
inicio
Sintaxis: do{ inicio cuerpo del ciclo fin } while(expresión) ; siguiente instrucción.
Cuerpo del ciclo
incremento
Condición De salida
si
no Siguiente Instrucción Ejemplo: #include<stdio.h> int main( ); { int count=0,total=0; system(“clear”); do{ total+=count; printf(“count=%d, total=%d \n”,count++,total); } while(count<10); return 0; }
NOTA: El ciclo do-while es el único de los ciclos que lleva (;) punto y coma después de la expresión del while( );
En resumen, una instrucción repetitiva do...while permite ejecutar repetidamente (una o más veces) un bloque de instrucciones, mientras que, una determinada condición sea verdadera.
Ejemplo: INGRESO DE UNA PALABRA CLAVE (PASSWORD). Escribir un programa que permita escribir una palabra clave, para el ingreso de una computadora. Solo se permite que la palabra clave se ingrese 3 veces. #include<stdio.h> int main( ) { clrscr( ); int clave; int contador=0; do{ printf("INGRESE SU CLAVE AHORA:.\n"); scanf("%d",&clave); if(clave==12345) { printf(".\nACCESO AL SISTEMA. BIENVENIDO!.\n"); break; } /*ojo la función break; manda al final del ciclo, si no se usa, se puede forzar a que else { el contador sea igual o mayor a 3*/ printf(".\nCLAVE INCORRECTA!.\n"); contador++; } } while (contador<3); printf(".\nGRACIAS!.\n"); return 0; } Ejemplo2: Que hace el siguiente programa? num=1; do{ printf(“%d\n”,num); num++; } while(num<100); ___imprime los números del 1 a l 99__. /*efectuar distintos ejercicios con el uso de do while y ver las diferencias en lo que imprime cada programa, cambiar valores y operadores relacionales). Practica. Se quiere escribir un programa con el uso de do-while que: 1º) Pida por teclado un número (dato entero). 2º) Pregunte al usuario si desea introducir otro o no. 3º) Repita los pasos 1º y 2º, mientras que, el usuario no responda 'n' de (no). 4º) Muestre por pantalla la suma de los números introducidos por el usuario.
ARREGLOS Los arreglos o tablas consisten en un numero, fijo, finito y ordenado de elementos donde todos son datos del mismo tipo y tienen un nombre en común. Variables. X=? cuantos valores a la vez puede almacenar? R=1. Subíndice X1 X2 X3 X4. . . . . XN nombre del arreglo
índices (enteros)
ARR 0
100
1 2
200
3 4
500
5 6
700
7
600
8
En C se inicia con el subíndice 0.
100 componentes o elementos todos son de un mismo tipo.
900 500 300
Longitud = 9.
Nota: El tipo de un arreglo se define en base al tipo de sus componentes o elementos. Declaración de arreglos: float promedio[5]; promedio 0
9.8
1
7.5
2 3
10.0
4
9.3
8.8
Acceso a los elementos o componentes de un arreglo. Nombre del arreglo + indice Ejemplo:
9.3 prom[4]
10.0 prom[2]
error prom[5]
Sintaxis: tipo nombre + dimensión int edades [50]; Ejemplo: Elaborar un programa que permita capturar la temperatura de una semana (una por día) almacenar las temperaturas en un arreglo y obtener su promedio. #include<stdio.h> int main( ){ float temp[7]; float acum=0; int x; float prom; system(“clear”); for(x=0;x<=6;x++) { printf(“\nIngresar la temperatura del dia %d”,x+1); scanf(“%f”,&temp[x]); acum+=temp[x]; } prom=acum/7; printf(“.\nEL PROMEDIO DE TEMPERATURA DE ESA SEMANA=%.1f GRADOS”, prom); return 0; } Ejercicio Practica: Obtener las ventas acumuladas por mes de una empresa. Arreglos (continuación). La longitud de un arreglo esta definida en base a la cantidad de elementos. x 0 1
98 99
'x' 'a' . . . . . 'b' 'm'
char x[100];
El tipo del arreglo esta definido en base a el tipo de sus elementos: M Tipo 9.8 Enteros (int) char
484.3 98.1
Reales float double
482.6 tipo -> float CLASIFICACION DE LOS ARREGLOS. 1) Unidimensionales (vectores) 2) Bidimensionales (matrices) 3) Multidimensionales (poliedros) UNIDIMENSIONALES (VECTORES) 0
BIDIMENSIONALES (matrices) 0
1 2
renglones índice 1
3 4
2
5
3
6 7
dime nsiones
renglon es
0
1
2
3
columnas índice 1 ciclo for( )
Declaración de Arreglos: 1) char vector[11]; 2) int MAT[5][3]; r c 3) float CUBO [3][3][3]; r c d
MULTIDIMENSIONALES
2 ciclos for ( ) anidados
0 1 2 COLUMNAS CUBO (POLIEDROS) Arreglo de 3 dimensiones 3 ciclos anidados.
Ejercicio: Elabore un programa en el que lea y almacene en un arreglo 20 letras o caracteres y cuente la cantidad de m's y f's que fueron introducidas al final. #define MAX 20 #include<stdio.h> int main( ){ char letra[MAX]; int ms=0,fs=0,x; system(“clear”); for(x=0;x<MAX;x++){ printf(“\nINGRESE LA LETRA DESEADA”); scanf(“%c”,&letra[x]); /*También se puede con: letra[x]=getchar( ); */ if(letra[x]=='m' || letra[x]=='M') { ms++; } if(letra[x]=='f' || letra[x]=='F') { fs++; } printf(“\nTOTAL DE M'S ENCONTRADAS: %d”,ms); printf(“\nTOTAL DE F'S ENCONTRADAS: %d”,fs); return 0; } ARREGLOS BIDIMENSIONALES
100
MAT 600
8
200
300
6
300
200
4
400
300
100
Declaración: int MAT[4][3];
/*TIPO MATRIZ = entero*/
Declaración de arreglos locales automáticos. int MAT[4][3]={ {100,600,8}, {200,300,6}, {300,200,4}, {400,300,100} }; en una dimensión se declara: float A[6]={4.2,8.3,2.2,3.3,etc};
Ejemplo: Elaborar un programa para contar los números 300 que existen en el arreglo MAT y mencionar en que renglón y en que columna se encuentran almacenados. #define R 4 #define C 3 int main( ){ int MAT[4][3]={ {100,600,8}, {200,300,6}, {300,200,4}, {400,300,100} }; int r,c,cuenta=0; for(r=0;r<R;r++) { for(c=0;c<C;c++) { corre asi el if: if(MAT[r][c]==300) MAT[0][0]==300 ? no { MAT[0][1]==300 ? no cuenta++; printf(“Un 300 esta almacenado en: r=%d,c=%d”,r,c); MAT[0][2]==300 ? no } MAT[1][0]==300 ? no } MAT[1][1]==300 ? Si, cuenta ++; } printf(“\nLOS NUMEROS 300 ENCONTRADOS EN LA MATRIZ SON: %d”,cuenta); return 0; } Ejemplo 2: Elaborar un programa que calcule e imprima la suma y el promedio de la siguiente matriz. MAT 1.2 3.2 8.1 1.3 1.2
8.4
9.3
3.2
1.3
8.2
3.4
6.2
1.4 1.3 4.5 6.5 #define R 4 #define C 4 int main( ){ float MAT[R][C]={ {1.2,3.2,8.1,1.3},{1.2,8.4,9.3,3.2},{1.3,8.2,3.4,6.2},{1.4,1.3,4.5,6.5} }; int r,c,acum=0; float promedio; for(r=0;r<R;r++) { for(c=0;c<C;c++) { acum+=MAT[r][c]; } } promedio=acum/(R*C); printf(“\nLA SUMATORIA DE LOS ELEMENTOS DE LA MATRIZ ES: %d”,acum); printf(“\nEL PROMEDIO DE LOS ELEMENTOS DE LA MATRIZ ES: %d”,promedio); return 0;} /*analice que operaciones están dentro del ciclo y cuales están fuera del ciclo. */
Ejercicio.-De los siguientes vectores, realice la suma y la resta del vector A y del vector B. A 4.1 5.1 7.8 6.3
+
B 1.0 1.0 1.0 1.0
C =
? ? ? ?
int main( ){ float A[4]={4.1,5.1,7.8,6.3}; float B[4]={1.0,1.0,1.0,1.0}; float C1[4],C2[4]; int x; system(“clear”); for(x=0;x<4;x++){ C1[x]=A[x]+B[x]; C2[x]=A[x]-B[x]; printf(“\n%d + %d = %d”,A[x],B[x],C1[x]); printf(“\n%d - %d = %d”,A[x],B[x],C2[x]); } return 0; } Practica: Escribir un programa en C que almacene en un arreglo 10 cantidades en dolares, las convierta a pesos y las almacene. En otro arreglo imprimir los resultados. Ejemplo.- Elaborar un programa para ordenar un arreglo unidimensional en orden ascendente. #define MAX 10 #include <stdio.h> int main( ){ int A[MAX]={200,300,100,400,700,500,800,600,1000,900}; int ind1,ind2,temp; system(“clear”); for(ind1=0;ind1<MAX-1;ind1++){ for(ind2=ind1+1;ind2<MAX;ind2++){ if(A[ind1]>A[ind2]) { temp=A[ind2]; A[ind2]=A[ind1]; A[ind1]=temp; }}} printf(“\nARREGLO ORDENADO:\n”); for(ind1=0;ind1<MAX;ind1++){ printf(“\nA[%d]=%3d”,ind1,A[ind1]); } getch( ); return 0; } /*Extra: elabore programa juego del submarino*/
FUNCIONES. Rutina o subrutina que realiza una tarea especifica. La utilización de funciones nos permite dividir un programa extenso en pequeños segmentos que realizan tareas concretas. Probablemente, dentro de un mismo programa se realicen las mismas tareas varias veces, lo que se facilita mediante la utilización de funciones. Sin embargo, es probable que ciertas funciones no sean reutilizables, pero al usarlas se mejora la legibilidad del programa. La filosofía en la que se base el diseño de C es el empleo de funciones. Por esta razón, un programa en C contiene al menos una función, la función main. Esta función es particular dado que la ejecución del programa se inicia con las instrucciones contenidas en su interior. Una vez iniciada la ejecución del programa, desde la función main se puede llamar a otras funciones y, posiblemente, desde estas funciones a otras. Otra particularidad de la función main es que se llama directamente desde el sistema operativo y no desde ninguna otra función. De esta manera, un programa en C sólo puede contener una función main. La función printf imprime por la salida estándar los argumentos que le pasamos. Al igual que esta función, existen otras funciones que realizan diversas tareas ya definidas en el estándar ANSI C y que pueden ser utilizadas por el programador. Este tipo de funciones predefinidas son denominadas funciones de biblioteca. Sin embargo, cada programador puede definir sus propias funciones de acuerdo a sus necesidades. Las funciones que define el programador son conocidas como funciones de usuario. Se puede acceder (llamar) a una determinada función desde cualquier parte de un programa. Cuando se llama a una función, se ejecutan las instrucciones que constituyen dicha función. Una vez que se ejecutan las instrucciones de la función, se devuelve el control del programa a la siguiente instrucción (si existe) inmediatamente después de la que provocó la llamada a la función. Cuando se accede a una función desde un determinado punto del programa, se le puede pasar información mediante unos identificadores especiales conocidos como argumentos (también denominados parámetros). Una vez que la función procesa esta información, devuelve un valor mediante la instrucción return. FUNCIONES Sistema system(“clear”); sin(x); sqrt(x); isdigit(c); time( );
Usuario suma_matrices( ); multipl_matrices( ); cambio( ); salir( ); imprimir( ); reporte_articulos( );
Notas importantes: • Un prototipo de función declara ante el programa a la función. • El llamado de una función es la ejecución de dicha función. • Una definición de función es la función misma. • La declaración de una función nombra la misma función y especifica el tipo de dato retornado y sus argumentos recibidos.
Que es una función prototipo? Es aquella que le dice al compilador lo siguiente: • El tipo de la función (entero, flotante, void, etc). • El nombre de la función. • La cantidad y tipo de sus argumentos. La declaración de una función se conoce también como prototipo de la función. Donde se ubica? Fuera de main( ). Generalmente antes de las directivas del compilador (#include, #define). Estructura general de una función. Tipo nombre (nombre y tipo de sus argumentos) { inicio Declaración de variables locales ... } instrucciones } fin de la función. Ejemplos: float suma( ) { int x; x=1; printf(“%d”,x); }
int ciclo(int A[ ], int B[ ] ) { int x; for(x=0;x<10;x++) { printf(“%d %d”, A[x], B[x]); } return; } Ejemplo con el uso de funciones: #include<stdio.h> void A( ); void B( ); void C( ); ... int main( ){ A( ); B( ); C( ); return 0; } void A( ) void C( ) { { } } void B( ) { } El tipo void no retorna ningún valor.
Estructura tomada de libro Mc graw-hill tipo_de_retorno nombre_de_la_función (lista_de_parámetros) } cuerpo_de_la_función return expresión { Antes de empezar a utilizar una función debemos declararla Donde: • tipo_de_retorno: es el tipo del valor devuelto por la función, o, en caso de que la función no devuelva valor alguno, la palabra reservada void. • nombre_de_la_función: es el nombre o identificador asignado a la función. • lista_de_parámetros: es la lista de declaración de los parámetros que son pasados a la función. Éstos se separan por comas. Debemos tener en cuenta que pueden existir funciones que no utilicen parámetros. • Cuerpo_de_la_función: está compuesto por un conjunto de sentencias que llevan a cabo la tarea específica para la cual ha sido creada la función. • return expresión: mediante la palabra reservada return, se devuelve el valor de la función, en este caso representado por expresión. Ejecución de Funciones. Por valor Funciones Por referencia
En C todos los argumentos que se pasan a una función se pasan por valor. En otras palabras, se pasa una copia del valor del argumento y no el argumento en sí (por ello, este procedimiento se conoce en algunas ocasiones como paso por copia). Al pasar una copia del argumento original a la función, cualquier modificación que se realice sobre esta copia no tendrá efecto sobre el argumento original utilizado en la llamada de la función. Se puede considerar un argumento pasado por valor como una variable local de la función a la que se ha pasado, de tal modo que los cambios que se realicen sobre ésta tendrán efecto sólo dentro de la función Sin embargo, en muchas ocasiones lo que queremos es que una función cambie los valores de los argumentos que le pasamos. Para lograrlo se utiliza lo que se conoce como paso de argumentos por referencia. En estos casos, no se pasa una copia del argumento, sino el argumento mismo. Cuando realizamos un paso de argumentos por referencia en C, realmente lo que estamos pasando son direcciones de memoria. a. En otras palabras, lo que le pasamos a la función son las direcciones de memoria de los argumentos. Esta operación se logra mediante la utilización de punteros.
Crear un programa para calcular el precio de un producto basándose en el precio base del mismo y el impuesto aplicable. #include <stdio.h> float precio(float base, float impuesto); /* declaración */ main() } float importe = 2.5; float tasa = 0.07; printf("El precio a pagar es: %.2f\n", precio(importe, tasa)); return 0; { float precio(float base, float impuesto) /* definición */ } float calculo; calculo = base + (base * impuesto); return calculo; { El ejemplo anterior se compone de dos funciones, la función requerida main y la función creada por el usuario precio, que calcula el precio de un producto tomando como parámetros su precio base y el impuesto aplicable. La función precio calcula el precio de un producto sumándole el impuesto correspondiente al precio base y devuelve el valor calculado mediante la sentencia return. El siguiente programa calcula el cubo de los números del 1 al 5 utilizando una función definida por el usuario. #include <stdio.h> int cubo(int base); main() } int numero; for(numero=1; numero<=5; numero++){ printf("El cubo del número %d es %d\n", numero, cubo(numero)); { return 0; { int cubo(int base) } int potencia; potencia = base * base * base; return potencia; { La salida es: El cubo del número 1 es 1 El cubo del número 2 es 8 El cubo del número 3 es 27 El cubo del número 4 es 64 El cubo del número 5 es 125
Ejemplo para variables locales. #include <stdio.h> void imprimeValor(); main() } int contador = 0; contador++; printf("El valor de contador es: %d\n", contador); imprimeValor(); printf("Ahora el valor de contador es: %d\n", contador); return 0; { void imprimeValor() } int contador = 5; printf("El valor de contador es: %d\n", contador); { La salida es: El valor de contador es: 1 El valor de contador es: 5 Ahora el valor de contador es: 1 Ejemplo para variables globales. #include <stdio.h> void unaFuncion(); void otraFuncion(); int variable; main() } variable = 9; printf("El valor de variable es: %d\n", variable); unaFuncion(); otraFuncion(); printf("Ahora el valor de variable es: %d\n", variable); return 0; { void unaFuncion() } printf("En la funci贸n unaFuncion, variable es: %d\n", variable); { void otraFuncion() } variable++; printf("En la funci贸n otraFuncion, variable es: %d\n",variable); {
Ejemplo: Elaborar un programa que solicite por el teclado un numero entero, llame a una funcion e imprima la cantidad de asteriscos de acuerdo al numero n ingresado. #include<stdio.h> void imprimirA(int); int main( ){ int N; system (“clear”); printf(“\nINGRESE UN NUMERO”); scanf(“%d”,&N); imprimirA(N); /*aquí se manda el valor*/ return 0; } void imprimirA(int N); /*aquí recibe el valor*/ { int x; for(x=1;x<=N;x++) { printf(“*”); } } Ejemplo.- Escribir un programa con una función que reciba como parámetros 2 arreglos de enteros, los sume y muestre el arreglo resultante. #include<stdio.h> void sumaV(int [ ], int[ ]); int main( ) { int A[3]={100,200,300}; int B[3]={100,200,100}; sumaV(A,B); /*se envían 2 argumentos*/ return 0; } void sumaV(int A[3],int B[3]) /*se reciben 2 argumentos*/ { int C[3]; int ind; for(ind=0;ind<3;ind++) { C[ind]=A[ind]+B[ind]; printf(“%d + %d = %d\n”,A[ind],B[ind],C[ind]); } }
Ejemplo. Elaborar un programa que sume 2 matrices por medio de una función con paso de parámetros. 2 2
4 4
+
2 2
A
2 2 B
#define R 2 #define C 2 void suma_mat(int[ ][ ], int[ ][ ]); int main( ){ int A[R][C]={{2,4},{2,4}}; int B[R][C]={{2,2},{2,2}}; suma_mat(A,B); return 0; } void suma_mat(int A[R][C], int B[R][C]) { int r,c; int T[R][C]; for(r=0;r<R;r++){ for(c=0;c<C;c++) { T[r][c]=A[r][c]+B[r][c]; } } for(r=0;r<R;r++){ for(c=0;c<C;c++) { printf(“%d”, T[r][c]); } printf(“\n”); } }
=
4 4
6 6 T
Escribir un programa que llame a una función pase como parámetro la siguiente tabla y determine e imprima su promedio. 6.1 4.3 6.3
8.3 8.3 6.5
4.2 8.4 1.0
#define R 3 #define C 3 void promedio(float[ ][ ]); int main( ){ float A[R][C]={{6.1,8.3,4.2},{4.3,8.3,8.4},{6.3,6.5,1.0}}; system(“clear”); promedio(A); return 0; } void promedio(float A[R][C]) { int r,c; float acum=0, prom; for(r=0;r<R;r++){ for(c=0;c<C;c++) { acum+=A[r][c]; } } prom=acum/R*C; printf(“Promedio de la tabla=%f”, prom); } Procedimiento para multiplicación de matrices: for(r=0;r<R;r++){ for(c=0;c<C;c++) { T[r][c]=0; for(i=0;i<c;i++){ T[r][c]=T[r][c]+(A[r][i]*B[i][c]); } } } /*agregar lo demás del programa*/
Practica Ventas.- Elabore un programa que por medio de funciones para que determine las ventas de los artículos por cada uno de los vendedores, por día, promedio de ventas de la semana. VENTAS DIAS 0 1 2 100 400 600 = ? vendedores 200 300 200 = ? 100 200 300 = ? ? ? ? #define R 3 #define C 3 #include <stdio.h> void prom(int [ ][ ]); void v_articulos(int [ ][ ]); int main( ){ int VENTAS[R][C]={{100,400,600},{200,300,200},{100,200,300}}; prim(VENTAS); v_articulos(VENTAS); return 0; } void prom(int VENTAS[R][C]) { int r,c,acum=0; float prom; for(r=0;r<R;r++){ for(c=0;c<C;c++) { acum+=VENTAS[R][C]; } } prom=acum/(R*C); printf(“\nEL PROMEDIO DE LAS VENTAS EN LA SEMANA FUE: %.2f”,prom); } void v_articulos(int VENTAS[R][C]) { int av1=0,av2=0,av3=0; int col; for(col=0;col<C;col++) { av1+=VENTAS[0][col]; av2+=VENTAS[1][col]; av3+=VENTAS[2][col]; } printf(“\nVENDEDOR 1=%d”, av1); printf(“\nVENDEDOR 2=%d”, av2); printf(“\nVENDEDOR 3=%d”, av3); }
RECURSIVIDAD. FUNCION RECURSIVA. Las funciones en C pueden ser recursivas, en otras palabras, pueden llamarse a sí mismas directa o indirectamente. La recursividad directa es el proceso mediante el que una función se llama a sí misma desde el propio cuerpo de la función, mientras que la recursividad indirecta implica más de una función. Un proceso recursivo tiene que tener una condición de finalización, ya que de lo contrario podría continuar infinitamente. Un ejemplo típico de aplicación de la recursividad es el cálculo del factorial de un número entero. Recordemos que el factorial de un número entero (n!) se calcula de la siguiente manera: n! = n * (n-1) * (n-2) * ... * 2 * 1 Ejemplo: long factorial(int numero) } if(numero == 1) return 1; return (numero * factorial(numero-1)); { main( ) { int num; printf(“\nIntroduce un numero:”); scanf(“%d”, &num); printf(“Su factorial es %ld \n”, fact(num)); }
ESTRUCTURAS. Una estructura es una colección de datos de diferentes tipos. Una estructura de datos es una manera de almacenar y organizar datos para facilitar el acceso y modificaciones. Una estructura es un grupo de variables las cuales pueden ser de diferentes tipos sostenidas o mantenidas juntas en una sola unidad. La unidad es la estructura. Registros. Struct -> tipo de dato estructura.
. campos
-> operador punto, sirve para conectar el dato de tipo estructura con un elemento o miembro de ella. Por ejemplo: persona.nombre = “JUAN”;
Forma general de las estructuras: struct persona{ char nombre[50]; ... } persona1;
struct xx{ ... } yy,zz; /*indefinición*/
Ejemplo. Elaborar un programa que almacene 2 registros con la siguiente estructura: Titulo 40 caracteres. Autor 50 caracteres. Editorial 30 caracteres. Edición entero. Costo flotante. #include<stdio.h> #include<stdlib.h> int main( ){ struct libros{ char titulo[40]; char autor[50]; char editorial[30]; int edicion; float costo; } libro1,libro2; char aux[20]; printf(“DATOS DEL LIBRO 1:\n”); printf(“TITULO DEL LIBRO:\n”); gets(libro1.titulo); printf(“AUTOR:\n”); gets(libro1.autor); printf(“EDITORIAL:\n”); gets(libro1.editorial); printf(“EDICION DEL LIBRO:\n”); gets(aux); libro1.edicion=atoi(aux);
printf(“COSTO DEL LIBRO:\n”); gets(aux); libro1.costo=atof(aux); printf(“DATOS DEL LIBRO 2:\n”); printf(“TITULO DEL LIBRO:\n”); gets(libro2.titulo); printf(“AUTOR:\n”); gets(libro2.autor); printf(“EDITORIAL:\n”); gets(libro2.editorial); printf(“EDICION DEL LIBRO:\n”); gets(aux); libro2.edicion=atoi(aux); printf(“COSTO DEL LIBRO:\n”); gets(aux); libro2.costo=atof(aux); /*falta impresion de datos*/ getch( ); return 0; }
ARREGLOS DE ESTRUCTURAS. Son un conjunto finito de registros agrupados en un arreglo. A struct A { int x; float y; } B[10];
0 1 2 3 renglones 4 5 6 7 8 9 10
x 3 2 2 3 4 6 8 2 1 0 0
y 9.1 3.2 1.0 4.2 2.4 6.6 3.3 2.1 1.2 1.2 1.2
B
for(c=0;c<10;c++) { scanf(“%d”,&B[c].x); scanf(“%d”,&B[c].y); } NOMBRES Z nom edad 0 1 2 3 4
struct NOMBRES{ char nom[50]; int edad; char aux[10]; } Z[5]; for(c=0;c<5;c++) { gets(Z[c].nombre); gets(aux); Z[c].edad=atoi(aux); }
En C/C++ se forma una estructura utilizando la palabra reservada struct, seguida por un campo etiqueta opcional, y luego una lista de miembros dentro de la estructura. La etiqueta opcional se utiliza para crear otras variables del tipo particular de la estructura.
Ejemplo: Elaborar un programa con arreglos de estructuras que almacene la información básica de 10 personas amigos y al final imprima toda la información de cada uno de ellos. #include<stdio.h> int main( ){ struct personas{ char nombre[50]; char direccion[40]; int edad; } amigos[10]; int c; char aux[20]; for(c=0;c<10;c++) { printf(“\nNOMBRE:”); gets(amigos[c].nombre); printf(“\nDIRECCION:”); gets(amigos[c].direccion); printf(“\nEDAD:”); gets(aux); amigos[c].edad=atoi(aux); } system(“clear”); for(c=0;c<10;c++) { printf(“\nNOMBRE No. %d INGRESADO: %s”,c+1,amigos[c].nombre); printf(“\nDIRECCION No. %d INGRESADA: %s”,c+1,amigos[c].direccion); printf(“\nEDAD No. %d INGRESADA: %s”,c+1,amigos[c].edad); printf(“\n”); } return 0; } Analogía para estructuras y apuntadores: ¿Qué son y para qué sirven las estructuras de datos? En lo que se refiere a la resolución de problemas, muchas veces para plantear el problema imaginamos objetos y acciones que se relacionan entre si. Por ejemplo, un mesero tiene platos de colores apilados; de vez en cuando el que lava los platos coloca un plato recién lavado sobre la pila de platos; y en otras ocasiones el mesero toma el plato que esta hasta arriba y sirve ahí la comida que ha sido preparada por el cocinero para posteriormente llevarla a su destino. Si sabemos de qué color es la pila inicial de platos, y en qué momentos el que lava los platos colocó platos sobre la pila(y claro, también sabemos el color de estos), y en qué momentos el mesero retiró el plato que se encontraba hasta arriba; podemos saber de qué color será el plato que le toca a cada cliente. Una manera de saberlo podría ser, hacer una representación dramática de los hechos; pero esto no es necesario, ya que también podríamos tomar un lápiz y un papel, y escribir una lista de los colores de los platos, posteriormente, ir escribiendo los colores de los platos que se pusieron en la pila al final de la lista, y borrar el ultimo color de la lista cada que un plato se retire. No se necesita ser un gran matemático para pensar en hacer eso, sin embargo, en el momento de querer implementar un programa en C que lo reproduzca, nos encontramos con que no tenemos ninguna lista donde se coloquen y se quiten cosas del final, tenemos solamente arreglos, variables, estructuras, apuntadores, etc. Claro que podemos simular esta lista con las herramientas que nos proporciona C, así pues, los objetos(como la pila de platos) ligados a operaciones(como poner un nuevo plato o quitar un plato) que modifican al objeto son llamados estructuras de datos. Una definición sencilla de estructura de datos: unión de un conjunto de datos y funciones que modifican dicho conjunto.
APUNTADORES. Un apuntador prevé el camino de acceso a una variable (o a otro tipo de datos como lo son los arreglos) sin referirse directamente a la variable. El mecanismo utilizado para esto es la dirección de la variable. C usa apuntadores explícitamente con: • Arreglos • Estructuras • Funciones La dirección actúa como un intermediario entre el valor de la variable y el programa. Analogía; Un espía. Operadores: & -> operador de dirección. (*) -> operador de indirección.
DIR DIR DIR DIR
DATO
DATO
DIR
Por que el uso de apuntadores? 1) Se puede retornar mas de un valor de una función. 2) El paso de parámetros de arreglos y cadenas es mas efectivo. 3) La manipulación de arreglos es mas efectiva y versátil. 4) La creación de complejas estructuras de datos (listas encadenadas, arboles binarios, pilas, etc) es mas atractiva con el uso de apuntadores. Declaración de un tipo apuntador. Tipo de dato *variable Ejemplo: int *A; float *B, *n; char *z; Un apuntador es una variable que contiene la dirección en memoria de otra variable. Se pueden tener apuntadores a cualquier tipo de variable. El operador unario o monádico & devuelve la dirección de memoria de una variable. El operador de indirección o dereferencia * devuelve el “contenido de un objeto apuntado por un apuntador”.
Ejemplo: 1310 --------- x 1312 y ----------
1310 1312
Main( ){ int x,y; gets(&x,&y); ... }
px py
Aquí las direcciones son pasadas a la función y almacenadas en memoria.
void gets(int *px,int *py) { - }
Función puts: Esta función escribe la cadena apuntador por cadena. Imprime una cadena de caracteres, se puede usar puts o printf. Ejemplo: puts(cadena); o bien printf(“%s”, cadena); . La diferencia entre puts y printf para cadenas de caracteres es que la función puts cambia de linea por si sola y printf no. La ventaja de printf es que con ella si se pueden desplegar varias cadenas. Ejemplo: main( ) { int x,y; gets(&x,&y); } 1310 1312
----3-------5----
void puts (int *px,int *py) { *px=3; *py=5; } 1310 1312
Aquí los valores son pasados indirectamente a main( ) y almacenados en memoria. La declaración de un * indica que es un tipo apuntador o puntero y se dice apunta a...
ARREGLOS CON APUNTADORES. Ejemplo: int main( ){ int nom[5]={92,81,70,69,58}; int c; for(c=0;c<5;c++){ printf(“\n%d”, num[c]); } return 0; }
/*Esto es lo que habíamos estado acostumbrados a hacer*/ /*ver como corre*/.
Con Apuntadores: Se tiene la siguiente formula: *(nombre del arreglo+índice)=nombre del arreglo[índice]. Ejemplo: for(c=0;c<5;c++) { printf(“\n%d”, *(num+c)); } /*Corre exactamente igual pero es mas eficiente en modo de compilador*/. Con apuntadores se pueden hacer cosas como: char *p=”HOLA....”; ++(*p); while (*p)... putchar(*p++);
APUNTADORES CON ESTRUCTURAS Operador -> nuevo operador para estructuras.
( - ) + ( > )= -> para el operador en el teclado.
Partamos de un ejemplo: #include<stdio.h> int main( ){ struct xx { int num1; char ch1; }xx1,*ptr; ptr=&xx1; ptr -> num1=303; ptr -> ch1='Q'; printf(“ptr -> num1=%d\n”,ptr->num1); printf(“ptr -> ch1=%c\n”,ptr->ch1); return 0; } Donde *ptr apunta a la estructura xx y ptr=&xx proporciona la dirección donde se encuentran los miembros de la estructura. El operador punto ( . ) conecta una estructura con un miembro de ella y el operador (->) conecta un apuntador con un miembro de la estructura. FUNCION SIZEOF( ); La función sizeof es utilizada para obtener el tamaño en bytes de un tipo de valor como puede ser (int, float, char, double, short int…).por ejemplo: sizefo( int ); pero se puede utilizar pasándole de parámetro una variable declarada para allar su valor en bytes por ejemplo: int variable; sizeof( variable ). Sintaxis: sizeof(tipo_dato); Practica.-Elaborar un programa donde se utilice la declaración de los diferentes tipos de datos y una estructura de datos con diferentes tipos de datos. Utilizar la función sizeof( ); para determinar el tamaño en bytes de cada uno de los tipos de datos. Por ejemplo: printf(“\nEl tamano de shor int es de: %d bytes\n”, sizeof(short)); ...sizeof(int)); ...sizeof(long)); Este valor en bytes es lo que se reserva en memoria para almacenar el valor del tipo de dato y una dirección de memoria en donde esos 4 bytes han sido reservados.
Ejemplos de programas con apuntadores: #include<stdio.h> #include<string.h> int main( ){ int j,k; int *ptr; j=1; k=2; ptr=&k; 1) printf(“j tiene el valor de:%d, y esta alojado en:%p\n”,j,&j); 2) printf(“K tiene el valor de:%d, y esta alojado en:%p\n”,k,&k); 3) printf(“ptr tiene el valor de:%p, y esta alojado en:%p\n”,ptr,&ptr); 4) printf(“El valor del entero al que apunta es:%d\n”*ptr); return 0; } Explicación: k=2; hay dos valores asociados con el objeto k, uno es el valor del entero alojado (2) y el otro el valor de la localidad de memoria donde se ha guardado, (dirección de k). En j,k; k=2; j=7 --> linea 1 k=j --> linea 2 El compilador interpreta a la j en la linea 1 como dirección de la variable j y crea código para copiar el valor 7 a esa dirección. En la linea 2, la j es interpretada como su rvalue (esta del lado derecho del = ). Por lo que j hace referencia al valor alojado en la dirección de memoria asignado a j, 7 en este caso, así que 7 es copiado a la dirección designada por el lvalue de k. En int *ptr, ptr es el nombre de la variable (como k era el nombre de la variable de tipo entero). El * informa al compilador que lo que se quiere es una variable apuntador, es decir, que se reservan los bytes para alojar una dirección en memoria. El int quiere decir que usara una variable apuntador para almacenar la dirección de un dato de tipo entero. (Apunta a un entero). Si la declaración se hace fuera de cualquier función se inicializa automáticamente a 0. ptr no tiene un valor asignado, esto es no hemos almacenado una dirección aun. Es inicializado a un valor garantizando que no apunte a una variable o a una función. Si se hace asi, se define como apuntador nulo (null). Si se quiere almacenar en ptr la dirección de nuestra variable entera k. Para hacerlo hacemos uso del operador unario & y se escribe; ptr=&k; & obtiene la dirección de k aun cuando k esta en el lado derecho del operador = y copia esa dirección en el contenido del apuntador ptr. Ahora ptr es un puntero a k. El operador de indirección se usa (*) *ptr=7; Esto copiara el 7 a la dirección a la que apunta ptr. Asi que como ptr apunta a k o contiene la dirección de k, la instrucción de arriba asignara a k el valor de 7. Esto es cuando se usa el (*), se hace referencia al valor al que ptr esta apuntando, no el valor del apuntador en si. De forma similar se puede usar también printf(“%d\n”,*ptr); este imprime el valor entero alojado en la dirección a donde apunta ptr.
#include<stdio.h> #include<string.h> int main( ){ char cadena[30], *alla, primera, segunda; int *pt, lista[100],indice; strcpy(cadena, “Esta es una cadena de texto”); primera=cadena[0]; segunda=*cadena; printf(“La primera salida es %c %c\n”, primera, segunda); primera=cadena[8]; segunda=*(cadena+8); printf(“La segunda es: %c %c\n”primera, segunda); alla=cadena+10; printf(“La tercera salida es: %c\n”, cadena[10]); printf(“La cuarta salida es: %c\n”, *alla); for(indice=0;indice<100;indice++){ lista[indice]=indice+100; pt=lista+27; printf(“La quinta salida es: %d\n”, lista[27]); printf(“La sexta salida es: %d\n”, *pt); return 0; } /*Analizar que es lo que hace el programa*/ Otro ejemplo: #include<stdio.h> #include<....> void main( ){ char c; char *pc; pc=&c; for(c='a';c<='z';c++) { printf(“%c “,*pc); } getch( ); return 0; }
Apuntadores a apuntadores Un apuntador a un apuntador es una forma de direccionamiento indirecto múltiple, o una cadena de apuntadores. En un apuntador a apuntador el direccionamiento es la siguiente forma: El primer apuntador contiene la dirección del segundo apuntador. El segundo apuntador apunta a la variable que contiene el valor deseado.
ARCHIVOS DE DISCO.
Nombre del archivo Programa en lectura,escritura,etc SISTEMA C OPERATIVO
Apuntador a un archivo. ID del archivo
Memoria secundaria DISCO “Permanente y flexible”
Que es un archivo? Es una coleccion de bytes que tienen un nombre en comun. Un programa en lenguaje C puede leer y escribir archivos de diferentes maneras. Operacion de un archivo. 1) Se declara una variable de tipo apuntador a archivo. Ejemplo: FILE *fptr; (variable) /*SE ESCRIBE FILE EN MAYUSCULAS*/ apuntador al archivo. Tipo de dato archivo. 2) Se abre un archivo con un formato especifico. Ejemplo: fptr=fopen(“Nombre del archivo”,”MODO”);
apuntador al archivo
El modo puede ser: w- escritura, r-lectura, a-agregar rt-escribir y leer pref leer wt-escribir y leer pref escribir. A+ apend, rb binario, r+, etc palabra reservada para abrir el archivo
3) Cerrar un archivo, se escribe fclose y entre paréntesis el apuntador al archivo. fclose(ftpr apuntador);
palabra reservada para cerrar el archivo.
CATEGORIAS FUNCIONES DE DISCO.
fread( ) fwrite( )
fscanf( ) fprintf( )
fgets( ) fputs( )
getc( ) putc( )
read( ) write( )
Ejemplo: #include<stdio.h> int main( ){ FILE *fptr; char ch; system(“clear”); fptr=fopen(“text.txt,”w”); while((ch=getchar( ))!='\n') { putc(ch,fptr); /*grabar al archivo caracteres*/ } fclose(fptr); return 0; } #include<stdio.h> int main( ){ FILE *fptr; int ch; if((fptr=fopen(“text.txt”,”r”))==NULL) { printf(“\nNO PUEDE ABRIR EL ARCHIVO NO EXISTE”); exit( ); } /*obtener caracteres grabados en disco*/ while((ch=getc(fptr))!=EOF) { printf(“%c”,ch); fclose(fptr); return 0; }