introducion a la programacion

MODULO

CURSO INTRODUCCION A LA PROGRAMACION

IVAN ARTURO LOPEZ ORTIZ [email protected]

[email protected]

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD

FACULTAD DE CIENCIAS BÁSICAS E INGENIERÍA

PROGRAMA INGENIERIA DE SISTEMAS BOGOTÁ D.C., 2005

PROTOCOLO ACADEMICO Y GUÍA DIDÁCTICA CURSO: ALGORITMOS @CopyRigth Universidad Nacional Abierta y a Distancia ISBN 2005 Centro Nacional de Medios para el Aprendizaje

PROTOCOLO ACADEMICO Y GUÍA DIDÁCTICA _____________________________ 6 1.-FICHA TECNICA ________________________________________________ 9 INTRODUCCION __________________________________________________ 11

1.0 Primera Unidad______________________________________________ 1

1.2 INTENCIONALIDADES FORMATIVAS: __________________________________ 1 1.3.1 EDITOR LENGUAJE C++ ________________________________________ 3 1.3.2 ESTRUCTURA GENERAL DE UN PROGRAMA: _________________________ 4 1.3.3 DEPURACIÓN DE PROGRAMAS ___________________________________ 4 EL PROCESO DE DEPURACIÓN _______________________________________ 4 Lectura #1 Programar Con Estilo ____________________________________ 5 1.4 FUNCIONES _________________________________________________ 10 1.4.1 PROTOTIPOS _______________________________________________ 11 1.4.1.1 La Definición De Una Función _______________________________ 12 1.4.1.2 Paso De Parámetros Por Valor: ______________________________ 12 1.4.1.3 Paso De Parámetros Por Referencia: _________________________ 15 1.4.2 VARIABLES LOCALES Y GLOBALES _______________________________ 18 1.4.3 RECURSIVIDAD______________________________________________ 20 1.5 PUNTEROS: _________________________________________________ 21

2.0 Segunda Unidad ___________________________________________ 26

1.2 INTENCIONALIDADES FORMATIVAS: _________________________________ 26 UNIDADES DIDÁCTICAS:____________________________________________ 27 2.1 ARREGLOS UNIDIMENSIONALES:___________________________________ 28 2.2 ARREGLO DE CARACTERES Y CADENAS _____________________________ 34

Librería String: Librería Estándar Del Ansi C, Entre Sus Principales Funciones Están: ________________________________________________________ 36

Librería Ctype Ansi C ____________________________________________ 36

2.3 ORDENACIÓN Y BÚSQUEDA _____________________________________ 42 2.3.1 BÚSQUEDA: ________________________________________________ 42 2.3.1.1búsqueda Lineal __________________________________________ 42 2.3.1.2 Busqueda Binaria: ________________________________________ 44 2.3.1.3 Busqueda De Hash . ______________________________________ 46 2.3.2 ORDENAMIENTO: ____________________________________________ 47 2.3.2.1 Ordenación Mediante El Algoritmo Burbuja:_____________________ 47 2.3.2.2 Ordenamiento Por Inserción_________________________________ 50 2.3.2.3 Ordenamiento Shell :______________________________________ 53 2.3.2.4 Ordenación Rápida (Quicksort) : _____________________________ 56 3.3 MATRICES O ARREGLOS BIDIMENSIONALES:__________________________ 65

3.0 Unidad Número 3 ___________________________________________ 70

3.1 ESTRUCTURAS Y ARCHIVOS______________________________________ 70 1.2 INTENCIONALIDADES FORMATIVAS: _________________________________ 70 3.1.1 ESTRUCTURAS: _____________________________________________ 70 3.2.1 ARCHIVOS O FICHEROS:_______________________________________ 74 3.2.1.1operaciones Con Archivos___________________________________ 77 3.2.1.2 Archivos Tipo Texto _______________________________________ 78 3.2.1.2 Archivos De Acceso Directo_________________________________ 86

Bibliografía ____________________________________________________ 93

Sitios Web ____________________________________________________ 93

Anexos _______________________________________________________ 95

ANEXO TIPOS DE DATOS___________________________________________ 96 ANEXO INDICE DE FUNCIONES _______________________________________ 99 ANEXO ERRORES COMUNES DE PROGRAMACIÓN ________________________ 103

1.-FICHA TECNICA

NOMBRE DEL CURSO ALGORITMOS.

PALABRAS CLAVE

Computadora, Hardware, Software, Informática, Código binario, Periféricos, Memoria, Programación de computadoras, programador, Programación estructurada, Lenguaje de programación, Interprete, Compilador, Variable, Constante, Diagramas de flujo, Algoritmos, Toma de decisión, Ciclos, Funciones, estructuras, arreglos, cadenas, ficheros, ordenamiento, búsqueda

INSTITUCION UNIVERSIDAD NACIONAL ABIERTA Y A

DISTANCIA UNAD

CIUDAD SANTA FE DE BOGOTÁ AUTOR DEL

PROTOCOLO ACADEMICO

IVAN ARTURO LOPEZ ORTIZ [email protected] [email protected]

AÑO 2005 UNIDAD ACADEMICA FACULTAD DE CIENCIAS BASICAS E INGENIERIA

CAMPO DE FORMACION PROFESIONAL

AREA DE CONOCIMIENTO INGENIERIA DE SISTEMAS Y AFINES

CREDITOS ACADEMICOS TRES (3)

TIPO DE CURSO TEORICO PRÁCTICO DESTINATARIOS Estudiantes de diversos programas de la UNAD,

COMPETENCIA GENERAL DE APRENDIZAJE

El estudiante se inicia en los fundamentos esenciales de las técnicas y destrezas del diseño, análisis y

construcción de algoritmos y programas informáticos METODOLOGIA DE

OFERTA A DISTANCIA

FORMATO DE CIRCULACION

Documentos impresos en papel con apoyo en Web; CD-ROM.

DENOMINACION DE LAS UNIDADES

DIDACTICAS

1. Conceptos, antecedentes y desarrollo de algoritmos

2. Estructura general de un algoritmo 3. Herramienta de programación

PLANIFICACIÓN DE LAS UNIDADES DIDÁCTICAS. Unidades didácticas, capítulos, temas, secciones, fragmentos

Unidades Didácticas capítulos temas Secciones

Análisis y diseño Estructuración Abstracción de datos Documentación Control de versiones

• Generalidades

• Editor de C++ • Estructura General

de un Programa • Depuración de

programas

• Estructura de una

función • Prototipos • Llamados de función • Funciones

incorporadas • Funciones propias

Declaración Paso de parámetros por Valor

• Parámetros • Variables locales y

globales

Parámetros por valor Parámetros por prototipo

• Recursividad

Funciones • Funciones

• Biblioteca de funciones

• Funciones de carácter • Funciones numéricas • Funciones de fecha y

hora • Otras funciones

• Introducción a la programación en C o C++

• Punteros

• Direcciones de referencia

• Conceptos de punteros y utilización

• Arreglos unidimensionales • Declaración

• Arreglos de caracteres y cadenas • Funciones

• Ordenación Búsqueda Tipos de algoritmos Arreglos

• Arreglos bidimensionales • Declaración

• Declaración de una estructura

• Estructuras anidadas

Estructuras y Archivos

• Archivos de Entrada y salida

• Archivos tipo texto • Archivos binarios • Acceso aleatoria a

archivos

Funciones E/S

INTRODUCCION El curso de introducción a la programación es un curso que cobra vital importancia y al cual se le puede sacar el máximo provecho, puesto que los participantes tienen conocimientos previos fuertes, que vienen del curso inmediatamente anterior (algoritmos), y sobretodo de su última unidad donde se inicia el trabajo con un lenguaje de programación especifico, en este modulo se incluirá un pequeño apartado al retomar conceptos básicos del lenguaje de programación , de su compiladores, sobretodo de su editor, algunas lecturas que permiten conceptualizar la forma de depurar programas, se reforzara los conceptos sobre funciones, complementándolas con trabajo de recursividad, y a pesar de que en algoritmos se trabaja la parte de funciones es bueno prestarle mucho interés, ya que C++ es un lenguaje que se trabaja todo bajo funciones, luego continuamos con un trabajo importante referido a punteros, la razón es que cuando hablamos de funciones, estructuras, archivos, los punteros cobran vital importancia en el funcionamiento adecuado de estos ítems. En una segunda unidad nos afrentamos a las estructuras estáticas y le dedicamos todo un capitulo a este tema y consideró que no es suficiente para abordar todos los apartados, es aquí donde se ve la necesidad de que el estudiante se apropie de los temas e investigue más por su cuenta, aproveche los recurso de biblioteca y las consultas de Internet para ampliar aun más los conceptos, se trabaja también y por tratarse de vectores, las cadenas de caracteres. Por ultimo es importante que los datos no se queden únicamente en la memoria del computador, sino que sean escritos en un dispositivo de almacenamiento para que puedan recuperarse en cualquier momento. Este tema es un poco complejo se pide a los participantes que no solo se queden con los ejercicios propuestos, sino que traten de mirar un poco más este tema, es uno de los más apasionantes, pues es la base abordar los temas que se acercan cuando inicien el trabajo con bases de datos. Para terminar, solo resta decir que este modulo esta construido, con base en una recopilación de ejercicios prácticos que llevara al estudiante a un aprendizaje significativo, complementado con teoría y una amplia referencia bibliografica y direcciones web. Nuevamente reiterearles la invitación a que consulten diversidad de textos que existen con referencia a los temas que se trabajan en este modulo.

1

1.0 PRIMERA UNIDAD La primera unidad de una u otra manera se trata de un pequeño repaso sobre la programación de computadoras, asiendo especial énfasis en la programación utilizando un lenguaje especifico, como lo es C++. Es importante que los estudiantes retomen el modulo de algoritmos, para recordar algunos de los conceptos olvidados, lo mismo que bibliografía referente al tema. Esta primera unidad comprende una pequeña inducción al editor del lenguaje que se utilizara a lo largo del modulo, se prestara primordial interés al tema de las funciones tratado al final del ultimo capitulo de algoritmos, pero complementándolo con temas nuevos como son las funciones recursivas. Igualmente están implícitas diferentes estrategias de pensamiento de orden superior que el estudiante irá afianzado gracias al apoyo permanente del tutor, quien es el mediador del proceso de aprendizaje. A lo largo de esta unidad se presentan una serie de ejercicios que le permiten al estudiante verificar la evolución de su aprendizaje. 1.2 intencionalidades formativas: Afianzar conocimientos referentes a la programación de computadoras, con un lenguaje especifico Propósitos de la unidad

• Realizar recuento de las principales características de la programación de computadoras

• Dominar de manera general el entorno de programación con el compilador C++

• Fortalecer los temas de funciones Objetivos de la unidad

• Conocer la funcionalidad del editor del compilador utilizado aquí • Motivar a descubrir que otras funciones tiene el editor del lenguaje • Determinar las técnicas de programación, utilizando C++ como lenguaje

de base Competencias de la unidad: • El estudiante domina los conceptos previos necesarios para el desarrollo de

programas en C++ • El estudiante reconoce el funcionamiento general del editor de C++ • El estudiante aplica las funciones como herramienta fundamental en la

modularizacion de los programas

2

Metas de aprendizaje • El estudiante es capaz de desarrollar programas mediante la utilización de

funciones UNIDADES DIDÁCTICAS: PALABRAS CLAVES: Copilador Editor Funciones Recursividad /*******************************************

3

1.3.1 Editor lenguaje C++

1.- procesos de apertura cierre grabado…. 2.- Procesos de edición Copiar, cortar, pegar…. 3.-realizar búsquedas por diferentes criterios en un texto de programa 4.-opciones para correr los programas 5.-opciones para compilar los programas, una de las más importantes 6.-permite tener diversidad de parámetros para depurar programas 7.-opciones necesarias para crear proyectos desde cero 8.-permite configurar todo el entorno e inclusive opciones de trabajo en modo grafico 9.-cada programa se puede trabajar en ventanas independientes 10.-importante toda una ayuda de comando, funciones con ejemplos 11.-barra de menús 12.-espacio para escribir los programas, el editor propiamente dicho 13.-espacio donde aparecen o se configuran diversidad de ventas de apoyo al programa 14.-barra de ayudas y accesos rápidos 15.-nombre que toman los archivos

1 2 3 4 5 6 7 8 910

11

12

13

14

15

4

1.3.2 Estructura general de un programa: Un programa en c++ esta constituido básicamente por: directivas del pre-procesador: [declaración de variables globales] [prototipos de funciones] función main [definiciones de funciones]

• Directivas del Pre-procesador: en este se encuentra Los archivos de cabecera nos permiten indicarle al compilador que pretendemos hacer uso de las funcionalidades que nos proporcionan unas ciertas bibliotecas (en este caso predefinidas). En este caso concreto queremos emplear la biblioteca de entrada/salida iostream para lo cual tenemos que incluir iostream.h. #include <iostream.h>

• Declaración de variables y constantes globales: recordemos que la variables y constantes globales son aquellas que su valor afecta a todo el programa

• Cabecera de funciones: se realiza una descripción a manera de prototipo de las funciones que se crearan más adelante

• Función main(): todo programa escrito en c++ esta constituido por funciones, y la función principal es Main(),

• Definición de funciones: es necesario crear las funciones que se definieron como prototipos para darle viabilidad al programa

• Sentencias: cada una de las ordenes que se le da al compilador por medio del lenguaje para que efectué una acción,

Observación importante: a pesar que se recomienda la utilización de prototipos, C++ permite la utilización directa de las funciones, es decir: puedo en la sección de prototipos, realizar toda la función y la función principal main (), estará al finalizar

1.3.3 Depuración de programas La depuración es determinación de las causas de los errores y corrección de los mismos, en un programa determinado. El proceso de depuración

1. Estudio de los síntomas del error 2. Determinación de las causas 3. Corrección 4. Prueba.

Pueden existir varias causas de error que se pueden agrupar en dos grandes grupos:

5

1.- Errores de sintaxis 2.- Errores lógicos: Para el primer caso, al momento de compilar el programa, este detecta los errores y es posible corregirlos, mirar el el siguiente grafico Mirar anexo referente a errores comunes de programación y algunas buenas prácticas de programación, propuesto por Miguel Á. Toledo Martínez1

Los errores lógicos son más difíciles de corregir, pues el compilador no los detecta, veamos un ejemplo, estamos realizando un programa para el pago de la nomina de 500 empleados y nos equivocamos a la hora de hacer la formula de los descuentos, en ves de realizar la resta hacemos una suma, como se puede ver en este ejemplo es un error muy grave, pero de análisis y no de sintaxis. Es indispensable realizar una buena interpretación del problema para continuar con el análisis respectivo.

Lectura #1 Programar con estilo

��

Introducción

�� !� �"�� #�� $�� %� �� $�� & �� '� �� (��

1 http://www.galeon.com/neoprogramadores/soyc-cpp.pdf

6

��)�� *�� )�� )�� +�*�� *�� "�� ,�� -�� .��

�� -�� &/0�� /'��1 �� "��2�� 3�� /43��$��5/�

1�� 6�� )�&�� '�� "�� )�� '��

�� $�� 7��*��& �� #��,� �!�'�� )� �� 8�� #��,� ��

3��-�� $�� )�� /�� /� �� 9*�� &�� '� �� :�� "�� ;;<�:�� '��

Análisis y Diseño

1 �� -�� #�� )�� 1 �� 1 �� )�� )��)�� #�� "�� *�� =�� )� ��

7

��12*�� *�� )��$�� "�� -�� -�� 2�� 3� �� )��

Estructuración

#�� $�� )�� 1 �� &'�� 1�� &�� '�'��>�� $�� !�� 0�� -�� "� � ��

void ImprimirRecords() { Datos=LeerDatos(Fichero); DibujarPantalla(); EscribirRecords(Datos); EsperarTecla(); }

1�� )��

Abstracción de datos

#�� $�� 1�� )��&��'�� )�� 1 �� -��)�� (�� ?!�� "� �� )�� 6�� )�� *�� ( �� 4�� $�� )�� 5�� $�� )��

8

�$�� 2�� )�� 6�� 7@#��!?!��!�� AA��'�

1�� $�� $��

Documentación

�� ,��

#��

��1��

;�!��

;�>�� &B� � ��'

;�!� �� @��

;�!� ��

=�� 22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;�22��C7D9E1��>E��22��!1*>E(�>(7C��>�� )��(�!(��22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;�22��=F7E��+��G� $�*��@��;�8(#1�;�22��+1>B��HI2HI2JHHI;K;�0� � ��J�L�22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;�22��B(*F7E(>7��22��L�?�� 22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

��#� ��

;�C��7��

;�� &�� '

;�E� ��

;�(��

22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;�

9

22��C7D9E1��E��)�22��!1*>E(�>(7C��!��)��-�� 22��EMD1FE7*� ��N��C-�� )�22��C7F��1�� -�� <KH�� H�� OP?PP�22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

!��"�� Q��

;�!� ��

;�=�� &:�� C�*�'

;�4��5

Control de versiones

1 �� )� �� $�� @�� )�� L�H��*��$�� &��,��'��

1��-�� -�� N�3�RST

#��!��*��0� � �� )��)�� & �� '�

$�� )�� -��

%�� D� ��-�� )�� -�� &�� '��

7��$ �� )�� &'&'(�� -�� >��)�� &�� '�� 1 �� )��*��

��$�� (�� U!� �� D�V�� ) �� >+=F97#��?J�LJ�?IHL��.(C!7.*�J?�IJ�LJ� �� -�� /��/�� V�� 9��

+��,��>�� &�� '�� &�,�� '��

10

�� !��+��,�&�� (U!��JW�X�I'�� (U!�� -��1��

-�� 1 �� ,�� &�� )�'�� 1 �� (U!�� $ �� )�� &'&'(�� )��-��

/**** 1.4 FUNCIONES Una de las herramientas fundamentales a lo largo de la historia de la programación, ha sido la inclusión de funciones, que se comportan como mini programas dentro de otro programa, permitiendo la reducción de espacio, la agrupación de muchas sentencias repetitivas bajo un mismos nombre, permiten que los programas sean legibles, estructurados y comprensibles, logrando con esto poder actualizar y/o corregir los programas de una manera rápida, sin tener que afectar la integridad de todo el programa. Podemos definir a las funciones como:

• “Una función es simplemente un algoritmo el cual devuelve un único valor al sitio del programa en que fue invocada o llamada”

• “Es un conjunto de instrucciones que cumplen con una tarea específica” • YUna función es una sección de código independiente, con nombre, que

ejecuta una tarea específica y opcionalmente devuelve un valor al programa que la llamó�

• De acuerdo a las definiciones dadas podemos, podemos decir lo siguiente:

• Una función tiene un único nombre, al utilizar éste nombre en otras partes del programa se pueden ejecutar los enunciados contenidos en la función. A esto se le conoce como llamar o llamado a la función, e inclusive se puede llamar desde otras funciones

• Una función es independiente, es decir pude ejecutar sus tareas sin interferencia ó interferir en otras partes del programa.

• Una función ejecuta una tarea específica. Una tarea es un trabajo discreto que un programa debe ejecutar como parte de su desempeño general, por ejemplo mandar una línea de texto a centrar, realizar ordenamientos, realizar cálculos matemáticos, ..

• Una función opcionalmente devuelve un valor al programa que la llamó. Cuando un programa llama a una función se ejecutan los enunciados contenidos en ésta, si el programa lo requiere, éstos enunciados pueden devolver un valor al programa que llamó a la función mediante la orden return,

11

Otras características importantes de las funciones y/o profundización a las anteriores:

• Las funciones se comportan como si fuesen variables • Se pueden definir funciones como "extern" o "static"., pro defecto están

definidas como extern, es decir afectan todo el programa • Las funciones están concebidas para devolver valores, por defecto el

valor es int, de querer que la función no retorne valor, se le antecede al instrucción “void” o puede tomar cualquier valor como si fuese una variable

• Las funciones deben tener nombres y se aconseja que este nombre identifique claramente lo que hace la función, si se necesita varias palabras para el nombre, se recomienda separarlo con un guión “_” o iniciando con mayúscula la primera letra de la palabra , un ejemplo pude ser “centrar _ palabra”, “Centrar palabra”,

• Los parámetros de una función van entre paréntesis y representa los valores de salida, y podemos afirmara que cada parámetro es una variable, en caso de no realizar paso de parámetros, simplemente se escribe el nombre de la función y los paréntesis “llamado()”

• Las funciones se comportan exactamente como programas, por lo tanto deben tener un inicio y un fin { }

• C++ esta soportado mediante funciones, de hecho el programa principal es una función main()

1.4.1 Prototipos Para utilizar una función en un programa se requiere en primer lugar declararla y después definirla. La declaración de la función le indica al compilador el nombre, el tipo de dato devuelto por la función y los parámetros pasados a la función. A la declaración de una función se le llama también el prototipo Un prototipo es una declaración de una función. Consistente simplemente en el encabezado de la función, terminado con punto y coma (;)lo que hace es avisar al compilador, como se va a llamar la función y si recibe y devuelve información La estructura de un prototipo es: <tipo> func(<lista de declaración de parámetros>); Ejemplo: int Mayor(int a, int b);// es un prototipo de función que devuelve un entero y recibe dos parámetros enteros Aunque C++ permite realizar el prototipo de la siguiente manera int Mayor(int,int); , sin necesidad de escribir el nombre de las variables Entonces La estructura de un programa en C++ quedaría así:

12

[directivas del pre-procesador: includes y defines] [declaración de variables y constantes globales] [prototipos de funciones] [declaraciones de clases] función main () [definiciones de funciones]//definidas en los prototipos [definiciones de clases]

Para llamar a una función de ejemplo (mayor) la cual la tenemos con dos parámetros y una segunda función llamada cuadro, la cual no contiene parámetros se debe respetar la sintaxis siguiente: x = mayor (<parametro1>, <parametro2>); x = cuadro (); La variable x tomará el valor regresado por la función. Cuando la función termina deber regresar a donde fue llamada. Esto se hace a través de la instrucción: return. Esta instrucción existe bajo dos formas: 1.)return(x); 2.) return(0) La primera regresa al programa que la llamó el valor de x, La segunda simplemente regresa el control a quien llamó a la función 1.4.1.1 La definición de una función Es en sí la función misma, está compuesta en su primer línea de código por el encabezado que debe ser idéntico al prototipo de la función pero en éste caso no se utiliza el punto y coma al final y además, al contrario del prototipo, donde es opcional incluir el nombre de las variables utilizadas como argumentos como lo vimos antes, en el encabezado de la función si se debe incluir el nombre de las variables. Enseguida del encabezado está el cuerpo de la función que contiene, encerrados entre llaves, procesos propios que debe realizar la función. Si la función devuelve algún valor, éste se debe especificar al final del cuerpo de la función, mediante la instrucción return(variable) 1.4.1.2 Paso de parámetros por Valor: En el caso de parámetros por valor: el valor de la variable que se esté pasando, es asignado a la variable local que es declarada al definir la función. Tanto la variable que se utilice al efectuar la invocación como la que la recibe "por valor" deben ser del mismo tipo, en caso contrario se presentará un error. Es hora de llevar lo anterior a la práctica, realizaremos un ejemplo para determinar cada una de las partes que conforman un programa con funciones: //*********************************************************

13

Se esta pasando valores a la función divide, primero el valor x inicial y en el segundo llamado el valor y inicial

Los valores X y Y, se convierten en valorx, valory, lo mismo sucede en la función multiplica

// Programa que permite realizar una multiplicación // y una suma mediante ala utilización de funciones //********************************************************* #include <iostream.h> void divide (int x, int y); int multiplica (int, int); // Función principal int main() { int x, y,r; cout << "Introduzca dos numeros" << endl; cin >> x cin >> y; divide(x, y); // llama a la función "Divide" divide(y, x); r = multiplica(x, y); cout << "La multiplicación de X y Y es = a: " << r << endl; return 0; } // Función divide void divide (int valorx, int valory) { int respuesta; // variable local respuesta= (valorx / valory;); cout << "La división de los dos valores es: " << resultado << endl; } // Función multiplica int multiplica(int valorx, int valory) { int mult; // variable local mult = valor1 * valor2; return mult;// retorna el valor del proceso }

La instrucción RETURN es quien regresa un y solo un dato a la parte del programa que la este llamando o invocando, sin embargo es de considerar que return puede regresar un dato, una variable o una expresión algebraica (no ecuación o formula) como lo muestran los siguientes ejemplos;

a) return 3.1416; b) return area; c) return x+15/2;

//Prototipo de funciones

Variable local, afecta solo a esta función

14

El siguiente programa soluciona un sistema lineal de tres incógnitas con tres variables, por el método de Cramer, mediante la utilización de funciones #include <iostream.h> #include <conio.h> // declaración de variables globales float a,b,c,d,e,f,g,h,i,j,k,l, // coeficientes y t‚rminos independientes X, Y, Z; // incógnitas a encontrar. void LeerCoeficientes(); // prototipo de función que permite leer los coeficientes void CalculoIncognitas(); // prototipo de función que permite realizar los calculos void EscribirResultados();// prototipo -función que permite escribir los resultados void main(){ LeerCoeficientes(); // lamado a caca una de las fucnciones CalculoIncognitas(); EscribirResultados(); } // Desarrollo de la Función que permite leer las variables void LeerCoeficientes() { cout << "Digite términos de la Primera Ecuación: \n"; cout << " \n"; cout << "Coeficiente de X : "; cin >> a; cout << "Coeficiente de Y : "; cin >> b; cout << "Coeficiente de Z : "; cin >> c; cout << "Término independiente: "; cin >> d; cout << "\nDigite términos de la Segunda Ecuación: \n"; cout << " \n"; cout << "Coeficiente de X : "; cin >> e; cout << "Coeficiente de Y : "; cin >> f; cout << "Coeficiente de Z : "; cin >> g; cout << "Término independiente: "; cin >> h; cout << "\nDigite términos de la Tercera Ecuación: \n"; cout << " \n"; cout << "Coeficiente de X : "; cin >> i; cout << "Coeficiente de Y : "; cin >> j; cout << "Coeficiente de Z : "; cin >> k; cout << "T‚rmino independiente: "; cin >> l; } // En esta función se realiza el calculo de las incognitas void CalculoIncognitas() {

15

float DetX, DetY, DetZ, DetSistema; // Variables locales DetSistema = a*f*k + e*j*c + i*b*g - i*f*c - j*g*a - k*e*b; DetX = d*f*k + h*j*c + l*b*g - l*f*c - j*g*d - k*h*b; DetY = a*h*k + e*l*c + i*l*g - i*h*c - l*g*a - k*e*d; DetZ = a*f*l + e*j*d + i*b*h - i*f*d - j*h*a - l*e*b; X = DetX / DetSistema; Y = DetY / DetSistema; Z = DetZ / DetSistema; } // funcion que permite mostrar por pantalla los resultados void EscribirResultados() { cout << "\n\n"; cout << "X = " << X << " Y = " << Y << " Z = " << Z; cout << "\n\nDigite cualquier tecla para terminar..."; getch(); } Observación: Es importante que como futuro programador de computadoras, documente muy bien cada uno de los bloques del programa o las líneas que usted considere de mayor relevancia, los motivos: 1.- Es importante que otras personas entienda lo que usted esta haciendo en cada una de las partes del programa 2.- Pasado un tiempo, con toda seguridad usted no recordará que quiso hacer en ese bloque o segmento y esto le ocasionará demoras en su trabajo y por consiguiere perdidas Para complementar, esta primera parte, es importante que revise la última unidad del modulo de algoritmos, la cual contiene unos ejercicios interesantes de algoritmos: A continuación se presenta un pequeño taller para que lo resuelva individualmente o con su grupo de trabajo colaborativo

• Las calculadoras, se convierten en un electo esencial en la vida cotidiana, por consiguiente y mediante el uso de funciones, se debe desarrollar una calculadora estándar, con todas las funciones incorporadas, (suma, resta, multiplicación, división, porcentaje, raiz cuadrada …), para los cual se sugiere consulte la ayuda que brinda el entorno C++ (F1)

• Si se quiere mejorar el ejercicio anterior, se propone tener un menú, con las opciones estándar y/o científica

• Existen muchos ejercicios que despiertan la creatividad, personalmente me inclino por los juegos, pues ellos permiten despertar habilidades propias de los ingenieros (como el ingenio), por lo anterior usted debe desarrollar un pequeño juego, donde se vea reflejada la utilización de funciones.

1.4.1.3 Paso de parámetros por referencia:

16

“Otra forma de comunicación, adicional al retorno de un valor, el cual puede producir una función, consiste en el paso de parámetros por referencia, en el cual cada variable pasada como parámetro, puede ser modificada por las instrucciones contenidas en el ámbito de la función. En la invocación se pasa la variable de igual forma que se hace por valor, esto es una "desventaja" ya que al ver la instrucción no nos daríamos cuenta si se está pasando por referencia o valor, la costumbre nos haría pensar que es por valor, pero para estar seguros debemos ver la definición de la función; al identificador que recibe, en la definición de la función, se le antepondrá el operador de dirección, &; de esta forma, en la memoria RAM tomará la misma dirección del parámetro de invocación” No nos inquietemos, en el siguiente capitulo se estudiará lo referente a punteros, esto nos permitirá una mayor claridad, sin embargo es bueno que el estudiante vaya indagando acerca de este apasionante tema. Miremos el siguiente ejemplo: donde se hace el intercambio de dos valores en la memoria ram del computador �

//Paso de parámetros por referencia // #include <stdio.h> #include <iostream.h> void intercambio(int *, int *); // prototipo de la función main() { int a = 20, b = 30; intercambio(&a, &b); // a y b son pasados por referencia cout<<"a es "<<a; cout <<" b es " <<b; } void intercambio(int *x, int *y) { int z = *x; // z toma el contenido de la dirección x *x = *y; // x toma el contenido de y *y = z; // contenido de y = z } Otro ejemplo de paso de parámetros por referencia: Se trata de convertir un valor decimal a binario, en este ejemplo nos aproximamos más a la siguiente unidad, por que tenemos que utilizar un arreglo para su realización

17

#include <iostream.h> int leer(); CalcularBinario(int, int); void main() { int i, decimal, binario[20]; decimal = leer(); CalcularBinario(decimal, binario); } int leer() { int N; cout << "Digite un entero para convertirlo a binario: "; cin >> N; return (N); } CalcularBinario(int N, int *p) { int c,r; c = N >> 1; *p = N % 2; cout <<"\n Leer desde abajo hacia arriba" << *p; while(c){ p++; *p = c % 2; cout << "\n" << *p; c >>= 1; } return 0; }

Taller de verificación de temas tratados

1) Cuales de los siguientes prototipos son validos

a) int cambio(int *b)

Sí ___ No ____

b)Calcular(int, int, char r);

18

Sí ___ No ____

c) void Invertir(int, unsigned char)

Sí ___ No ____

d) void sumar(float valor);

Sí ___ No ____

e) float suma(float int);

Sí ___ No ____

f) int mayor(int, int, int);

Sí ___ No ____

g) char Menu(int opciones);

Sí ___ No ____

1.4.2 Variables locales y globales

En C++ está permitido declarar variables en cualquier parte del código fuente. Además de pasar variables como parte del argumento de una función, también es posible declarar variables dentro del cuerpo de una función, a este tipo de variables se les llama locales ya que sólo son útiles dentro del cuerpo de la función. Los parámetros utilizados en una función se consideran como variables de tipo local y se utilizan exactamente de la misma manera, como lo demuestra en el siguiente codigo

int suma(int valor1, int valor2) { int local; // variable local local = valor1 + valor2; return local; }

�� "�� #� � �� #� � ��

19

#include <iostream.h> int global; // variable global void funcion1(int parametro); int main() { int local1, i, global=30; cout << local1 << endl << endl; cout << "Introduzca un numero:" << endl; cin >> local1; cout << "Su numero es: " << local1 << endl; cout << endl; for(i=0; i<5; i++) { int local2; // válida solo dentro del bucle local2 = i; cout << local1 << "\t"; cout << local2 << endl; } funcion1(local1); cout << "La variable \"global\" local vale: " << global << endl; cout << "La variable \"global\" global vale: " << ::global << endl; global=45; cout << "La variable \"global\" local ahora vale: " << global << endl; cout << "La variable \"global\" global vale: " << ::global << endl; //cout << local2 << endl; return 0; } void funcion1(int parametro) { global = global + parametro; }

Miremos, las variable definidas dentro de la función main (), se comportan como variables locales, para que afecten otra función, es necesario pasarlas a las funciones, en cambio la variable global (para esta caso también definida como global) afectan a toda el programa

20

1.4.3 Recursividad

Esta es la propiedad que tienen las funciones en C++ de poder llamarse a si mismas. Se dice que una función es recursiva cuando se autollama. No todas la funciones pueden llamarse a si mismas (ser recursivas), deben estar diseñadas especialmente para que tengan una final y no se conviertan en ciclos o bucles infinitos.

�1 �� $ �� #� �� F�� 1�� -�� $��P�K�PZIZ?ZJZL�K�LJH��1��

#include <iostream.h> double factorial(int valor); int K=1; // variable global, para un contador general int main() { int num; cout << "Introduzca un numero" << endl; cin >> num; cout << endl; cout << “El factorial del número es “ << factorial(num) << endl; cout << "La función se llamo en forma recursiva " << k << " veces" << endl; return 0; } double factorial(int valor) { double R; if(valor<=1) return 1; else { R= (valor*factorial(valor-1)); K = K+1; }

21

return resultado; }

1.) la función se declara de tipo doble, puesto que los valores que retornan la función pueden ser demasiado grandes.

2.) También se utiliza una variable global (K), que sirve de contador, para determinar el número de iteraciones que la función se repite

3.) El programa empieza solicitándole un número entero y después llama por primera vez a la función factorial ( ). La recursividad necesita una condición para terminar el proceso en el momento especifico, por ésta razón, la función factorial ( ) determina en primer lugar si el valor pasado como parámetro de la función es igual a 1, en cuyo caso la función retorna 1. Si el valor del parámetro es mayor que 1, entonces la función factorial ( ) se llama a sí misma tomando como parámetro el valor original menos uno, multiplicando éste valor por el valor del parámetro original y almacenando el resultado en la variable llamada resultado. (se recomienda realizar una prueba de escritorio para entender un poco más el movimiento de la función y sus iteraciones)

1.5 PUNTEROS: Podremos deducir por el nombre que un puntero, que es algo que apunta a algún lado, en el caso de la programación de computadoras, los punteros apuntan a direcciones de memoria, Los punteros son variables las cuales guardan direcciones de memoria RAM. En memoria un puntero ocupa 2 bytes. La dirección de memoria RAM que almacena un puntero (p) corresponderá a la dirección base de otra variable(x) que está en memoria, decimos entonces que el puntero "apunta" a esta variable, de la siguiente forma: P X �� 1200� � � "P apunta a X" �� 1200

Para este caso tomaremos una dirección no real (1200), la verdadera dirección la asigna el sistema operativo, a través del compilador En memoria, la variable P almacena un valor de 1200. La variable X se encuentra en la dirección de memoria 1200.La abstracción que se debe hacer es la de que P apunta o señala a X. Para definir un puntero se inicia definiendo el tipo (int, flota, char…), luego se antepone el * la nombre de la variable ejemplo int *X.

22

La dirección de memoria se representa a través de notación hexadecimal Si se define Int *X, k=23 y queremos que X tome la dirección de la variable K entonces: P=&K; Esta instrucción se debe interpretar así: La dirección (&) de la variable K de tipo entero, se asigna ala variable puntero P, una representación gráfica quedará así: �

�� 0X0012FF78 � �00000000 00001101� �� 0x0012FF7C 0x0012FF78 0x0012FF79

Y si se quiere visualizar el valor de la variable K a través del puntero, queda así: Cout<<*P; Esto mostrará el valor 23 y *P se leerá como el valor al cual apunta P,

Los siguientes son algunas recopilaciones de ejercicios de cómo se hace la declaración de punteros:

int *puntero1; int *puntero2, *puntero3; char x, *punteroCaracter; float *punteroReal, real;

En la primera línea, declaramos un puntero a un entero. En la segunda, dos punteros a entero. En la tercera, un carácter ( x) y un puntero a carácter (punteroCaracter). Por último, punteroReal es un puntero a un real, y real es declarado como un número real.

un ejemplo de uso del operador * y del operador de dirección (&):

#include <iostream.h>

main(){ double d, *dp; d = 2.7183; dp = &d; cout << "número = " << d << "\tdirección = " << &d << '\n'; }

• * �� Sirve para crear y manipular el valor hexadecimal que representa esa dirección.

• & �� Se utiliza para procesar directamente el dato que se encuentra en dicha dirección.

• Los punteros pueden apuntar a variables de cualquier tipo para ilustrar mejor lo anterior, se propone un ejercicio de un puntero a un número entero

23

#include <iostream.h> void main(){ int *p, x=13; cout << "la variable de tipo entero es: " << x; p = &x; cout << "\La variable P tomo la dirección de memoria : " << p; cout << "\ y el valor de p es = " << *p; *p = 41; Cout <<"\n después de *p=41 esta toma el valor de "<< *p; cout << "\n Digite un valor para la variable x: "; cin >> *p; cout << "\n Ahora X = " << x; cout <<"\n\n la variable X está en la dirección de memoria: " << p; cout <<"\n\n la variable x está en dirección de memoria: " << &x; cout <<"\n\n Puntero p está en la dirección de memoria “<<&p; } Otro ejemplo

# include <iostream.h>

main () { int *ptInt; int var1 = 7, var2 = 27;

ptInt = &var1; var2 = *ptInt;

cout << " var1 = " << var1 << " var2 = " <<var2 << "*ptInt = " <<*ptInt << '\n';

*ptInt = 5;

cout << " var1 = " << var1 << " var2 = " <<var2 << "*ptInt = " <<*ptInt << '\n';

ptInt = &*ptInt; var1 = *&var1; }

El resultado de la ejecución es:

var1 =7 var2 = 7 *ptInt = 7 var1 = 5 var2 =7 *ptInt = 5

24

Estudiemos el funcionamiento del programa:

• Se asigna a ptInt la dirección de var1. Entonces el valor de ptInt es la dirección de memoria de var1.

• A var2 se asigna el valor al que ptInt apunta. Entonces el valor de var2 es el contenido de la localización de memoria la que ptInt apunta (var1).

• Después de imprimir los tres valores por primera vez, el contenido de la dirección a la que apunta ptInt es cambiado a 5. Como este contenido es var1, el valor de var1 es ahora 5, pero var2 no es modificado.

• Las dos últimas líneas ilustran cómo los operadores * y & son conceptos inversos. Nótese que el orden de precedencia es de izquierda a derecha, por tanto el más cercano a la variable es siempre el primero que se aplica.

Taller Punteros

1) investigue porque un puntero ocupa 2 bytes? 2) Donde radica la importancia de la utilización de punteros 3) Cuales son las restricciones del uso de los punteros

Taller cerificacion Fin unidad

1.- Existe un ejercicio clásico, la intencionalidad no es transcibirlo, es leer los enunciados y desarrollarlo utilizando funciones recursivas, se trata de las torres de Hanoi

La Leyenda: En una ciudad antigua en la India, los monjes de un templo tienen que mover una pila de 64 discos sagrados a partir de una localización a otra. Los discos son frágiles; solamente uno se puede llevar al mismo tiempo. Un disco no se puede colocar encima de un disco más pequeño, menos valioso. Y, hay solamente otra localización en el templo (además de la original y de la localización de destino) bastante sagrada y solo una pila de discos se puede colocar allí. Así pues, los monjes comienzan a mover discos hacia adelante y hacia atrás, entre la pila original, la pila en la nueva localización, y la localización intermedia, manteniendo siempre el orden (más grande en el fondo, más pequeño en la tapa). La leyenda consiste en que, antes de que los monjes hagan el movimiento final de terminar la pila nueva en la nueva localización, el templo se convertirá en polvo y el mundo terminará. Tú que crees? .........Bueno dejémonos de leyendas y vamos a lo que vamos.......

El "Juego" torres de Hanoi consiste en tres palos, en el cual el primer palo tiene N número de argollas colocadas de tal manera que las más grandes siempre deben estar por debajo de las más pequeñas...el segundo palo le podremos llamar palo auxiliar y es el que nos ayudará de cierta manera a lograr el desarrollo del juego el cual será lograr pasar todas las argollas al tercer palo de

25

tal manera que se mueve una argolla a la vez y que nunca una argolla grande quede encima de una pequeña....

Torre 1............... Torre 2............... Torre 3

26

2.0 SEGUNDA UNIDAD

• Arreglos unidimensionales • Arreglos de caracteres y cadenas • Arreglos bidimensionales • Ordenación • Búsqueda

Esta unidad nos permite afrentarnos un poco en el mundo de los datos estructurados, para tal efecto iniciaremos con los datos mas sencillos como los son los arreglos unidimensionales, realizando ejemplos de diferente tipo, y se presentará una vez se tenga dominio sobre este tema, abordaremos un tipo especial de arreglos unidimensionales como lo son las cadenas de caracteres, para seguir con los arreglos bidimensionales o matices, se nombraran simplemente los arreglos multidimencionales, y se espera que el estudiante profundice mas sobre este tema, también se profundiza sobre las operaciones fundamentales que se hacen con los arreglos como los son la ordenación y la búsqueda , para lo cual se revisarán diversidad de algoritmos que dan solución a estos temas, al finalizar cada tema se propondrá una serie de ejercicios que le permitan al estudiante realizar una auto evaluación de lo aprendido, lo mismo que interactuar con los compañeros del pequeño grupo colaborativo.

1.2 intencionalidades formativas: Conceptuar referente a estructuras de datos que manipulan volumen mayor de información Propósitos de la unidad

• Conocer el trabajo que se realiza con vectores, arreglos y cadenas de caracteres

• Realizar búsquedas y ordenamientos utilizando algoritmos diseñados para tal fin

Objetivos de la unidad

• Tener claridad en la importancia que tienen los vectores, los arreglos y las cadenas de caracteres

• Tener claridad en los criterios de búsqueda y ordenamiento Competencias de la unidad: • Dominar las tecnicas de búsqueda y ordenamiento aplicado a estructuras

básicas de la programación • El estudiante aplica los vectores y arreglos como herramienta fundamental

en la programación de computadoras

27

Metas de aprendizaje • Realizar programas con un alto grado de complejidad

UNIDADES DIDÁCTICAS: PALABRAS CLAVES: Arreglos Búsqueda Ordenamiento String

28

2.1 Arreglos unidimensionales:

Los arreglos unidimensionales son estructura de datos estática que le periten almacenar gran cantidad de información bajo un mismo nombre, también reciben el nombre de vectores en álgebra o arreglos unidimensionales en programación

Los procesos normales con un vector o con sus elementos incluyen: Declarar toda la lista, Capturar sus elementos, Desplegarlos, Realizar operaciones con ellos, entre otros procesos

Para decalar un arreglo o una lista se usa el siguiente formato:

tipodato nombre[cantidad de elementos];

ejemplos; int edades[12]; float sueldos[10]; Char carreras[10];// El tema del manejo da cadena de caracteres, es apasionante, se recomienda iniciar su estudio, para abordar temas posteriores /** Como se ve, el número de elementos del arreglo estará dado por el número encerrado entre [ ] al declararlo, esto se llama dimensionamiento., es obligatorio, a menos que se de implícitamente el tamaño del arreglo por medio de la inicialización del mismo como así: char Operador[] = {'U', ‘N', 'A', 'D'}; int Enteros[] = { 4, 13, 0, 5, 6, -23, 7, 345, 45, -12}; En el primer ejemplo, Operador será un arreglo de cuatro posiciones, y queda inicializado con los correspondientes caracteres dados entre llaves. El segundo ejemplo el vector Enteros tendrá 10 posiciones. En un arreglo de “N” elementos organizados en una dimensión donde “N” recibe el nombre de longitud o tamaño del vector. Para hacer referencia a un elemento del vector se usa el nombre del mismo, seguido del índice (entre corchetes), el cual indica una posición en particular del vector. Por ejemplo: Vec[x] Donde: Vec…………Nombre del arreglo x…………… Numero de datos que constituyen el arreglo

29

Siendo más claros, si queremos manejar un conjunto de 9 elementos de tipo entero, tendremos que definir un arreglo de la siguiente manera:

Int c[9]: esquemáticamente queda así:

Que es el subíndice? Es el Es el número que hace referencia a una celda específica del arreglo, en el caso de c++ el subíndice es un valor que inicia desde cero y se extiende hasta el valor que se haya definido el arreglo, es importante no confundir el subíndice con el valor que toma el arreglo en esa posición, para el ejemplo anterior el arreglo toma el nombre de c y si queremos referirnos a una posición en especial, por ejemplo a la posición número 4 x= c[4], para este caso la variable x tomara el valor de -200.14

Normalmente un arreglo va acompañado de un ciclo, y el más común para manipular arreglos es el ciclo for, ya que se conoce una dimensión exacta del arreglo.

3.2

-1.0

4.75

3.14

0.23

-200.14

10.78

18.84

0.7550

1983.0

c[0]

c[1]

c[2]

c[3]

c[3]

c[4]

c[5]

c[6]

c[7]

c[8]

Nombre del arreglo

Los registros se acceden a través de un subíndice

30

Es importante realizarle una limpieza a todas las posiciones del arreglo, antes de iniciar a trabajar con ellas, miremos un segmento de programa que permita poner en ceros (0) todas la posiciones del vector anterior

Void Main () { Int c [10], k; For(k=0;k<10;k++) c[k]=0; } Veamos : se definió un arreglo de 10 elementos (0..9), de tipo entero, una variable k, para controlar el arreglo, en este caso servirá como subíndice, un ciclo for que inicia en 0 y termina en 9 (recuerde que de cero a nuevo hay 10 elementos) y por ultimo se le asigna el valor de 0 a cada una de las posiciones, puesto que están dentro de un ciclo Ejemplo: mediante la utilización de un arreglo, leer las edades de 10 estudiantes del curso de introducción a la programación, encontrar la mayor de las edades, y el promedio de las mismas Recordemos: Recuerdan de algoritmos?, una de las primeras preguntas que me hago a al abordar el ejercicio, es que no conozco de este ejercicio.. Perfecto las edades, y el promedio? (ojo , el promedio no lo conozco pero lo puedo calcular con la � de las edades sobre el número de encuestados), Manos a la obra #include <iostream.h> #include <conio.h> void main() { int edad[10], k, suma=0, promedio, edad_mayor; clrscr(); for (k=0; k<10; k++)// ciclo para limpieza, auque para este caso no sea edad[k]=0; // necesario // Leemos las edades for (k=0; k<10; k++) { cout<<”por favor ingrese la edad para el estudiante # “ << k+1 <<”\n”; cin>>edad [k]; } //calculamos el promedio, aunque lo hubiésemos podido hacer en el ciclo // anterior, también encontraremos la mayor de las edades, mediante una //deducción sencilla, asumiremos que la primera de las edades que ingreso es //la mayor de todas, para luego compararla con las demás e ir intercambiando //su valor

31

edad_mayor= edad[0 ]; // edad_mayor toma el primer valor del arreglo for (k=0; k<10; k++) { suma=suma+edad[k]; if (edad_mayor < edad[0]) { edad_mayor= edad[k]; } } promedio=suma/10; cout <<”el promedio de las edades es: ”<< promedio <<”\n”; cout<< “la mayor de las edades es : “ <<edad_mayor; getch(); } Realicemos la prueba de escritorio, Valores del arreglo edad 20 25 30 15 40 18 20 38 26 12 k Edad [ ] suma mayor promedio 0 20 20 20 1 25 45 25 2 30 75 30 3 15 90 4 40 130 40 5 20 150 6 20 170 7 35 205 8 25 230 9 20 250 25 Taller de verificación Ejercicios propuestos para ser desarrollados en forma individual, luego serán compartidos con los compañeros del grupo colaborativo

1. Se tiene un arreglo unidimensional, de N posiciones, en el cual cada uno de sus componentes puede ser solo un dígito. Determinar el número de veces (frecuencia) que aparece cada uno de los (diez) dígitos en el vector.

2. Calcular el promedio de 150 valores almacenados en un vector.

Determinar además cuantos son iguales que el promedio, imprimir el promedio, el número de datos iguales que el promedio y una lista de valores inferiores al promedio.

32

3. Leer un vector A de N elementos y un vector B de M elementos (pueden

ser repetidos en cada vector). ¿Cuántas veces se encuentra presente cada elemento de A en B, no incluya elementos repetidos?.

4. Llenar dos vectores A y B de 25 elementos cada uno, sumar el elemento

uno del vector A con el elemento uno del vector B y así sucesivamente hasta 25, almacenar el resultado en un vector C, visualizar los tres vectores

5. Lea un vector A de N elementos todos diferentes y un vector B de M

elementos los cuales pueden ser repetidos. ¿Cuántas veces se encuentra presente cada elemento de A en B?

6. Llenar un vector de 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.( solo cambia una condición a nuestro ejemplo de trabajo )

7. Se tiene un vector de N posiciones de tipo entero. Generar a partir de él

otros tres vectores A, B y C de suerte que en A estén solo los números pares, en B los impares y en C los múltiplos de 10.

8. 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.

9. Almacenar 300 números en un vector, imprimir cuantos son ceros,

cuantos son negativos, cuantos positivos. Imprimir además la suma de los negativos y la suma de los positivos.

10. Almacenar 150 números en un vector, almacenarlos en otro vector en

orden inverso al vector original e imprimir el vector resultante. 11. Se tienen almacenados en la memoria dos vectores M y N de cien

elementos cada uno. Hacer un algoritmo y programa que escriba la palabra “Iguales” si ambos vectores son iguales y “Diferentes” si no lo son. Serán iguales cuando en la misma posición de ambos vectores se tenga el mismo valor para todos los elementos.

12. Se tiene el vector A con 100 elementos almacenados. Diseñe un

algoritmo y programa que escriba “SI” si el vector esta ordenado ascendentemente o “NO” si el vector no esta ordenado

13. Leer valores numéricos en un vector en desorden, a continuación mostrarlo en la misma secuencia pero ignorando los elementos repetidos y diciendo ¿cuántos se imprimieron?.

14. Diseñe un algoritmo y programa que lea un número cualquiera y lo

busque en el vector X, el cual tiene almacenados 80 elementos. Escribir

33

la posición donde se encuentra almacenado el número en el vector o el mensaje “NO” si no lo encuentra. Búsqueda secuencial.

15. Diseñe un algoritmo y programa que lea dos vectores A y B de 20

elementos cada uno y multiplique el primer elemento de A con el ultimo elemento de B y luego el segundo elemento de A por el diecinueveavo elemento de B y así sucesivamente hasta llegar al veinteavo elemento de A por el primer elemento de B. El resultado de la multiplicación almacenarlo en un vector C.

16. Diseñe un algoritmo y programa que almacene en un vector llamado

Fibon[100] los 100 primeros números de la serie fibonacci., recuerde que esta serie inicia así: 0,1,1,2,3,5,8,13…..N100

34

2.2 Arreglo De Caracteres y Cadenas Una vez se conceptualizo el concepto fundamental de lo que es un vector o arreglo unidimensional, se puede con gran facilidad hablar de cadena de caracteres, pues se comporta como un arreglo de este tipo, a diferencia de otros lenguajes que trae un tipo primitivo para el manejo de este tipo de datos, normalmente se denominan string La declaración es similar a un vector normal ejemplo: char cadena[10] en este caso hemos abierto un arreglo de 10 espacios para manejar una cadena de 9 caracteres Observación si se debe definir una cadena con un espacio más, puesto que C++ reserva la ultima posición para identificar el fin de la cadena \0 Una cadena puede almacenar todo tipo de información de tipo alfanumérico como: nombres de personas, mensajes de error, números de teléfono, direcciones entre otras . La asignación directa sólo está permitida cuando se hace junto con la declaración. Por ejemplo: char S[5]; S = "UNAD" O también podemos realizar una asignación uno a uno así: char S [5]; S [0] = 'U'; S [1] = 'N'; S [2] = 'A'; S [3] = 'D'; S [4] = '/000'; Realicemos un ejemplo

Escribir un programa que lea el nombre, la edad y el número de teléfono de un usuario y los muestre en pantalla.

#include <conio.h> #include <iostream.h> int main() { char Nombre[30]; // cadena para almacenar el nombre (29 caracteres) int Edad; // Un entero para la edad char Teléfono[13]; // Y otra cadena para el número de teléfono (12 dígitos) // Mensaje para el usuario y captura de información cout << "Por favor escribe tu nombre : :"; cin>>Nombre; cout<<"\n Por ingresa tu edad" ;

35

cin>>Edad; cout <<"por favor el número de teléfono "; cin>>Teléfono; // Visualización de los datos leídos cout << "Nombre:" << Nombre << endl; // = "\n" cout << "Edad:" << Edad << endl; cout << "Teléfono:" << Teléfono << endl; getch(); return 0; } Miremos que el teléfono se hubiese podido leer como un entero, pero es posible que se agreguen caracteres especiales como paréntesis o guiones, lo que lo convierten en alfanumérico Si ya los se, no funcionó como se quería, ahora prueba sin escribir espacios en la variable nombre… ahora si funciono verdad. Esto sucede porque la cin>> es un canal básico de entrada, el cual no permite la separación de cadena de caracteres. Afortunadamente C++ incorpora una serie de librerías que ayudan a manipular de manera adecuada este tipo de datos La librería estándar de C++ iostream.h , contiene cantidad de funciones pero las principales podemos decir que son 4:

• cin, canal de entrada estándar. • cout, canal de salida estándar. • cerr, canal de salida de errores. • clog, canal de salida de diario o anotaciones

Dedicaremos un tiempo a la función cin>>, por ser una de las más utilizadas, el objeto cin se pude emplear con:

• Cin.getline( ), este llamado a función, puede resolver el problema del ejercicio anterior, cuando únicamente permitía la entrada de una cadena si espacios, por tanto la función cin.getline permite leer una línea completa incluyendo los espacios, para el ejercicio anterior cin.getline(nombre,30), es necesario especificar la longitud máxima de la cadena a ingresar.

• Cin.get( ): permite ingresar carácter por carácter, normalmente se acompaña de un ciclo condicional como while

• Cin.put( ) Caso contrario del anterior, permite una salida de caracteres, uno a uno.

Afortunadamente hay otra serie de librería que permite una manipulación adecuada de los caracteres, entre ellas:

36

Librería string: librería estándar del ANSI C, entre sus principales funciones están:

• Memchr: void *memchr (const void *s, int c, size_t n);

Localiza la primera aparición de un carácter para en los primero n caracteres de una cadena

Ejemplo

#include <iostream.h> #include <stdio.h> #include <string.h> int main() { char cadena[] = "Mundo cruel..."; char *puntero; puntero = (char *)memchr( cadena, 'd', 15 ); cout<< cadena<<endl; cout<< puntero<<endl; return 0; }

A continuación se presentaré un listado con las funciones de esta librería, esperando que usted profundice más es este aspecto

memchr memcmp memcpy memmove memset strcat strchr strcmp strcoll strcpy strcspn strerror strlen strncat strncmp strncpy strpbrk strrchr strspn strstr strtok strxfrm

Librería ctype ANSI C Contiene las funciones y macros de clasificación de caracteres

• Tolower: convierte un carácter a minúscula Ejemplo:

37

// Mediante la utilización de un ciclo podemos convertir toda una cadena que esta en //mayúsculas a minúsculas #include <stdio.h> #include <ctype.h> int main() { char cadena[ ] = "UNIVERSIDAD – UNAD-"; int i; for(i = 0; cadena[ i]; i++) cadena[i] = tolower(cadena[i]); cout<< cadena; return 0; }

• Toupper: El caso contrario de Tolwer convierte caracteres a mayúscula

También contiene una serie de macros a las que les hago referencia a continuación

isalnum isalpha isascii iscntrl isdigit isgraph islower isprint ispunct isspace isupper isxdigit toascii

38

1. Ejemplo de funciones varias para manipular cadenas de caracteres. La mayoría vienen incorporadas en el archivo a incluir string.h. #include <iostream.h> #include <stdlib.h> /* NULL*/ #include <ctype.h> #include <conio.h> #include <stdio.h> int longitud (char *cadena){ //Similar a la función strlen de string.h int c=0; while(*cadena){ c++; cadena++; } return c; } void AMayusculas(char *cadena){ //similar a strupr de string.h while (*cadena){ if (*cadena>=97 && *cadena<=122 ) // ASCII: a=97 z=122 A=65 *cadena = *cadena - (97-65); cadena++; } } void AMinusculas(char *cadena){ //similar a strlwr de string.h while (*cadena){ if (*cadena>=65 && *cadena<=90 ) // ASCII: A=65 Z=90 a=97 *cadena = *cadena + (97-65); cadena++; } } void Apropiado(char *s){ while(*s){ *s = toupper(*s); s++; while(*s && *s!=' '){ *s = tolower(*s); s++; } while(*s && *s==' ') s++; } }

39

void CopiarCadena(char *cadena2, char *cadena1){//Copia cadena1 en cadena2 *cadena2 = *cadena1; while(*cadena1){ cadena2++; cadena1++; *cadena2 = *cadena1; } } void ConcatenarCadena(char *cadena2, char *cadena1){ //esta función es similar a strcat de string.h while (*cadena2) //Encuentra final de cadena2 cadena2++; while(*cadena1){ //añade contenido de cadena1 a cadena2 *cadena2 = *cadena1; cadena2++; cadena1++; } *cadena2 = '\0'; //coloca terminador nulo a la cadena2 } int CompararCadenas(char *cadena2, char *cadena1){//Similar a strcmp de string.h int posicion=1; //de la primera diferencia. while(*cadena1 == *cadena2){ if( *cadena1 == NULL && *cadena2 == NULL) return 0; //las cadenas son iguales cadena1++; cadena2++; posicion++; } if (*cadena1-1 < *cadena2-1) posicion = -posicion; return posicion; } int ContarOcurrenciaCaracter(char *cadena, char caracter){ int c=0; while(*cadena != NULL){ if (*cadena == caracter) c++; cadena++; } return c; }

40

int SustituirCaracterPorOtro(char *cadena, char carviejo, char carnuevo){ int contador=0; while(*cadena){ if (*cadena == carviejo){ *cadena = carnuevo; contador++; } cadena++; } return contador; } void main(){ char c1, c2, s2[80], *s1="Esto es una prueba"; int pos; clrscr(); cout << s1; cout << ": Tiene una longitud de " << longitud(s1) << " caracteres \n"; AMayusculas(s1); cout << "\n\nEn mayúsculas fijas es: " <<s1; AMinusculas(s1); cout << "\n\nEn minúsculas fijas es: " <<s1; Apropiado(s1); cout << "\n\nEn forma Apropiada es: " <<s1; CopiarCadena(s2, s1); cout << "\n\nCopiado S1 en s2 = "<< s2; ConcatenarCadena(s2, " de cadenas"); cout << "\n\nConcatenado S2 con un mensaje = " << s2; getch(); clrscr(); cout << "\n\nEJEMPLO DE COMPARACION DE CADENAS \n" << "Digite cadena:"; gets(s1); cout << "\n\nDigite otra cadena:"; gets(s2); pos = CompararCadenas(s2,s1); if ( pos > 0) cout << "\n\nCadena " << s1 << " es mayor alfabéticamente que " << s2; else if ( pos < 0) cout <<"\n\nCadena " << s1 << " es menor alfabéticamente que " << s2;

41

else cout << "\n\nLas cadenas "<< s2 << " y " << s1 << " son iguales"; getch(); clrscr(); cout << "\n\n\nDigite frase para contarle las vocales:"; gets(s1); cout << "\na = "<< ContarOcurrenciaCaracter(s1, 'a'); cout << "\ne = "<< ContarOcurrenciaCaracter(s1, 'e'); cout << "\ni = "<< ContarOcurrenciaCaracter(s1, 'i'); cout << "\no = "<< ContarOcurrenciaCaracter(s1, 'o'); cout << "\nu = "<< ContarOcurrenciaCaracter(s1, 'u'); cout << "\nDigite un caracter de anterior frase: "; cin >> c1; cout<<"\nDigite nuevo caracter para sustituir a: " << c1 << "\n"; cin >> c2; if ( SustituirCaracterPorOtro(s1, c1, c2) ) cout << "\n" << s1; else cout << "El caracter digitado no se encontró en frase"; getch(); } Taller de verificación

1. Cree un programa que lea una cadena de caracteres y la compare con otra definida por código dentro de la aplicación. Por ejemplo:

2. Cree un programa que solicite una cadena de caracteres y retorne la

cantidad de letras que ésta tenga.

3. Cree un programa que solicite una cadena de caracteres y retórnela invertida.

4. Cree un programa que solicite una cadena de caracteres y retorne la

suma del valor ASCII de cada carácter.

5. Cree un programa que solicite una cadena de caracteres y retórnela sin vocales.

6. Se pide digitar una cadena de caracteres y luego esta es presentada

centrada en la pantalla dos filas más abajo.

42

2.3 Ordenación y Búsqueda Una de las mayores actividades que los computadores realizan con los datos incorporados, es estar buscando información y ordenarlos permanentemente, de acuerdo a unos criterios establecidos por los usuarios, por consiguiente estos temas cobran vital importancia para los estudiantes del presente curso. Los temas se tratan con algoritmos ya realizados por expertos, lo que pretendemos es simplemente estudiarlos y adecuarlos a ejercicios propuestos. Es vital que para poder conceptualizar estos temas, se tenga claridad en el manejo de vectores. 2.3.1 Búsqueda: La búsqueda es una tarea que uno realiza permanentemente, en toda actividad, cuando se esta en un supermercado uno busca artículos en particular, en una multitud de gente se busca a alguien en especial, en un directorio se busca a una persona, como se observa la búsqueda esta presente en cada una de las actividades.

Los algoritmos más utilizados para la realización de búsquedas son:

• Lineal o Secuencial • Binaria. • Hash (transformación de claves).

2.3.1.1Búsqueda lineal Es el método para buscar algo dentro de un arreglo , donde se hace un recorrido de inicio a fin de, realizado las comparaciones necesarias hasta encontrar el elemento requerido . Para entenderlo mejor realizamos el algoritmo necesario encontro = FALSE para k= 0 hasta n haga

si X[k] = ValorBuscado haga mostrar “Elemento encontrado en la posición “, k

encontro = TRUE k=n;

fin si fin para si encontro = FALSE haga

mostrar “No se encontró el elemento“ fin si

43

A continuación un ejemplo de búsqueda lineal

#include <stdio.h> #include <conio.h> #include <iostream.h> // Prototipos de las funciones. void mostrar(int *arreglo, int n); int buscar(int valor, int *arreglo, int n); void main(void) { int n; // numero de elementos del vector < 100 int valor; // El numero a buscar int i; // Contador int arreglo[100]; // Arreglo de enteros clrscr(); cout<<"Digite el numero de elementos:"; cin>>n; for (i=0;i<n;i++) { cout<<"Digite la posicion ", i; cin>>arreglo[i]; } cout<<"Digite el numero a buscar:"; cin>>valor; cout<<"\nVector Leido:\n"; mostrar(arreglo,n); cout<<"\nBusqueda lineal:\n"; if ((i=buscar(valor, arreglo, n)) != -1) cout<<"\nEncontrado en la posicion \n"<<i+1; else cout<<"\nNo existe en el arreglo\n"; getch(); } // función que permite mostrar en la pantalla el vector void mostrar(int *arreglo, int n) { int i; // Contador for (i=0;i<n;i++) cout<< arreglo[i]; cout<<"\n"; } // función Búsqueda lineal. int buscar(int valor, int *arreglo, int n)

44

{ int i; // Contador for (i=0; i<n; i++) if (valor == arreglo[i]) // condicional para encontrar el elemento return i; return -1; }

Se recomienda realizar prueba de escritorio para determinar el comportamiento del anterior código.

2.3.1.2 Busqueda Binaria: La búsqueda lineal es efectiva, pero no es la más eficiente, si se tiene gran cantidad de información, esta búsqueda pude ser tediosa, por consiguiente se han desarrollado diferentes algoritmos, que permiten realizar búsquedas más efectivas, como es el caso de la búsqueda binaria, este algoritmo tiene una pequeña restricción es que solo realiza búsquedas efectivas si el arreglo está ordenado. El algoritmo de búsqueda binaria, divide el vector en dos y compara el elemento central con el valor que se esta buscando, si el elemento es mayor se realizar divisiones sucesivas hacia la derecha, de aso contrario la hará hacia la izquierda, gráficamente si se tiene un vector de 8 elementos ordenados y se quiere encontrar el un valor en especial, para este caso el 19, se procede así:

A[0] A[1] A[2] A[3] A[4] A[5] A[6] A[7]

5 9 13 15 19 21 25 31

El primer paso que se realiza es examinar el valor central del vector, o sea la casilla número 4 (8 div 2), como el contenido de ella es menor que el número a buscar se puede descartar la búsqueda en las casillas ubicadas a la izquierda,

5 9 13 15 19 21 25 31

19 21 25 31

A continuación se repite este procedimiento, comparando el valor a la derecha

19 21 25 31

Central Menor Mayor

Menor Mayor Central

45

Ahora el elemento central es mayor que el valor que se esta buscando, por lo tanto hay que proceder hacia la izquierda

19 Existe en la posición 5

encontro = 0 menor = 1 mayor = n mientras menor <= mayor hasta central = (mayor + menor ) div 2 si X[central] = valor haga

mostrar “Elemento encontrado en la posición “, central encontro =1

fin si si X[central] < valor haga

menor = central + 1 si no haga mayor = central - 1

fin si fin mientras si encontro = 0 haga

mostrar “No se encontró el elemento“ fin si El código para la búsqueda binaria es el siguiente: #include <stdio.h> #include <conio.h> #include <iostream.h> // Prototipos de las funciones. void MostrarVector(int *arreglo, int n); int buscar(int valor, int *arreglo, int n); void main(void) { int n; // cantidad de elementos del vector int valor; // numero a buscar int i; // Contador int arreglo[100];// Arreglo de enteros clrscr(); cout<<"Digite el numero de elementos:"; cin>> n; for (i=0;i<n;i++) {

Menor, mayor y central

46

cout<<"Digite un valor para la posicion :", <<i<<" "; cin>>arreglo[i]; } cout<<"Digite el numero a buscar:"; cin>>valor; cout<<"\nVector Leido:\n"; MostrarVector(arreglo,n); cout<<"\n inicia el proceso de Búsqueda binaria:\n"; if ((i=buscar(valor, arreglo, n)) != -1) cout<<"\nEncontrado en la posicion n"<<i; else cout<<"\nNo existe en el arreglo\n"; getch(); } // función para mostrar en pantalla el vector void MostrarVector(int *arreglo, int n) { int i; // Contador for (i=0;i<n;i++) cout<< arreglo[i]; cout<<"\n"; } // función para realizar Búsqueda binaria. int buscar(int valor, int *arreglo, int n) { int menor=0; // Posicion inferior de la sablista int mayor; // Posicion superior de la sablista int central; // Posicion central de la sablista mayor = n; while (menor <= mayor) { central = (mayor + menor) / 2; if (arreglo[central] == valor) return central; if (arreglo[central] < valor) menor = central + 1; else mayor = central - 1; } return -1; } Al igual que el código de la búsqueda lineal, se recomienda realzar la respectiva prueba de escritorio 2.3.1.3 Busqueda De Hash .

47

Es otro método complejo de búsqueda, que tiene ventajas con respeto al método binario, puesto que no requiere que el vector este ordenado. Este método no lo veremos en este modulo, pues presenta colisiones. Si esta interesado en profundizar un poco más en este método, refiérase a la siguiente dirección http://www.itlp.edu.mx/publica/tutoriales/estru1/18.htm,. 2.3.2 Ordenamiento: a pesar que no es una actividad tan constante como la búsqueda de datos, muchas veces necesitamos ordenar los datos para tener una información más consistente, es así que se han desarrollado numerosos algoritmos que permite dar un orden adecuado a los datos, entre ellos podemos encontrar unos sencillos, otros complejos otros eficientes y otros no tanto. Los algoritmos que revisaremos en este apartado son

1. Burbuja (intercambio). 2. Inserción (baraja) 3. Inserción binaria 4. Selección. 5. Shell. 6. Ordenación rápida (Quicksort). 7. Mergesort

De los cuales en este modulo presentamos el 1,2,4,5 los otros son variaciones de los primeros 2.3.2.1 Ordenación mediante el algoritmo Burbuja: Este es el método más fácil de utilizar y aprender, también se lo conoce como ordenamiento directo o de intercambio, consiste en: que va comparando cada elemento del arreglo con el siguiente; si un elemento es mayor que el que le sigue, entonces se intercambian (dependiendo si queremos ordenar ascendente o descendentemente); esto producirá que en el arreglo quede como su último elemento, el más grande. Este proceso deberá repetirse recorriendo todo el arreglo hasta que no ocurra ningún intercambio. Los elementos que van quedando ordenados ya no se comparan, los pasos son: Los pasos a dar son:

1. se decide como se quiere el resultado del ordenamiento, si ascendete o descendente

2. Comparar A[1] y A[2]; Si están en orden, se mantienen como están; en caso contrario, se intercambian entres sí.

3. A continuación se comparan los elementos 2 y 3; de nuevo se intercambian si es necesario.

4. El proceso continúa hasta que cada elemento del vector ha sido comparado con sus elementos adyacentes y se han realizado los intercambios necesarios.

Este será el algoritmo Para i =1 hasta n haga si elemento[i] > elemento [i+1] haga

48

Temporal = Elemento[i] Elemento[i] = Elemento [i+1] Elemento [i+1] = Temporal fin si fin para Para poder realizar este intercambio no apoyamos en una variable temporal que permite almacenar uno de los valores por un periodo, para que no se pierda. Ahora miremos el código #include <stdio.h> #include <conio.h> #include <iostream.h> // Prototipos de las funciones. void MostrarVector(int *arreglo, int n); void burbuja(int *arreglo, int n); void main(void) { int n; // Numero de elementos del vector int i; // Contador int arreglo[100]; // Arreglo de enteros clrscr(); cout<<"Digite el numero de elementos < 100:"; cin>>n; for (i=0;i<n;i++) { cout<<"Digite valor para la posición :"<< i+1<<" "; cin>>arreglo[i]; } cout<<"\nVector Leido:\n"; MostrarVector(arreglo,n); cout<<"\nProcesamiento Burbuja:\n"; burbuja(arreglo, n); cout<<"\nVector Ordenado:\n"; MostrarVector(arreglo,n); getch(); } // Muestra en pantalla el vector

49

void MostrarVector(int *arreglo, int n) { int i; // Contador for (i=0;i<n;i++) cout<<arreglo[i]; cout<<"\n"; } // Ordenamiento por burbuja. void burbuja(int *arreglo, int n) { int i,j; // Contadores int temporal; // Variable para intercambio de contenidos for (i=0;i<n-1;i++) for (j=0;j<n-1;j++) if (arreglo[j]>arreglo[j+1]) { temporal=arreglo[j]; arreglo[j]=arreglo[j+1]; arreglo[j+1]=temporal; } }

Vamos Esta es nuestra lista:

4 - 3 - 5 - 2 - 1

Tenemos 5 elementos. Es decir, n toma el valor 5. Comenzamos comparando el primero con el segundo elemento. 4 es mayor que 3, así que intercambiamos. Ahora tenemos:

3 - 4 - 5 - 2 - 1

Ahora comparamos el segundo con el tercero: 4 es menor que 5, así que no hacemos nada. Continuamos con el tercero y el cuarto: 5 es mayor que 2. Intercambiamos y obtenemos:

3 - 4 - 2 - 5 - 1

Comparamos el cuarto y el quinto: 5 es mayor que 1. Intercambiamos nuevamente:

3 - 4 - 2 - 1 - 5

Repitiendo este proceso vamos obteniendo los siguientes resultados:

3 - 2 - 1 - 4 - 5

50

2 - 1 - 3 - 4 - 5

1 - 2 - 3 - 4 - 5

Nuevamente se sugiere la realización de nuevas pruebasa de escritorio para entender mejor el comportamiento de este programa También existen formas de mejorar la efectividad de este algoritmo, se le sugiere tratar de implementar soluciones que mejoren los procesos en este algoritmo 2.3.2.2 Ordenamiento por inserción En este tipo de algoritmo los elementos que van a ser ordenados son considerados uno a la vez. Cada elemento es INSERTADO en la posición apropiada con respecto al resto de los elementos ya ordenados. Así por ejemplo, si tenemos el vector

53 15 27 31 29 11 59 7 Podemos insertar el elemento 15 en la posición 1 y mover el 53 a la posición 2, con lo que tendríamos los dos primeros elementos ordenados como se aprecia en la ¡Error! No se encuentra el origen de la referencia..

15 53 27 31 29 11 59 7 Repitiendo el proceso anterior pero con la casilla 3, se puede observar que la sublista a la izquierda esta ordenada y los movimientos serían los que se aprecian en la ¡Error! No se encuentra el origen de la referencia..

15 53 27 31 29 11 59 7

Como resultado:

15 27 53 31 29 11 59 7 Como se puede observar el método se basa en comparaciones y desplazamientos sucesivos. El algoritmo de ordenación de un vector X para N elementos se realiza recorriendo el vector e insertando el elemento correspondiente en el lugar adecuado. De esto tenemos que el siguiente pseudocódigo nos da una idea general de la labor a realizar:

51

para i =2 hasta i = n haga Inserte X[i] en la posición adecuada entre X[1] y X[i-1] fin para El desarrollo de está operación de inserción se puede realizar en dos partes principales. La primera determinar en que lugar debe ir el elemento que se esta evaluado. lugar = i temporal = X[i] para j =1 hasta j = i - 1 haga si temporal < X[j] haga lugar = j salir para fin si fin para La segunda, empieza con preguntar si se debe mover el elemento y si es así se corren hacia la derecha del lugar de inserción, los elementos así: si lugar < i haga para j = i – 1 hasta j = lugar en decrementos de 1 haga X[j+1] = X[j] fin para X[lugar] = temporal fin si De esta forma el pseudocódigo final queda de la siguiente manera: para i =2 hasta i = n haga

lugar = i temporal = X[i] para j =1 hasta j = i - 1 haga si temporal < X[j] haga lugar = j salir para fin si fin para si lugar < i haga para j = i – 1 hasta j = lugar en decrementos de 1 haga X[j+1] = X[j] fin para X[lugar] = temporal fin si

fin para veamos el comportamiento del código

52

#include <stdio.h> #include <conio.h> #include <iostream.h> #define MAXNUM 100 // Prototipos de las funciones. void MostrarVector(int *arreglo, int n); void insercion(int *arreglo, int n); void main(void) { int n; // numero de elementos del vector int i; // Contador int arreglo[100]; // Arreglo de enteros clrscr(); cout<<"Digite el numero de elementos:"; cin>>n; for (i=0;i<n;i++) { cout<<"por favor escriba el valor en la posicion :" <<i+1; cin>>arreglo[i]; } cout<<"\nVector Leido:\n"; MostrarVector(arreglo,n); cout<<"\nOrdenamiento por inserción:\n"; insercion(arreglo, n); cout<<"\nVector Ordenado:\n"; MostrarVector(arreglo,n); getch(); } // función para mostrar por pantalla void MostrarVector(int *arreglo, int n) { int i; // Contador for (i=0;i<n;i++) cout<< arreglo[i]; cout<<"\n"; } // función que realiza el ordenamiento void insercion(int *arreglo, int n) { int i,j; // Contadores

53

int temporal; // Variable que conserva el elemento X[i] int lugar; // Variable del lugar donde se debe insertar for (i=1;i<n;i++) { lugar=i; temporal= arreglo[i]; for (j=0;j<=i-1;j++) { if (temporal<arreglo[j]) { lugar=j; break; } } if (lugar<i) { for (j=i-1;j>=lugar;j--) arreglo[j+1]=arreglo[j]; arreglo[lugar]=temporal; } } } 2.3.2.3 Ordenamiento Shell : Toma este nombre de su inventor Donald Shell, es como utilizar el ordenamiento burbuja pero comparando e intercambiando los elementos. La idea es seleccionar fragmentos de un arreglo para ser ordenados y ordenarlos por el método directo, Luego se cogen nuevos fragmentos hasta quedar ordenado por completo El algoritmo sera: salto = n div 2 mientras salto <> 0 haga repita

cambios = 0 para i ← 1 hasta n – salto haga si X[i] > X[i+salto] haga temporal = X[i] X[i] = X[i+salto] X[i+salto] = temporal cambios = 1 fin si fin para

hasta que cambios = 0 salto = saldo div 2

54

fin mientras Es momento de realizar la prueba de escritorio, consideremos el siguiente vector: 4 10 9 3 7 2 1 9 Decidimos ordenarlo en forma ascendente: Salto = 4 y es <> 0 Cambio = 0 I = 1

4 10 9 3 7 2 1 9 Como la condición no se cumple 4 no es mayor que siete, se incremente i y continúa el proceso Variable i = 2 4 10 9 3 7 2 1 9 Como podemos observar el número 10 si es mayor que el 2 por lo tanto hay un intercambio y el vector resultante es: 4 10 9 3 7 2 1 9 La variable cambios toma el valor de 1, el proceso continua hasta que i llega a n- salto, para el primer caso hasta 4, luego se divide nuevamente en 2 y luego en uno. Ahora miremos el código #include <stdio.h> #include <conio.h> #include <iostream.h> // Prototipos de las funciones. void MostrarVector(int *arreglo, int n); int shell(int *arreglo, int n); void main(void) { int n; // El numero de elementos del vector int i; // Contador int arreglo[100]; // Arreglo de enteros

55

clrscr(); cout<<"Digite el numero de elementos < 100:"; cin>>n; for (i=0;i<n;i++) { cout<<"digite valor para ["<<i+1<<"] "; cin>>arreglo[i]; } cout<<"\nVector Leido:\n"; MostrarVector(arreglo,n); cout<<"\nOrdenamiento por shell:\n"; cout<<"\n Numero iterciones" <<shell(arreglo, n); cout<<"\nVector Ordenado:\n"; MostrarVector(arreglo,n); getch(); } // Muestra en pantalla el vector void MostrarVector(int *arreglo, int n) { int i; // Contador for (i=0;i<n;i++) cout<< arreglo[i]<<" "; cout<<"\n"; } // Ordenamiento por shell. int shell(int *arreglo, int n) { int ciclos=0; // Contador de ciclos int i; // Contador int salto; // Variable para el tamaño del salto int temporal; // Variable para intercambio de contenidos int cambio; // Variable lógica para detener una iteración salto=n/2; while (salto!=0) { do { cambio=0; for(i=0;i<n-salto;i++) { ciclos++;

56

if(arreglo[i]>arreglo[i+salto]) { temporal=arreglo[i]; arreglo[i]=arreglo[i+salto]; arreglo[i+salto]=temporal; cambio=1; } } } while (cambio!=0); salto=salto/2; } return ciclos; }

2.3.2.4 Ordenación rápida (quicksort) : Algoritmo desarrollado por Charles Hoare propuesto en 1962. Este es el método de ordenamiento, que trae a mi mente viejos recuerdos, pues gracias a una exposición magistral de este método, me gane un cinco que necesita para pasar el curso de algoritmos en la U donde estudiaba, por el año de 1989 (hace rato.). Bueno dejemos los sentimentalismos con los algoritmos y al grano, es un método de ordenamiento, muy eficiente, a pesar de que han salido variaciones del mismo. El algoritmo consiste en: Proceso interativo. Para cada paso, se escoge un elemento "a" de alguna posición específica dentro del arreglo. Ese elemento "a" es el que se procederá a colocar en el lugar que le corresponda. Por conveniencia se seleccionará a "a" como el primer elemento del arreglo. El elemento "a" se procede a comparar con el resto de los elementos del arreglo. Una forma puede ser: comparar "a" con el ultimo elemento del arreglo. En la comparación, si el elemento "a" toma la ultima posición y el último elemento toma la posición 1 se procede a seguir comparando a "a" pero ahora con el segundo elemento. Si "a" resulta ser menor que el segundo elemento se hace el intercambio y se procede a comparar "a" con el penúltimo y así sucesivamente hasta que "a" se compara con todos los elementos restantes del arreglo. Note que cada vez que ocurre un intercambio de valores, la comparación de "a" se hace con los elementos del arreglo que se encuentran en posición contraria a la que se está haciendo. Una vez que se terminó de comparar "a" con todos los elementos, "a" ya se encuentra en su lugar y a la izquierda de "a" quedan todos los elementos menores a él y a su derecha todos los mayores. Se toma el sub-arreglo izquierdo (los menores de "a") y se realiza el mismo procedimiento. Se toma el sub-arreglo derecho (los mayores de "a") y se realiza el mismo procedimiento. Este proceso se realiza hasta que los sub-arreglos sean de un elemento. Vemos gráficamente tomado el siguiente vector 43 2 90 52 87 100 -10 68 13 7 21 45

57

Las variables izq (izquierda) y der (derecha), una variable para controlar el punto pívot (pivote), que se puede mirar su comportamiento en los extremos resaltados Izq

der 0

1

2

3

4

5

6

7

8

9

10

11

12

PosPiv Pivote

0 11 43 2 90 50 87 100 -10 68 13 7 21 45 50 0 43

En este caso la posición más a la izquierda es 0, la más a la derecha es 12, se escoge como "pivote" el primer término de la lista, es decir la posición más a la izquierda, tal como está escrito en la tabla anterior. Se procede a comparar el pivote, 43, con el valor más a la derecha, posición 12 cuyo valor es 50. Se verifica que 43 y 50 están en posiciones relativas, ascendentemente, adecuadas, por esto comenzamos a movernos a la izquierda, decrementando der, así: Izq

der 0

1

2

3

4

5

6

7

8

9

10

11

12

PosPiv Pivote

0 11 43 2 90 50 87 100 -10 68 13 7 21 45 50 0 43

Se compara ahora el pivote 43, en posición cero, con el número en posición der=11, es decir 45, nuevamente están en posiciones relativas adecuadas a nuestro ordenamiento ascendente, por esto se decremento derecha (Der--): Izq

der 0

1

2

3

4

5

6

7

8

9

10

11

12

PosPiv Pivote

0 11 43 2 90 50 87 100 -10 68 13 7 21 45 50 0 43

Se compara ahora 43 con 21 de la posición der=10, no están en posiciones relativas ordenadas, se procederá entonces a su intercambio, quedando el vector, paso a paso así: Izq

der 0

1

2

3

4

5

6

7

8

9

10

11

12

PosPiv Pivote

21

2 90 50 87 100 -10 68 13 7 21 45 50 0 10

21

2 90 50 87 100 -10 68 13 7 43 45 50

0 10

43

58

Se actualiza la posición del pivote, ahora está en 10, y se comienza a comparar desde la izquierda, como lo señala la flecha en la tabla anterior. Así se compara 43 con 21, los cuales están en posiciones relativas adecuadas: Izq

der 0

1

2

3

4

5

6

7

8

9

10

11

12

PosPiv Pivote

1 10 21 2 90 50 87 100 -10 68 13 7 43 45 50 10 43

Por esto se incrementa izquierda y se compara el 43 con el 2, igualmente están en orden ascendente relativo; se incrementa izquierda nuevamente llegando a donde está el número 90 en la posición 2 del vector: Izq

der 0

1

2

3

4

5

6

7

8

9

10

11

12

PosPiv Pivote

2 10 21 2 90 50 87 100 -10 68 13 7 43 45 50 10 43

El 90 al compararlo con el pivote 43 es mayor, por esto deberán ser intercambiados, y actualizada la posición del pivote: Izq

der 0

1

2

3

4

5

6

7

8

9

10

11

12

PosPiv Pivote

21

2 90 50 87 100 -10 68 13 7 90 45 50 0 10

21

2 43 50 87 100 -10 68 13 7 90 45 50

10 2

43

Siguiendo este proceso se obtiene la siguiente secuencia de posiciones: Izq

der 0

1

2

3

4

5

6

7

8

9

10

11

12

PosPiv Pivote

2 9 21 2 43 50 87 100 -10 68 13 7 90 45 50 2 43

Izq

der 0

1

2

3

4

5

6

7

8

9

10

11

12

PosPiv Pivote

21

2 7 50 87 100 -10 68 13 7 90 45 50 2 9

21

2 7 50 87 100 -10 68 13 43 90 45 50

2 9

43

59

Izq

der 0

1

2

3

4

5

6

7

8

9

10

11

12

PosPiv Pivote

3 9 21 2 7 50 87 100 -10 68 13 43 90 45 50 9 43

Izq

der 0

1

2

3

4

5

6

7

8

9

10

11

12

PosPiv Pivote

21

2 7 50 87 100 -10 68 13 50 90 45 50 3 9

21

2 7 43 87 100 -10 68 13 50 90 45 50

9 3

43

Izq

der 0

1

2

3

4

5

6

7

8

9

10

11

12

PosPiv Pivote

3 8 21 2 7 43 87 100 -10 68 13 50 90 45 50 3 43

Izq

der 0

1

2

3

4

5

6

7

8

9

10

11

12

PosPiv Pivote

21

2 7 13 87 100 -10 68 13 50 90 45 50 3 8

21

2 7 13 87 100 -10 68 43 50 90 45 50

3 8

43

Izq

der 0

1

2

3

4

5

6

7

8

9

10

11

12

PosPiv Pivote

4 8 21 2 7 13 87 100 -10 68 43 50 90 45 50 8 43

Izq

der 0

1

2

3

4

5

6

7

8

9

10

11

12

PosPiv Pivote

21

2 7 13 87 100 -10 68 87 50 90 45 50 4 8

21

2 7 13 43 100 -10 68 87 50 90 45 50

8 4

43

Izq

der 0

1

2

3

4

5

6

7

8

9

10

11

12

PosPiv Pivote

4 7 21 2 7 13 43 100 -10 68 87 50 90 45 50 4 43

Izq

der 0

1

2

3

4

5

6

7

8

9

10

11

12

PosPiv Pivote

4 6 21 2 7 13 43 100 -10 68 87 50 90 45 50 4 43

60

Izq

der 0

1

2

3

4

5

6

7

8

9

10

11

12

PosPiv Pivote

21

2 7 13 -10 100 -10 68 87 50 90 45 50 4 6

21

2 7 13 -10 100 43 68 87 50 90 45 50

4 6

43

Izq

der 0

1

2

3

4

5

6

7

8

9

10

11

12

PosPiv Pivote

5 6 21 2 7 13 -10 100 43 68 87 50 90 45 50 6 43

Izq

der 0

1

2

3

4

5

6

7

8

9

10

11

12

PosPiv Pivote

21

2 7 13 -10 100 100 68 87 50 90 45 50 5 6

21

2 7 13 -10 43 100 68 87 50 90 45 50

6 5

43

Al avanzar desde la derecha hacia la izquierda, la variable der se encuentra con la posición donde está el pivote, e izq ya estaba en el mismo valor, es decir las tres variables "se encuentran en el mismo sitio", así: Izq

der 0

1

2

3

4

5

6

7

8

9

10

11

12

PosPiv Pivote

5 5 21 2 7 13 -10 43 100 68 87 50 90 45 50 5 43

Se observa que el valor del pivote, 43, está en el sitio que le corresponde en ordenamiento ascendente, y que a su izquierda se forma una sublista, desordenada, desde la posición 0 a la 4, con todos sus elementos menores; y una sublista a la derecha, desde la posición 6 hasta la 12, en desorden y con todos mayores que el pivote. A partir de este punto se procede con el mismo procedimiento sequido para la lista completa, en cada una de las sublistas y por separado Con lo anterior podemos describir el siguiente algoritmo para que usted mediante una prueba de escritorio verifique que hace #include <stdio.h> #include <conio.h> #include <iostream.h>

61

// Prototipos de las funciones. void MostrarVector(int *arreglo, int n); void QuickSort(int *arreglo, int l, int r); void intercambiar(int *arreglo, int pos1, int pos2); void main(void) { int n; // numero de elementos del vector int i; // Contador int arreglo[100]; // Arreglo de enteros clrscr(); cout<<"Digite el numero de elementos:"; cin>>n; for (i=0;i<n;i++) { cout<<"Digite valor para la posicion :[" <<i+1<<"] "; cin>>arreglo[i]; } cout<<"\nVector Leido:\n"; MostrarVector(arreglo,n); cout<<"\nOrdenamiento por QuickSort:\n"; QuickSort(arreglo,0,n-1); cout<<"\nVector Ordenado:\n"; MostrarVector(arreglo,n); getch(); } // Muestra en pantalla el vector void MostrarVector(int *arreglo, int n) { int i; // Contador for (i=0;i<n;i++) cout<<arreglo[i]<< " "; cout<<"\n"; } // Ordenamiento QuickSort. void QuickSort(int *arreglo, int izquierda, int derecha) { int mayor; // Posicion de un elemento mayor al pivote int menor; // Posicion de un elemento menor al pivote int pivote; // Elemento pivote

62

if (izquierda < derecha) { pivote = arreglo[derecha]; mayor = izquierda-1; menor = derecha; while (mayor <= menor) { while (mayor <= derecha) { mayor++; if (arreglo[mayor] >= pivote) break; } while (menor >= izquierda) { menor--; if (arreglo[menor] <= pivote) break; } if (mayor < menor) intercambiar(arreglo,mayor,menor); } intercambiar(arreglo,derecha,mayor); QuickSort(arreglo,izquierda,mayor-1); QuickSort(arreglo,mayor+1,derecha); } } void intercambiar(int arreglo[], int pos1, int pos2) { int temporal; // Variable para intercambio de contenidos temporal = arreglo[pos1]; arreglo[pos1] = arreglo[pos2]; arreglo[pos2] = temporal; } Bueno solo queda que usted que es una persona muy “pila”, indague más acerca de estos métodos, tanto de búsqueda como de ordenamiento , o realice nuevas mejoras a estos programas aquí desarrollados. /*******

63

Ejercicios de verificación 1: Recopilación de preguntas de selección múltiple con única respuesta

A. Propósito principal de un ordenamiento es

a. Facilitar las búsquedass de los miembros de un conjunto ordenado b. Buscar los elementos de un conjunto c. Ordenar en base a su valor

B. Cuando es conveniente usar los ordenamientos

a. Cuando se requiere hacer una cantidad considerable de búsquedas b. Cuando se tienen varios directorios c. Cuando se considera el factor del tiempo

C. En este tipo de algoritmos cada elemento es comparado contra los demás

a. Algoritmo de enumeración b. Algoritmo de inserción c. Algoritmo de intercambio

D. En este algoritmo los elementos que van a ser ordenados son considerados uno a la vez

a. Algoritmo de burbuja b. Algoritmo de shell c. Algoritmos de insercción

E. Compara cada elemento del arreglo con el siguiente, si el elemento es mayor que el se sigue, entonces surge un intercambio.

a. Método de Burbuja b. Método de Quicksort c. Método de Shell

F. Este tipo de algoritmos se selecciona o se busca el elemento más pequeño o más grande de todo el conjunto de elementos y se coloca en la posición adecuada

a. Algoritmo de Shell b. Algoritmo de selección c. Algoritmo de selección directa

64

G. Este ordenamiento lleva elnombre de su inventor

a. Ordenamiento Quicksort b. Ordenamiento de Burbuja c. Ordenamiento de Shell

2) deduzca, indague, consulte, cuales son las ventajas y/o desventajas de los métodos de búsqueda y ordenamiento aquí expuestos 3) Realice un programa que permita introducir en un arreglo de n elementos valores de tipo entero y a través de un menú, realizar las siguientes funciones:

1. Ingreso de datos 2. Búsqueda 3. Ordenamiento 4. Estadística 5. Salir

En cada uno de los menús se incluirá, un segundo submenú, por ejemplo el item número

3 Ordenamiento pude incluir los metodos de • Por burbuja • Por inserción

….. Y así sucesivamente, en el menú estadista, se debe presentar un informe de la cantidad de iteraciones que cumple una opción de las anteriores.

65

0 1 2 3 4 5

Fila

0 1 2 3 4 5

columna

Celda (3,5)

3.3 Matrices o arreglos bidimensionales: Por que mostrar una imagen de una hoja de calculo (Excel), como inicio de este apartado, es simple es el ejemplo típico de una matriz, como se observa esta dividido en filas y columnas, y cada posición se lo conoce como celda, de igual manera se comporta una matriz en c++, solo que las columnas no están identificadas con letras sino con números al igual que las filas. Entonces podemos decir que las matrices “es una colección de localidades asociadas a un nombre, sólo que los datos se organizan en dos dimensiones”. Por ello, para hacer referencia a una localidad del arreglo se necesitan de dos números:

– El número de la fila . – El número de columna.

Por consiguiente la lectura de la posición de la matriz se hace fila columna, de acuerdo al siguiente grafico.

0

1

2

3

0 1 2 3 A[0][0] A[0][1] A[0][2] A[0][3]

A[1][0] A[1][1] A[1][2] A[1][3]

A[2][0] A[2][1] A[2][2] A[2][3]

A[3][0] A[3][1] A[3][2] A[3][3]

El primer índice siempre indica las filas

El segundo índice siempre indica las columnas

66

Realicemos un ejemplo, para entender mejor : Se lee un arreglo bidimensional por teclado y luego se muestra en pantalla adecuadamente. #include <iostream.h> #include <iomanip.h> #include <conio.h> const int MaxFilas=5; const int MaxColumnas=4; void main(){ int fila, columna, MATRIZ[MaxFilas][MaxColumnas]; clrscr(); for ( fila = 0; fila < MaxFilas; fila++) for ( columna = 0; columna < MaxColumnas; columna++) { cout << "Posición: (" << fila << "," << columna << "): "; cin >> MATRIZ[fila][columna]; } clrscr(); for ( fila = 0; fila < MaxFilas; fila++) { for ( columna = 0; columna < MaxColumnas; columna++) cout << setw(6) << MATRIZ[fila][columna]; cout << endl; } } Explicación 1.- se han definido 2 constantes que permiten el control de una matriz en el tamaño de sus filas y columnas 2.-se define una matriz o array de 5 filas por 4 columnas 3.-se hace necesario utilizar 2 ciclos para hacer recorrido a una matriz, uno de los ciclos controla las filas y el otro las columnas, dependiendo de que queramos hacer, se pude controlar primero las filas y luego las columnas o viceversa 3.-nuevamente se utilizan otros dos ciclos para mostrar por pantalla los arreglos antes leídos Eso es todo Como podemos ver las matrices se comportan como vectores solo que están divididos en filas y columnas, por consiguiente siempre están acompañados de dos arreglos Realicemos otro código de ejemplo: Una matriz A de orden MxN es generada al azar y luego se intercambian sus filas y columnas en otra matriz B de orden NxM.

67

#include <iostream.h> #include <iomanip.h> #include <conio.h> #include <stdlib.h> const int MaxM=10; const int MaxN=8; void main(){ int i, M, j, N; float A[MaxM][MaxN], B[MaxN][MaxM]; clrscr(); do{ cout << "Digite el número para M deseado (Máximo " << MaxM << "): "; cin >> M; } while (M<1 && M>MaxM); do{ cout << "Número para N deseado (Máximo " << MaxN << "): "; cin >> N; } while (N<1 && N>MaxN); randomize(); cout << "\nMATRIZ A:\n"; for ( i = 0; i < M; i++) { for ( j = 0; j < N; j++) { A[i][j] = random(100); cout << setw(5) << A[i][j]; } cout << endl; } for ( i = 0; i < M; i++) for ( j = 0; j < N; j++) B[j][i] = A[i][j]; cout << "\nMATRIZ B:\n"; for ( j = 0; j < N; j++) { // j recorre las filas for ( i = 0; i < M; i++) // i recorre las columnas cout << setw(5) << B[j][i]; cout << endl; } getch(); }

68

Es importante que usted realice la prueba de escritorio para este ejemplo antes de codificarlo, para conceptualizar cada una de las partes del mismo Ejercicios de verificación 1. Realizar un programa que almacene números en una matriz de 5 * 6. Imprimir la suma de cada una de las filas de la matriz. 2. Hacer un programa que llene una matriz de 10 * 10 y determine la posición [renglón, columna] del número mayor almacenado en la matriz. 3. Implementar un programa que llene una matriz de 7 * 7. Calcular la suma de cada fila y almacenarla en un vector, la suma de cada columna y almacenarla en otro vector. 4. Elaborar un programa que llene una matriz de 20 * 20. Sumar las columnas e imprimir que columna tuvo la máxima suma y la suma de esa columna. 5. Originar un programa que llene una matriz de 5 * 5 y que almacene la diagonal principal en un vector. Imprimir el vector resultante. 6. Producir un programa que llene una matriz de 10 * 10 y que almacene en la diagonal principal unos y en las demás posiciones ceros. 7. se desea hacer un programa que llene una matriz de 6 * 8 y que almacene toda la matriz en un vector. Imprimir el vector resultante. 8. Hacer un algoritmo y programa que llene una matriz de 8 * 8, que almacene la suma de las filas y la suma de las columnas en un vector. Imprimir el vector resultante. 9. Hacer un algoritmo y programa que llene una matriz de 5 * 6 y que imprima cuantos de los números almacenados son ceros, cuantos son positivos y cuantos son negativos. 10. Diseñe un programa que escriba el número de la hilera cuya suma sea mayor que las demás hileras. Suponga que todas las hileras suman diferente cantidad. 11. El dueño de una cadena de tiendas de artículos deportivos desea controlar sus ventas por medio de una computadora. Los datos de entrada son:

a) El numero de la tienda (1 a 50) b) Un numero que indica el deporte del articulo (1 a 20) c) El costo del artículo. Al final del día el programa imprime lo siguiente: 1. Las ventas totales en el día para cada tienda 2. Las ventas totales para cada uno de los deportes. 3. Las ventas totales de todas las tiendas.

69

12. Se tiene almacenada la matriz M (50,5) la cuál contiene la información sobre las calificaciones de la materia de introducción a la programación. Diseñe un programa que imprima: a) Cantidad de alumnos que aprobaron la materia. b) Cantidad de alumnos que tienen derecho a nivelación. c) El (o los) numero (s) de control de lo(s) alumno(s) que haya (n) obtenido la máxima calificación final. 14 realizar la multiplicación de dos matrices (tenga en cuenta las reglas para la multiplicación de matrices) 13 existe un ejercicio que me gusta mucho, es el problema de los movimientos de posibles que tiene un caballo en un tablero de ajedrez, recordemos que los caballos en este juego hace movimientos en forma de L, la idea del ejercicio es que a partir de una posición dada el caballo pueda desplazarse lo más lejos posible, de ahí en adelante usted podrá realizar mucha variaciones al ejercicio

70

3.0 UNIDAD NÚMERO 3 3.1 ESTRUCTURAS Y ARCHIVOS Hasta el momento solo hemos trabajado con datos de un uncí tipo o ilimitados en tamaño, afortunadamente los lenguajes de programación y C++ para se preciso dejan al usuario construir o combinar diversidad de datos para conformar estructuras complejas de información, esto será la primera parte, pero la segunda es la más importante, si ustedes se han dado cuenta hasta el momento solo hemos trabajado a nivel de memoria, es decir todo funciona si el programa se esta ejecutando, pero en el momento que deja de ejecutarse, se pierde toda la información en el almacenada, la solución llega con la construcción de estructuras que se puedan almacenar y acceder en forma de archivos. 1.2 intencionalidades formativas: Determinar los mecanismos que se utilizan para combinar diferentes tipos de datos Propósitos de la unidad

• Manipular diversidad de datos en forma simultanea • Grabar datos en unidades de almacenamiento físicas

Objetivos de la unidad

• Desarrollar programas que manipulen cantidad de datos de diferentes tipos y que puedan almacenarse y recuperase en cualquier momento

Competencias de la unidad:

• Dominar el manejo de estructuras con diversidad de datos • Comprender como es que se escriben datos en medios fiscos

Metas de aprendizaje • Realizar programas que presten un verdadero servicio, cuando se trate de

guardar infamación UNIDADES DIDÁCTICAS: Palabras claves: Archivos Ficheros Estructuras 3.1.1 Estructuras:

71

Las estructuras están compuestas como ya dijimos por una serie de componentes individuales llamados miembros, para hacerlo más grafico podemos decir que queremos ingresar datos de una persona como su nombre, apellido, dirección, salario, edad… cada miembro de la estructura es de dato diferente, una estructura no tiene restricciones para contener un número determinado de miembros, e inclusive podemos realizar estructuras que contengan otras estructuras.. Veamos un ejemplo: Se desea llevar los datos de una colección de películas, para ello tenemos: Titulo, Protagonista Genero Precio Fecha de compra Para este ejemplo encontramos cinco miembros, ahora debemos deducir que tipo de datos contiene cada uno de ellos. Miembro Tipo Titulo Vector de 30 caracteres titulo [30] Protagonista Vector de 30 caracteres prota [30] Genero Vector de 10 caracteres genero [10] Precio float Fecha de compra Vector de 10 caracteres fecha [10] Si tenemos datos quedara así Miembro Dato Titulo Corto circuito Protagonista Alambrito Genero Acción Precio 25.580 Fecha de compra 01/01/05 Bien pero como se declara en un programa, Sencillo Struct película { char titulo[30]; char prota[30]; char genero[10]; float precio; char fecha[10]; } Nombre; // variable que refiere a la estructura

72

Lo mejor es hacerlo con la codificación real de un ejercicio, supongamos que deseamos llevar los datos de básicos de un empleado #include <iostream.h> void main(){ const int Max=20; struct registro { char nombre[Max]; int edad; float salario; } empleado; cout << "Digite su nombre: "; cin >> empleado.nombre; cout << "Digite su edad: "; cin >> empleado.edad; cout << "Digite su salario: "; cin >> empleado.salario;

cout << "\n\nNombre: " << empleado.nombre << "\nSalario: $ " << empleado.salario cout<< "\nedad: " << empleado.edad << " años";

} Explicación 1.- creamos una estructura llamada registro con los miembros nombre, edad, salario. 2.- una variable empleado que de tipo registro 3. – observemos que cada vez que hacemos referencia a un miembro de la estructura l hacemos a través de la variable (empleado), separandolo con un punto Miremos otro ejemplo, ahora almacenamos los datos de la estructura en un vector #include <iostream.h> #include <conio.h> const int Max=100; struct registro { char nombre[20]; int edad; float salario; } amigos[Max]; // permite almacenar máximo 100 datos para este caso void main(){

73

int num_reg = 0, i; cout <<"Cuántos amigos desea introducir? (máximo " <<Max <<") "; cin >> num_reg; for (i=0;i<num_reg;++i) { cout << "Registro : " << i << "\n"; cout << " Salario: "; cin >> amigos[i].salario; cout << " Nombre : "; cin >> amigos[i].nombre; cout << " Edad : "; cin >> amigos[i].edad; } clrscr(); cout << "��\n"; for (i=0; i<num_reg; ++i) cout << i+1 << " " << amigos[i].nombre << " " << amigos[i].edad << " " << amigos[i].salario << endl; cout << "��\n"; } Es interesante a realizar la prueba de escritorio de este ejercicio Ejerció de verificación 1.- tomar el programa anterior y aplicar alguno de los métodos de búsqueda y ordenación. /**

74

Pero bien lo que hemos realizado hasta el momento es agrupar diversos datos, pero igual, cuando se termina de ejecutar el programa, los datos se han perdido, la forma de solucionar este problema es mediante la utilización de archivos 3.2.1 Archivos o ficheros: Es el mecanismo que nos proporcionan los lenguajes de programación, para almacenar gran cantidad de datos en medios físicos, (disco duro, disquetes, cd rom…), antes de iniciar con la construcción de algoritmos o programas es importante manejar algunos conceptos básicos referentes a este tema, entre ellos están:

DATO: Unidad lógica de información que se suministra a la computadora, para el funcionamiento de un sistema de información.

INFORMACIÓN: Conjunto de datos o noticias de un tema específico.

SISTEMA: Conjunto de elementos independientes, conjunto de axiomas y reglas que determinan un perfecto desarrollo de sus funciones.

Programa que formando parte de un Sistema Operativo permite el manejo de archivos de una manera transparente, es decir sin tener en cuenta el tipo de unidad en las que este se encuentre.

REGISTRO: Está compuesto de campos y estos campos contienen los atributos de una Entidad.

ENTIDAD: Todo aquello de lo cual podemos obtener información, la información obtenida de una entidad son los atributos. Esto puede ser de forma tangible o intangible. La información obtenida de una entidad son los atributos.

ATRIBUTOS: Medida, peso, color, etc. (características).

CAMPO: Zona de información definida en una memoria.

La descripción de los datos y las de las relaciones que entre ellas hay, adopta una de las dos formas, lógica y física.

DATO FÍSICO: La descripción física de los datos se ocupan de como se los registro el Hardware.

DATO LÓGICO: La descripción lógica, en cambio se refiere a la forma con que los datos se presentan al programador de aplicaciones al usuario final.

75

Clasificación de los archivos

En base a su función, existen 6 tipos básicos de archivos clasificados por la función que desempeñan en un sistema de información

ARCHIVO MAESTRO.

ARCHIVO DE TRANSACCIONES.

ARCHIVO DE REPORTE.

ARCHIVO DE TRABAJO.

ARCHIVO DE PROGRAMA.

ARCHIVO DE TEXTO.

ARCHIVO MAESTRO: Representa una visión estática de algún aspecto de los negocios de una organización en un momento dado. Un Registro en un archivo maestro registra el estado de alguno de sus componentes. Ejemplo: los pagos efectuados a un empleado

Un archivo maestro contiene datos relativamente permanentes o datos de estados históricos. Los cambios que han de ser aplicados al archivo maestro, son recolectados en un archivo de transacciones.

ARCHIVO DE TRANSACIONES: Puede contener datos para agregar un nuevo registro o para borrar, modificar un registro maestro. Cada registro en un archivo de transacciones representa un vento a un cambio de alguna cosa, esto sucede permanentemente, en las aplicaciones comunes, por ejemplo modificaciones en un editor de texto o en una hoja de cálculo

ARCHIVO DE REPORTE: Contiene datos que son formateados para su representación al usuario; ejemplo: Archivo de reporte de una nomina

ARCHIVO DE TRABAJO: Es un archivo temporal en el sistema, no tiene las características de E/S de un archivo de transacciones de reporte; ejemplo: Archivo de trabajo para el ordenamiento de empleados.

El archivo de trabajo se usa comúnmente para pasar datos creados por un programa a otro programa.

ARCHIVO DE PROGRAMA: Contiene instrucciones para procesar datos, las cuales pueden almacenarse en otros archivos o recibir en la memoria principal.

76

Ejemplo: El código de un lenguaje: de alto nivel (lenguaje c, c++, etc), lenguaje ensamblador, lenguaje máquina.

ARCHIVO TEXTO: Contiene datos alfanuméricos y gráficos ingresados a través de un editor de texto. Block de notas

En general C++ proporciona la manipulación de tantos tipos de archivos como tipos de datos existen,

El paquete Standard de input/output de "C" y por ende de C++, hace disponible 4 métodos o maneras diferentes de leer y escribir los datos a disco.

1.- Datos a ser grabados o leídos como un carácter a la vez, se utilizaran funciones análogas a getchar y putchar.

2.- Datos que pueden ser leídos o grabados como una string se usaran funciones analogas a gets y puts.

3.- Datos que se capturen o desplieguen con formatos parecidos a los usados por scanf y printf se usaran funciones similares, es decir serán problemas que involucran mezclas de strings, caracteres, floats, etc.

4.- También se podrán leer y escribir datos de tipo arreglo y registros utilizando instrucciones apropiadas, en resumen:

carácter string Formateado Registros y arreglos

Leer getc() fgets() fscanf() fread()

Escribir putc() fputs() fprintf() fwrite()

Almacenamiento en archivos

En este curso trabajaremos dos métodos de almacenamiento:

Modo Texto: en este caso los datos son almacenados usando Ascii y por tanto son plenamente visibles usando cualquier editor.

Modo Binario: en este caso los datos son almacenados en notación hexadecimal y por tanto se ocupa un editor binario para reconocerlos, sin embargo un archivo binario es mas compacto que un archivo texto.

77

3.2.1.1Operaciones con Archivos

Existen muchas operaciones asociadas a archivos en c++, las más elementales son:

1.- Creación de Archivo.- En este proceso se pretende solamente crear un archivo nuevo en disco con su nombre, tipo y especialidad de almacenamiento de datos apropiado. archdisco = fopen("c:\\ac\\alumnos.dat","w");

2.- Apertura de Archivos.- En este caso se pretende abrir un archivo ya existente en disco para procesarlo ya sea para cargar, grabar o modificar estructuras en sus registros o leer algún registro en especial para ser manipulado de acuerdo a la necesidad del usuario

Observación: No confundir creación con apertura, creación es un proceso que solo se ejecuta una sola vez en la vida de un archivo, si se ejecuta más de una vez los datos del archivo se pierden, mientras que apertura, siempre se esta realizando por los programas especializados en algún proceso.

3.-Cierre de archivos: Es la operación más importante en cualquier programa que maneje archivos, de no cerrar los archivos existe mucha probabilidad que se pierdan los datos.

4.-Altas en archivo.- En este proceso se captura una estructura en memoria con sus datos pertinentes y después se graba la estructura al archivo en disco.

5.-Lectura de archivo.- En este proceso se abre el archivo, se manda el registro de disco a una estructura en memoria para su procesamiento.

6.- Consulta de archivos: En este proceso se pretende desplegar todos los registros del archivo en disco a la pantalla. o a otro dispositivo como la impresora

7.-Búsqueda en archivos: Una de las operaciones más comunes consiste en que el usuario pide toda la información de algún registro,.

8.- Filtros.- En este proceso el usuario esta interesado en algún conjunto de registros con características comunes (condición), por ejemplo todos los alumnos de "introducción a la programación" que tengan notas promedio superiores a 4.5 o todos los empleados que ganen mas de $5500.00 pesos,

9.-Modificaciones de registros o archivos: Problema muy común, donde los datos originales ya grabados se tienen que cambiar o actualizar, por ejemplo el nombre no era "Pedro" sino "José", o la calificación no es 3.5 si no 2.0, ..

78

10.- Bajas de registros: también muy común este proceso, por ejemplo el alumno deserto, el cliente se fue del país…

3.2.1.2 Archivos tipo texto

Trabajemos un ejemplo para determinar como se realiza la creación física de un archivo tipo texto:

#include <stdio.h> #include <conio.h> #include <string.h> #include <iostream.h> struct { int matricula; char nombre[30]; int edad;}alumno; void main() { clrscr(); //creando y cerrando el archivo en disco FILE *archivo; archivo = fopen("c:\\ac\\alumnos.dat","w"); fclose(archivo); cout<<”ARCHIVO CREADOSATISFACTORIAMENTE”; getchar();getchar();

}

Al momento de ejecutarlo

Lo primero que se crea es una variable de tipo puntero o apuntador a un archivo en el disco (instrucción FILE y debe ser en MAYUSCULAS) llamada archivo

Variables apuntadores son tipos especiales de variables que tienen la capacidad de almacenar n datos, pero si direcciones ya sean de la memoria del computador o como en este caso de una dirección física del disco.

79

En "C++" una variable apuntador se declara anteponiendo un asterisco antes del nombre, como ya lo vimos en el apartado de apuntadores (recuerdan)

En el programa se está creando una variable apuntador bautizada con el nombre de archivo (original no) que almacenara la dirección física de el archivo en disco,

Como segundo paso se abre el archivo con la instrucción fopen():

archivo = fopen("c:\\a1212c\\alumnos.dat","w");

Observar que el path es la dirección física en el disco del computador .

Observar el doble diagonal (\\) en el parámetro.

La función fopen() cuando realiza el trabajo de abrir un archivo, regresa la dirección física donde crea o graba el archivo en disco.

El primer parámetro o argumento en esta función es la unidad de disco y el nombre del archivo.

El segundo parámetro o argumento es llamado modo y es una de los varios modos que podemos usar.

"r" ----> Lectura.

"w" ----> Escritura.

"a" ----> Append, si el archivo ya existe append empieza a añadir los nuevos datos al final del archivo ya existente.

"r+" ---> Lectura y escritura, ya debe existir el archivo.

"w+" ---> Crea para lectura y escritura y si ya existe, sobreescribe.

"a+" ---> Crea o abre para lectura y append, sino existe el archivo será creado.

Existen dos caracteres que permiten determinar el tipo de archivo que estamos creando, pero insertándolo antes del signo +

Modo significado.

t lo abre en modo texto.

b lo abre en modo binario.

Cuando se ha finalizado de escribir al archivo se debe cerrar y esto se hace con la instrucción:

80

fclose(archivo);

Las funciones para manipular los Archivos se encuentran en el archivo de cabecera <stdio.h> y vale la pena mencionarlos:

Función Descripción

fopen() Abre un flujo

fclose() Cierra un flujo

Putc Escribe un carácter en un flujo

getc() Lee un carácter desde un flujo

fputs() Escribe una cadena en un flujo

fgets() Obtiene una cadena de un flujo

fseek() Salta al byte especificado en un flujo

fprintf() Imprime datos con formato en un flujo

fscanf() Lee datos con formato en un flujo

eof() Devuelve verdadero o falso si se halla el fin del archivo.

Miremos el siguiente programa que graba registros básicos de un estudiante, #include <stdio.h> #include <conio.h> #include <string.h>

Si usted ya transcribió el código, lo más seguro es que no haya realizado nada, pero le pregunto, tiene el directorio en su disco llamado ac ?.. Lo sabia NO, pues ahora cree ese directorio o carpeta (ojo en la raíz de la estructura del disco) y vuelva a correr el programa, ahora mire la carpeta y debe tener un archivo creado, si esto es así, puede anotarse un punto en su portafolio

81

struct { int matricula; char nombre[30]; int edad;} alumno; void main() { clrscr(); // captura de campos printf("Numero de matricula :"); scanf("%d",&alumno.matricula);getchar(); printf("Nombres :"); gets(alumno.nombre); printf("Edad :"); scanf("%d",&alumno.edad); // grabando a disco FILE *archdisco; archdisco = fopen("c:\\ac\\alumnos.dat","at+"); fwrite(&alumno,sizeof(alumno),1,archdisco); fclose(archdisco); //avisando usuario printf("alumno insertado"); getchar();getchar(); } Observemos: Con respecto al primer ejercicio, 1.- la función fopen(), cambia de w a at+ como miramos en la tabla, esto permite abrir el archivo para agregar datos. 2.- lo nuevo es la utilización de fwrite(&persona,sizeof(alumno),1,archdisco); Como se observa ocupa 4 parámetros que son:

1.- fwrite() ocupa primero conocer cuales datos va a almacenar en disco, aquí se le esta indicando que es el dato que se tiene en la dirección de memoria donde esta el registro "alumno".

82

2.- fwrite(), ocupa conocer cuantos bytes de información debe grabar, para esto se tienen dos opciones o se le da el valor exacto por ejemplo 64 bytes o 39 bytes o mas facil aun se usa sizeof() que regresa el tamaño del dato.

3.-fwrite(), necesita conocer también cuantas estructuras o registros a la vez debe grabar por lo general es un solo registro, pero mas adelante estudiaran que es posible grabar mas de un registro a la vez y esto es de mucho provecho, porque por ejemplo si en un sistema se ocupa grabar 1000 registros y usamos fwrite() de uno en uno, quiere decir que habría mil accesos a disco.

4.-fwrite() también ocupa conocer exactamente en que cluster, sector y byte exacto del disco duro debe grabar el registro, la primera opción seria desarmar el disco duro y ver donde hay lugar para poner el archivo X o mejor aun usar la variable archdisco que ya tiene esa dirección física del archivo en disco.

Ya sabemos como se crean archivos, como se ingresan datos, lo único que queda es como recuperar la información, eso lo haremos con otro ejemplo:

#include <stdio.h> #include <conio.h> #include <string.h> struct { int matricula; char nombre[30]; int edad;} alumno; void main() { clrscr(); // leyendo disco FILE *archdisco; archdisco = fopen("c:\\ac\\alumnos.dat","at+"); // aqui siempre debe empezar el ciclo de lectura // y fread() regresa siempre cuantas estructuras leyo while(fread(&alumno,sizeof(alumno),1,archdisco)==1) { // desplegando estructuras printf("MATRICULA =%d ",alumno.matricula); printf(" NOMBRE =%s ",alumno.nombre); printf(" MESES =%d ",alumno.edad); printf("\n"); }; // aqui termina while // no olvidar cerrar archivo y siempre fuera de while

83

fclose(archdisco); getchar();getchar(); }

Pocas observaciones

1.- En fopen() se uso modo "a+".

2.- En lugar de fwrite(), se usa fread() con los mismos cuatro parametros.

También recordar que fread(), nos regresa la cantidad de registros que existian en el disco, por eso el ciclo while se convierte en falso cuando fread() regresa 0 y esto indica que se llego al fin del archivo.

El diseño de impresión es responsabilidad de usted, compruebe este ejercicio con más de 40 registros, organícelos por pantallas

Si todo esta bien, pero no quiero mirara todos los registros de una vez, que puedo hacer. Aquí esta la solución:

#include <stdio.h> #include <conio.h> #include <string.h> struct { int matricula; char nombre[30]; int edad;} alumno; void main() { clrscr(); // cargando clave a buscar printf("dame matricula buscar:"); int clave; scanf("%d",&clave);getchar(); //abriendo, leyendo,cargando estructura

84

FILE *archdisco; archdisco = fopen("c:\\ac\\alumnos.dat","at+"); // aqui siempre debe empezar el ciclo de lectura // y fread() regresa siempre cuantas estructuras leyo while(fread(&alumno,sizeof(alumno),1,archdisco)==1) { // desplegando estructura buscada if ( clave == alumno.matricula) { printf("MATRICULA =%d ",alumno.matricula); printf(" NOMBRE =%s ",alumno.nombre); printf(" MESES =%d ",alumno.edad); printf("\n");}; }; // aqui termina while // no olvidar cerrar archivo y siempre fuera de while fclose(archdisco); getchar(); }

Observaciones

1.- recordemos que estamos haciendo ejercicio con archivos secuenciales, por consiguiente a estos no se pueden acceder directamente, si no a través de un recorrido, búsqueda lineal, ahora nos podemos dar cuenta porque este método de búsqueda no es el más apropiado, pensemos en más de mil registros

Bueno no todo podemos hacerlo, algo para ustedes,

1.- como realizar una búsqueda que contenga filtros, por ejemplo: mostrar por pantalla los estudiantes que sean mayores de edad.

2. El borrado es una de opciones de mayor cuidado, podemos hacer borrado físico y borrado lógico, el físico es desapareciendo el registro por completo del la unidad de almacenamiento, y el lógico (método que más degusta), es colocar una marca y tenerlo en cuenta al momento de realizar consultas u o operaciones con los archivitos, la gran ventaja es que no se pierdan los datos históricos, solo se los cubre. Es importante que usted indague mas sobre estos temas y trate de hacer ejercicios que complemente

3.-Realizar un ejercicio que permita llevar registros de una colección de música, esto lo realizara mediante la utilización de menús y funciones

En este momento se presenta un ejercicio que muestra como se realiza las operaciones con archivos:

85

#include <stdio.h> #include <stdlib.h> #include <io.h> #include <conio.h> #include <string.h> struct { int matricula; char nombre[30]; int edad;} alumno; void main() { clrscr(); FILE *arch1; FILE *arch2; arch1 = fopen("c:\\ac\\alumnos.dat","r+"); arch2 = fopen("c:\\ac\\temporal.dat","at+"); // aqui siempre debe empezar el ciclo de lectura // y fread() regresa siempre cuantas estructuras leyo while(fread(&alumno,sizeof(alumno),1,arch1)==1) { // OPERACIONES alumno.edad=alumno.edad +50; //grabando a temporal fwrite(&alumno,sizeof(alumno),1,arch2); }; // aqui termina while //cerrando archivos fclose(arch1); fclose(arch2); // removiendo y renombrando archivos // recordar que directorios y archivos de datos no mas de 8.letras+ 3 de la extensión remove("C:\\AC\\ALUMNOS.DAT "); rename("C:\\AC\\TEMPORAL.DAT","C:\\AC\\ALUMNOS.DAT "); //avisando puts("EDADES MAS 50"); getchar(); }

Ejecución 1

86

Ejecución 2

Como se observa la solución es muy sencilla solo se ocupa el registro original y los dos archivos el original y el temporal, se va leyendo registro a registro de archivo original al registro en memoria correspondiente, se realiza la operación u proceso deseado con el registro y se graba el registro modificado en el archivo temporal, al final se elimina archivo original y se renombra el archivo temporal.

Espero sea claro lo que se hizo

/**

3.2.1.2 Archivos de acceso directo Esencialmente se comportan como los archivos antes vistos, pero su ventaja radica en su velocidad para acceder a la información, veamos algunos ejemplos

Un archivo de acceso directo permite posicionar el apuntador de interno de registros, a cualquier registro determinado sin necesidad de pasar por todos los registros anteriores, usando las siguientes funciones.

1) int fseek(apuntador,long offset,origen);

Esta función posiciona el apuntador de registro en el byte indicado. Regresa 0 si se pudo posicionar.

apuntador=fopen("a:archivo.dat","r+");

fseek(apuntador,(long)(clave)*(sizeof(registro)),0);

0 ---> SEEK_SET principio del archivo.

1 ---> SEEK_CUR posicion actual.

2 ---> SEEK_END fin del archivo.

87

2) long ftell(apuntador);

Regresa un valor long indicando la posición actual del cursor interno de registros de archivo.

3) int rewind(apuntador);

Regresa el apuntador al principio del archivo.

Ejemplo para hacer modificaciones.


fread(&registro,sizeof(registro),1,apuntador);

hacer las modificaciones.

rewind(apuntador);


fwrite(&registro,sizeof(registro),1,apuntador);

Manos a la obra nuevamente, miremos el siguiente código que crea un archivo de este tipo, pero ahora utilizamos los datos de mascotas

#include <stdio.h> #include <conio.h> #include <string.h> struct { int clave; char nombre[30]; int edad;} mascota; void main() { clrscr(); //creando y cerrando el archivo en disco FILE *archdisco; archdisco = fopen("c:\\ac\\archivo1.dat","wb"); fclose(archdisco); printf("ARCHIVO CREADO SATISFACTORIAMENTE "); getchar(); }

88

Si ya es idéntico a un archivo de acceso secuencial, en apariencia pero démonos cuenta de lo siguiente: La diferencia es poca archdisco = fopen("c:\\ac\\archivo1.dat","wb"); Como observamos hay una b al final de la instrucción, lo que indica que el archivo es de tipo binario /* Por supuesto el ingreso de los datos será similar, veamos #include <stdio.h> #include <conio.h> #include <string.h> struct { int clave; char nombre[30]; int edad;} mascota; void main() { clrscr(); // captura de campos printf("dame clave :");scanf("%d",&mascota.clave);getchar(); printf("dame nombre :");gets(mascota.nombre); printf("dame edad :");scanf("%d",&mascota.edad); // grabando a disco FILE *archdisco; archdisco = fopen("c:\\ac\\archivo1.dat","ab+"); fwrite(&mascota,sizeof(mascota),1,archdisco); fclose(archdisco); //avisando usuario printf("mascota insertado"); getchar();} Observar que es completamente similar aL programa de archivos secuenciales, solo se recomienda y exige que las claves sigan la secuencia 0,1,2,3,4,5..... Ahora miremos como es una consulta #include <stdio.h> #include <conio.h> #include <string.h> struct { int clave; char nombre[30]; int edad;} mascota;

89

void main() { clrscr(); // leyendo disco FILE *archdisco; archdisco = fopen("c:\\ac\\archivo1.dat","rb+"); // aqui siempre debe empezar el ciclo de lectura // y fread() regresa siempre cuantas estructuras leyo while(fread(&mascota,sizeof(mascota),1,archdisco)==1) { // desplegando estructuras printf("%d ",mascota.clave); printf("%s ",mascota.nombre); printf("%d ",mascota.edad); printf("\n"); }; // aqui termina while // no olvidar cerrar archivo y siempre fuera de while fclose(archdisco); getchar();; } En este caso no hay nada que comentar, puesto que se despliegan todos los registros Ahora tenemos el mismo ejercicio pero consultando un registro en especial, es realmente aquí donde vamos a encontrar verdades diferencias #include <stdio.h> #include <conio.h> #include <string.h> struct { int clave; char nombre[30]; int edad;} mascota; void main() { clrscr(); // cargando clave a buscar printf("dame clave buscar:"); int claveb; scanf("%d",&claveb); //abriendo, leyendo ,cargando estructura FILE *archdisco; archdisco = fopen("c:\\ac\\archivo1.dat","ab+"); // usar fseek() para posicionarse al principio de registro buscado fseek (archdisco, (long)(claveb)* sizeof(mascota), 0 ); // ahora se lee el registro fread(&mascota,sizeof(mascota),1,archdisco); // desplegando estructura y asegurandose printf("%d ",mascota.clave); printf("%s ",mascota.nombre); printf("%d ",mascota.edad);

90

printf("\n"); // no olvidar cerrar archivo fclose(archdisco); getchar(); } /*

Como se desprende del programa usando fseek() es posible posicionarse en cualquier byte del archivo.

El formato completo de fseek() es:


Donde los parámetros son:

a. Apuntador al archivo en disco b. El segundo parámetro es el BYTE donde se quiere que empieza la

lectura o grabación al archivo en disco. c. Este BYTE debe ser de tipo LONG así que si en algún programa de

ejemplo ven fseek( , 387L, ); que no les llame la atención, es otra manera de hacerle cast a un dato.

Como va a estar difícil que se le atine a un byte determinado, es por eso que en el programa mejor se deja que sea el propio servidor quien calcule el byte donde empieza un registro determinado con clave * sizeof o tamaño de registro.

d. El tercer parámetro es a partir de donde se quiere posicionar el apuntador interno del archivo, los valores pueden ser:

0 ---> SEEK_SET principio del archivo.

1 ---> SEEK_CUR posicion actual.

2 ---> SEEK_END fin del archivo.

Recordar que es muy importante que las claves grabadas en un archivo directo tengan la secuencia 0,1,2,3,4,5.....n

Miremos otro ejercicio con operaciones de archivos, donde encontramos algún diferencia sustancial con los archivos secuenciales #include <stdio.h> #include <io.h> #include <conio.h> #include <string.h> struct {

91

int clave; char nombre[30]; int edad;} mascota; void main() { clrscr(); FILE *arch1; long r=0; arch1 = fopen("c:\\ac\\archivo1.dat","rb+"); while (fread(&mascota,sizeof(mascota),1,arch1)==1) { // sumando 100 a edad mascota.edad = mascota.edad + 100 ; // como ya se leyo se regresa el apuntador al principio del registro fseek(arch1,r*sizeof(mascota),0 ); // y se escribe el registro modificado al archivo fwrite(&mascota,sizeof(mascota),1,arch1); r=r+1; //turboc no permite i/o archivos sin un rewind, fseek, etc fseek(arch1,r*sizeof(mascota),0); }; // aqui termina for //cerrando archivo fclose(arch1); //avisando puts("EDADES + 100"); getchar(); }

Como se observa la solución es muy sencilla solo se ocupa:

1.- leer fread() el registro, esto mueve el apuntador al siguiente registro.

2.- modificar registro

3.- regresar a posición anterior con fseek()

4.- grabar fwrite() el registro corregido

5.- volver a usar un fseek() porque turboc no acepta i/o sin rewind, fseek, etc ver ayuda del compilador

y no se ocupan los dos archivos como en el caso secuencial.

/****

92

Recopilación de ejercicios de verificación

1- Realice un programa que permite manejar el acceso de estudiantes a la sala de computo de la universidad, es responsabilidad de usted, realizar el análisis respectivo, lo que permita tener un programa funcional

2- Realizar un programa que permita elegir el formato (windows o linux) y permita escribir un determinado texto de cualquier tamaño y guardarlo en un archivo ascii con el formato especificado llamado c:\texto.txt. Los archivos de texto windows tienen como marcador de final de línea la secuencia CR (retorno de carro ascii=13) y LF (line feed ascii=10). Los de Linux solo tienen LF.

3- Realizar un programa que lea c:\texto.txt y proporcione las siguientes estadísticas: nº total de caracteres, nº de mayúsculas, nº de consonantes, nº de vocales y las cinco letras mas usadas

4- Escribir un programa que solicite palabras y las agregue a un fichero llamado c:\diccionario de forma que luego se puedan consultar las palabras una a una

Bueno con esto creo que terminamos por el momento.

93

BIBLIOGRAFÍA

INSUASTY R, Luis Delfín, Guia “A”,”B”,”C”,”D” de aprendizaje autonomo. Bogotá Colombia, UNAD- Cafan MAURREN, Priestley . Tecnicas y estrategias del pensamiento critico. Mexico D.F. 1996 (reimp .2000). Trillas. ARCEO B, Frida y Otro. Estrategias Decentes Para un Aprendizaje Significativo. Mexico D,F 1999. McGRAW-HILL KENNETH C, louden . Lenguajes de programación (segunda edición). Mexico D.F 2004. Thomson AGUILAR, Luis. Fundamentos de programación, algoritmos y estructura de datos (segunda edición). España. McGRAW-HILL. AGUILAR, Luis. Fundamentos de programación, algoritmos, estructura de datos y Objetos (tercera edición). España. 2003. McGRAW-HILL. DEYTEL Y DEYTEL. Como programa C++(segunda Edición). Mexico D.F. 1999. Prentice Hall. McGRAW-HILL FARREL, Joyce, introducción a la programación lógica y diseño. Mexico D.F 2000. Thomson BROOKSHEAR, J. Glenn , Introducción a las ciencias de la Computación (Cuarta Edicón). Edición Española 1995. Addison-Wesley Iberoamericana

Sitios WEB

http://kataix.umag.cl/~mmarin/topinf/cs23/c++/Indice.htm http://www.geocities.com/david_ees/Algoritmia/curso.htm http://members.tripod.com/~MoisesRBB/c.html http://www.ilustrados.com/publicaciones/EpZVVEZpyEdFpAKxjH.php http://www.programacionfacil.com/cbueno/indice.htm http://www.ilustrados.com/buscar.php http://www.inf.utfsm.cl/~mcloud/iwi-131/diapositivas.html) http://www.ucsm.edu.pe/rabarcaf/vonuep00.htm http://www.funlam.edu.co/bired/index.asp-offset=0.htm

94

http://www.itq.edu.mx/vidatec/espacio/aisc/ARTICULOS/leng/LENGUAJESDEPROGRAMACI%D3N.htm www.microsoft.com (Productos de programación) www.borland.com (Productos de programación)

95

ANEXOS

96

ANEXO Tipos de Datos C++ soporta básicamente tres tipos de dato: Enteros Reales (de coma o punto flotante) Caracteres La siguiente tabla indica el tipo de dato, la declaración y los limites en los cuales se pude mover una determinada variable Tipo Declaración Limite Inferior Limite Superior

Entero Entero Corto Entero Largo Entero sin Signo Entero con Signo Real Real Doble Real Largo Caracter

Int A; Short Int A; Long Int A; Unsigned Int A; Signed Int A; Float A; Double A; Long DoubleA; Char A;

-32768

-128 2E -6 0 -65000 -3.4E37 -1.7E -304 3.4E -4932 -128

32767

127 2E 6 65535 65000 3.4E 38 1.7E 308 1.1E 4932 127

Tipo de dato bool., esta incorporado en los compiladores que siguen la norma ANSI (Instituto Nacional Americano de Estándares) 2, cuyos valores pueden ser verdadeo8true) o falso (false), aunque en la realidad, muchos programadores no utilizan este tipo de datos, lo remplazan por una variable bandera numérica “bandera”, que pude tomar un valor 0 o 1 dependiendo la situación Operadores y expresiones Expresiones: “es un conjunto de datos compuesto de operandos unidos por operadores. Los operandos pueden ser constantes, variables o funciones” Operadores: se utilizan para procesar adecuadamente los operandos de acuerdo a sus tipos de datos. Por la característica de operación que realizan, los operadores también se dividen en: aritméticos, relacionales, lógicos, entre otros, a continuación se muestra una tabla identificando el orden de la categoría, el operador y una pequeña definición

2 Comité que aprueba estándares de informática . Un comité ANSI se dedica a la estandarización de C++

97

# Categoría Operador Qué es (o qué hace) () Invocación de función [] Suscritos de arreglos -> Selector de indirección :: Resolución de ámbito

1 Mayor

. Selector de componentes ! Negación lógica (NOT) ~ Complemento en binario + Más - Menos

++ Preincremento o postincremento

-- Predecremento o postdecremento

& Dirección * Valor en la dirección de

sizeof Tamaño del operando en bytes new Espacio en memoria dinámica

2 Unarios

delete Desasigna espacio en memoria * Multiplicación / División 3 Multipli-

% Resto en división entera . Separador campo 4 Acceso

-> Separador campo + Más binario 5 Aditivos - Menos binario

<< Izquierda 6 Desplaza- >> Derecha < Menor que < Menor o igual que > Mayor que

7 Relacional

> Mayor o igual que Igual a 8 Igualdad ! No igual a

9 y & AND para bits 10 o exclusivo ^ XOR para bits 11 o | OR para bits 12 y && AND lógico 13 o || OR lógico

?: a ? x : significa: 14 Condicional "Si a Entonces x, SI_NO y" Asignamiento simple * Producto / División

% Resto + Suma - Diferencia & AND sobre bits ^ XOR sobre bits | OR sobre bits

<< Desplazamiento a la izquierda

15 Asignación

>> Desplazamiento a la derecha 16 Coma , Separador de expresiones

98

Observación: Muchos de los operadores relacionados en el cuadro anterior, no se utilizan a lo largo de este curso. *-

99

ANEXO Indice de funciones

-A- Función Librería Fichero de cabecera C arc graphics graphics.h

-B- Función Librería Fichero de cabecera C bar graphics graphics.h bar3d graphics graphics.h

-C- Función Librería Fichero de cabecera C cgets conio conio.h circle graphics graphics.h cleardevice graphics graphics.h clearviewport graphics graphics.h closegraph graphics graphics.h clreol conio conio.h clrscr conio conio.h cprintf conio conio.h cputs conio conio.h cscanf conio conio.h

-D- Función Librería Fichero de cabecera C delline conio conio.h detectgraph graphics graphics.h drawpoly graphics graphics.h

-E- Función Librería Fichero de cabecera C ellipse graphics graphics.h

-F- Función Librería Fichero de cabecera C fillellipse graphics graphics.h fillpoly graphics graphics.h floodfill graphics graphics.h

-G- Función Librería Fichero de cabecera C getarccoords graphics graphics.h getaspectratio graphics graphics.h getbkcolor graphics graphics.h getch conio conio.h getche conio conio.h getcolor graphics graphics.h getdefaultpalette graphics graphics.h getdrivername graphics graphics.h getfillpattern graphics graphics.h getfillsettings graphics graphics.h

100

getgraphmode graphics graphics.h getimage graphics graphics.h getlinesettings graphics graphics.h getmaxcolor graphics graphics.h getmaxmode graphics graphics.h getmaxx graphics graphics.h getmaxy graphics graphics.h getmodename graphics graphics.h getmoderange graphics graphics.h getpalette graphics graphics.h getpalettesize graphics graphics.h getpass conio conio.h getpixel graphics graphics.h gettext conio conio.h gettextinfo conio conio.h gettextsettings graphics graphics.h getviewsettings graphics graphics.h getx graphics graphics.h gety graphics graphics.h gotoxy conio conio.h graphdefaults graphics graphics.h grapherrormsg graphics graphics.h graphfreemem graphics graphics.h graphgetmem graphics graphics.h graphresult graphics graphics.h

-H- Función Librería Fichero de cabecera C highvideo conio conio.h

-I- Función Librería Fichero de cabecera C imagesize graphics graphics.h initgraph graphics graphics.h inport conio conio.h insline conio conio.h installuserdriver graphics graphics.h installuserfont graphics graphics.h

-K- Función Librería Fichero de cabecera C kbhit conio conio.h

-L- Función Librería Fichero de cabecera C line graphics graphics.h linerel graphics graphics.h lineto graphics graphics.h lowvideo conio conio.h

-M- Función Librería Fichero de cabecera C moverel graphics graphics.h

101

movetext conio conio.h moveto graphics graphics.h

-N- Función Librería Fichero de cabecera C normvideo conio conio.h

-O- Función Librería Fichero de cabecera C outport conio conio.h outtext graphics graphics.h outtextxy graphics graphics.h

-P- Función Librería Fichero de cabecera C pieslice graphics graphics.h putch conio conio.h putimage graphics graphics.h putpixel graphics graphics.h puttext conio conio.h

-R- Función Librería Fichero de cabecera C rectangle graphics graphics.h registerbgidriver graphics graphics.h registerbgifont graphics graphics.h restorecrtmode graphics graphics.h

-S- Función Librería Fichero de cabecera C sector graphics graphics.h setactivepage graphics graphics.h setallpalette graphics graphics.h setaspectratio graphics graphics.h setbkcolor graphics graphics.h setcursortype conio conio.h setfillpattern graphics graphics.h setfillstyle graphics graphics.h setgraphbufsize graphics graphics.h setgraphmode graphics graphics.h setlinestyle graphics graphics.h setpalette graphics graphics.h setrgbpalette graphics graphics.h settextjustify graphics graphics.h settextstyle graphics graphics.h setusercharsize graphics graphics.h setviewport graphics graphics.h setvisualpage graphics graphics.h setwritemode graphics graphics.h

-T-

102

-U-

-W-

Función Librería Fichero de cabecera C textattr conio conio.h textbackground conio conio.h textcolor conio conio.h textheight graphics graphics.h textwidth graphics graphics.h

Función Librería Fichero de cabecera C ungetch conio conio.h

Función Librería Fichero de cabecera C wherex conio conio.h wherey conio conio.h window conio conio.h

103

ANEXO Errores comunes de programación Buenas prácticas de programación

Por : MIGUEL Á. TOLEDO MARTÍNEZ (http://www.galeon.com/neoprogramadores/soyc-cpp.pdf) • ERRORES COMUNES DE PROGRAMACIÓN • BUENAS PRÁCTICAS DE PROGRAMACIÓN ERRORES COMUNES DE PROGRAMACIÓN 1. Si al utilizar funciones de la biblioteca matemática no incluye el archivo de encabezado matemático, se producirá un error de sintaxis. Por cada función de la biblioteca estándar que utilice en un programa, debe indicar un archivo de encabezado estándar. 2. La omisión de la clase de valor devuelto de una definición de función es un error de sintaxis si el prototipo especifica una clase devuelto distinto de int. 3. No devolver un valor desde una función que supuestamente debe hacerlo es un error de sintaxis. 4. La devolución de un valor desde una función cuya clase de devolución se ha declarado como void es un error de sintaxis. 5. La declaración de parámetros de función de la misma clase como float x, y, en lugar de float x, float y, causará un error de compilación debido a que para cada parámetro de la lista de parámetros se requiera una clase de datos. 6. Un punto y coma después del paréntesis derecho de la lista de parámetros de una definición de función es un error de sintaxis. 7. Volver a definir un parámetro de función como variable local en la función es un error de sintaxis. 8. El ( ) de una llamada de función de hecho es un operador de C++. Provoca que se invoque a la función. Omitir el () de una llamada de función que no tiene argumentos no es un error de sintaxis. Sin embargo si pretendía que se llamara a la función, esto no sucederá. 9. Definir una función dentro de otra es un error de sintaxis. 10. Sucede un error de sintaxis si el prototipo de función, el encabezado de la función y las llamadas de la función no coinciden en el número, clase de datos y orden de los argumentos y parámetros, así como en el tipo de valor devuelto. 11. La omisión del punto y coma al final de un prototipo de función es un error de sintaxis. 12. Las llamadas de función que no sean iguales a su prototipo provocan errores de sintaxis. 13. Cuando el prototipo de función y la definición de la función no son iguales, sucede un error de sintaxis. 14. La conversión de una clase de datos más alto en la jerarquía de promoción a un tipo menor puede cambiar su valor. 15. Omitir el prototipo de una función cuando esta no ha sido definida antes de ser llamada por primera vez es un error de sintaxis. 16. El intento por generar números aleatorios con srand() en lugar de rand() es un error de sintaxis, debido a que la función srand() no devuelve un valor.

104

17. Asignarle el equivalente entero de una constante de enumeración a una variable del tipo de la enumeración es un error de sintaxis. 18. Si después de definir una constante de enumeración intenta asignarle otro valor, provocará un error de sintaxis. 19. Indicar varios especificadores de clase de almacenamiento para un identificador es un error de sintaxis. Sólo se le puede aplicar un especificador de clase de almacenamiento a un identificador. Por ejemplo, si incluye register, no incluya también auto. 20. Por lo general es un error de lógica utilizar el mismo nombre para un identificador dentro de un bloque interno que para un identificador que es parte de un bloque externo cuando, de hecho, el programador quiere que el identificador del bloque externo esté activo en el bloque interno. 21. El no devolver un valor desde una función recursiva cuando sea necesario, causará que casi todos los compiladores generen un mensaje de advertencia. 22. La omisión del estado primitivo o la escritura incorrecta del paso de recursión de modo que no converja al estado primitivo, provocará una recursión infinita y agotará tarde o temprano la memoria. Esto es análogo al problema de los ciclos infinitos en las soluciones iterativas (no recurrentes) La recursividad infinita también puede ser provocada al proveer una entrada no esperada. 23. La codificación de programas que dependen del orden de evaluación de los operandos de los operadores que no sean &&, ||, ?: ni coma (,) puede generar errores, pues los compiladores no necesariamente evaluarán los operandos en el orden que el programador espera. 24. Es un error de lógica que una función no recursiva se llame a sí misma, ya sea directa o indirectamente, a través de otra función. 25. Los programas en C++ no se compilan a menos que se indiquen prototipos de función para todas las funciones o que se definan las funciones antes de usarlas. 26. Debido a que los parámetros de referencia se mencionan sólo por nombre en el cuerpo de la función llamada, el programador podría tratarlos inadvertidamente como parámetros de una llamada por valor. Esto puede provocar efectos secundarios inesperados si el invocador modifica las copias originales de las variables. 27. Declarar múltiples referencia en una instrucción suponiendo que el & se distribuye a través de una lista de nombres de variables separada por comas. Para declarar las variables x, y y z como referencias a un entero emplee la notación int &x = a, &y = b, &z = c; en lugar de la notación incorrecta int& x = a, y = b, z = c; o la otra notación incorrecta común int &x, y, z; 28. No inicializar una variable de referencia al declararla es un error de sintaxis. 29. Intentar reasignar una referencia declarada previamente como alias de otra variable es un error de lógica. El valor de la otra variable simplemente se le asigna a la localidad para la que la referencia es un alias. 30. Devolver un apuntador o referencia a una variable automática en una función llamada es un error de lógica. Algunos compiladores presentarán un mensaje de aviso al encontrar esto en un programa. 31. Especificar e intentar utilizar un argumento predeterminado que no sea el de más a la derecha (último) sin tomar los predeterminados de todos los argumentos a su derecha es un error de sintaxis.

105

32. Intentar acceder a una variable no global desde un bloque exterior por medio del operador unario de resolución de alcance es un error de sintaxis si no existe una variable global con el mismo nombre que la variable del bloque exterior, y es un error de lógica si es que existe. 33. La creación de funciones sobrecargadas con listas de parámetros idénticas y diferentes tipos de devolución es un error de sintaxis. 34. Una función a la que se le han omitido los argumentos predeterminados podría ser llamada de manera idéntica a otra función sobrecargada; esto es un error de sintaxis. Por ejemplo, cuando un programa tiene tanto una función que explícitamente no recibe argumentos como otra con el mismo nombre que contiene sólo argumentos predeterminados, sucede un error de sintaxis cuando se intenta utilizar dicho nombre de función en una llamada que no pasa argumentos. 35. No poner la palabra clave class antes de cada parámetro de tipo de una plantilla de función es un error de sintaxis. 36. No emplear todos los parámetros de tipo de una plantilla de función en la firma de la función es un error de sintaxis. BUENAS PRÁCTICAS DE PROGRAMACIÓN 1. Familiarícese con el vasto conjunto de funciones y clases de la biblioteca estándar de C++. 2. Ponga una línea en blanco entre las definiciones de función para separarlas y simplificar la lectura del programa. 3. Aunque lo predeterminado cuando se omite el tipo de devolución es int, siempre indique explícitamente el tipo de valor de devuelto. 4. Aunque no es incorrecto hacerlo, no utilice los mismos nombres para los argumentos pasados a una función y para los parámetros correspondientes de la definición de la función. Con esto se evitan ambigüedades. 5. Seleccione nombres de función y de parámetros que tengan significado para simplificar la lectura de los programas y para ayudar a evitar demasiados comentarios. 6. Muchos programadores indican los nombres de los parámetros en los prototipos de las funciones con fines documentativos. El compilador ignora estos nombres. 7. Ponga con mayúsculas la primera letra de los identificadores que sean nombres de clase definidos por el usuario. 8. Sólo indique letras mayúsculas para los nombres de constantes de enumeración. Con esto se resaltan las constantes en el programa, recordándole al programador que las constantes de enumeración no son variables. 9. Utilice enumeraciones en lugar de constantes enteras; con esto sus programas serán más claros. 10. Evite los nombres de variables que oculten nombres en los alcances exteriores. Esto puede lograrse evitando utilizar identificadores duplicados en el programa. 11. Siempre indique prototipos de función, aun cuando sea posible omitirlos al definir las funciones antes de utilizarlas. Al indicar los prototipos se evita enlazar el código al orden en que se definen las funciones (el cual puede cambiar fácilmente con la evolución del programa)

106

12. El calificador inline sólo debe utilizarse con funciones pequeñas de uso frecuente. 13. Los argumentos predeterminados pueden simplificar la escritura de las llamadas de función. De cualquier forma, algunos programadores sienten que resulta más claro indicar explícitamente todos los argumentos. 14. Evite utilizar variables con el mismo nombre cuyos fines sean diferentes. Aunque es válido bajo varias circunstancias, puede generar confusiones. 15. Sobrecargar funciones que realicen tareas muy relacionadas puede simplificar la lectura de los programas.

introducion a la programacion

Documents