Imagen abstracta de una mujer sentada en libros y estudiando en una computadora portátil

Manual C/C++

Descargar como DOCX, PDF
E
Estudiantes ISI_UCA

Este documento presenta una introducción al lenguaje de programación C++. Explica brevemente la historia de C++ y cómo surgió como una extensión del lenguaje C, añadiéndole características orientadas a objetos. Luego, cubre conceptos básicos como algoritmos, programas, tipos de datos, identificadores, constantes, operadores y comentarios. Finalmente, introduce temas más avanzados como arreglos, estructuras, entrada y salida, funciones y punteros.

Educación
1 de 142
Descargado 21 veces
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
[Título del documento] 2016 INGENIERIA EN SISTEMAS DE INFORMACION |UNIVERSIDAD CENTROAMERICANA Universidad Centroamericana FACULTAD DE CIENCIA, TECNOLOGÍA Y AMBIENTE DEPARTAMENTO DE DESARROLLO TECNOLÓGICO Manual C/C++ Autor: Eddy Esequiel Moreno Benavides. Docente: Elsner Boanerge González Ortega.
EDDY ESEQUIEL MORENO BENAVIDES 1 Tabla de contenido Historia de C++ ................................................................................................................. 4 Conceptos básicos ............................................................................................................ 7 ¿Qué es un algoritmo?............................................................................7 Ejecutable o programa de computador.....................................................8 Etapas o pasos para la creación de un programa .......................................8 Datos................................................................................................................................. 9 Tipos de datos .......................................................................................9 Puntos a tomar en cuenta..................................................................................................................................9 Identificadores ....................................................................................11 Reglas al nombrar identificadores.................................................................................................................11 Palabras reservadas .............................................................................12 Declaración de variables .......................................................................14 Constantes..........................................................................................16 Constante de carácter ..........................................................................17 Juego de caracteres..............................................................................19 Operadores .........................................................................................21 Operadores Aritméticos..................................................................................................................................21 Operadores lógicos y relacionales.................................................................................................................22 Operadores de asignación..............................................................................................................................22 Prioridad de Operadores.......................................................................23 Comentarios........................................................................................24 Cast....................................................................................................25 Librerías.......................................................................................................................... 26 Arreglos .......................................................................................................................... 28 Declaración .........................................................................................28 Acceso al arreglo..................................................................................29 Estructuras...................................................................................................................... 30 Acceso a estructuras ............................................................................31 Entrada y salida de datos en C ...................................................................................... 32 Formatos ............................................................................................32 Entrada de datos..................................................................................33
EDDY ESEQUIEL MORENO BENAVIDES 2 Salida de Datos....................................................................................34 Funciones sin formato ..........................................................................35 Función...............................................................................................35 Descripción .........................................................................................35 getche() ..............................................................................................35 getchar() .............................................................................................35 getch() ................................................................................................35 putchar().............................................................................................35 gets()..................................................................................................35 puts()..................................................................................................35 Entrada y salida de datos en C++ .................................................................................. 36 Sentencias de control ..................................................................................................... 37 If........................................................................................................37 Else ....................................................................................................37 Switch-case .........................................................................................38 For .....................................................................................................39 While..................................................................................................40 Do-while .............................................................................................41 Break..................................................................................................41 Continue .............................................................................................42 Return ................................................................................................42 Ficheros........................................................................................................................... 43 Fopen .................................................................................................43 Fclose .................................................................................................44 Feof....................................................................................................45 Rewind ...............................................................................................45 Lectura ...............................................................................................45 Escritura de Archivos............................................................................46 Funciones........................................................................................................................ 47 Punteros.......................................................................................................................... 48
EDDY ESEQUIEL MORENO BENAVIDES 3 Anexos ............................................................................................................................ 49 Proyecto final de clase (Administrador de apartamentos) ........................49 Main....................................................................................................................................................................49 Cabecera datos.h..............................................................................................................................................76 Login + Ejercicios de empleados.............................................................77 Ejercicio de matrices- Algebra lineal.......................................................98 Manejo de empleados ........................................................................128
EDDY ESEQUIEL MORENO BENAVIDES 4 Historia de C++ C++ es un lenguaje imperativo orientado a objetos derivado del C. En realidad un superconjunto de C, que nació para añadirle cualidades y características de las que carecía. El resultado es que como su ancestro, sigue muy ligado al hardware subyacente, manteniendo una considerable potencia para programación a bajo nivel, pero se la han añadido elementos que le permiten también un estilo de programación con alto nivel de abstracción. Estrictamente hablando, C no es un subconjunto de C++; de hecho es posible escribir código C que es ilegal en C++. Pero a efectos prácticos, dado el esfuerzo de compatibilidad desplegado en su diseño, puede considerarse que C++ es una extensión del C clásico. La definición "oficial" del lenguaje nos dice que C++ es un lenguaje de propósito general basado en el C, al que se han añadido nuevos tipos de datos, clases, plantillas, mecanismo de excepciones, sistema de espacios de nombres, funciones inline, sobrecarga de operadores, referencias, operadores para manejo de memoria persistente, y algunas utilidades adicionales de librería (en realidad la librería Estándar C es un subconjunto de la librería C++). Respecto a su antecesor, se ha procurado mantener una exquisita compatibilidad hacia atrás por dos razones: poder reutilizar la enorme cantidad de código C existente, y facilitar una transición lo más fluida posible a los programadores de C clásico, de forma que pudieran pasar sus programas a C++ e ir modificándolos (haciéndolos más "++") de forma gradual. De hecho, los primeros compiladores C++ lo que hacían en realidad era traducir (pre procesar) a C y compilar después. Por lo general puede compilarse un programa C bajo C++, pero no a la inversa si el programa utiliza alguna de las características especiales de C++. Algunas situaciones requieren especial cuidado. Por ejemplo, si se declara una función dos veces con diferente tipo de argumentos, el compilador C invoca un error de "Nombre duplicado", mientras que en C++ quizás sea interpretado como una
EDDY ESEQUIEL MORENO BENAVIDES 5 sobrecarga de la primera función (que sea o no legal depende de otras circunstancias). Se trata simplemente del sucesor de un lenguaje de programación hecho por programadores (de alto nivel) para programadores, lo que se traduce en un diseño pragmático al que se le han ido añadiendo todos los elementos que la práctica aconsejaba como necesarios, con independencia de su belleza o purismo conceptual. Estos condicionantes tienen su cara y su cruz; en ocasiones son motivo de ciertos "reproches" por parte de sus detractores, en otras, estas características son precisamente una cualidad. De hecho, en el diseño de la Librería Estándar C++ se ha usado ampliamente esta dualidad (ser mezcla de un lenguaje tradicional con elementos de POO), lo que ha permitido un modelo muy avanzado de programación extraordinariamente flexible (programación genérica). Aunque C++ introduce nuevas palabras clave y operadores para manejo de clases, algunas de sus extensiones tienen aplicación fuera del contexto de programación con objetos (fuera del ámbito de las clases), de hecho, muchos aspectos de C++ que pueden ser usados independientemente de las clases. Del C se ha dicho: "Por naturaleza, el lenguaje C es permisivo e intenta hacer algo razonable con lo que se haya escrito. Aunque normalmente esto es una virtud, también puede hacer que ciertos errores sean difíciles de descubrir”. Respecto al C++ podríamos decir otro tanto, pero hemos de reconocer que su sistema de detección de errores es mucho más robusto que el de C, por lo que algunos errores de este serán rápidamente detectados. Desde luego, C++ es un lenguaje de programación extremadamente largo y complejo; cuando nos adentramos en él parece no acabar nunca. Justo cuando aprendemos un significado descubrimos que una mano negra ha añadido otras dos o tres acepciones para la misma palabra. También descubrimos que prácticamente no hay una regla sin su correspondiente excepción. Cuando aprendemos que algo no se puede hacer, hay siempre algún truco escondido para hacerlo, y cuando nos dicen que es un lenguaje fuertemente tipeado, resulta completamente falso. A pesar de todo, ha experimentado un extraordinario éxito desde su creación. De hecho, muchos sistemas operativos, compiladores e intérpretes han sido
EDDY ESEQUIEL MORENO BENAVIDES 6 escritos en C++ (el propio Windows y Java). Una de las razones de su éxito es ser un lenguaje de propósito general que se adapta a múltiples situaciones. Tanto sus fervientes defensores como sus acérrimos detractores han hecho correr ríos de tinta ensalzando sus cualidades o subrayando sus miserias, aunque todo el mundo parece estar de acuerdo en que es largo y complejo. Ha servido de justificación para el diseño de otros lenguajes que intentan eliminar sus inconvenientes al tiempo que mantener sus virtudes (C# y Java por ejemplo), y una de sus última incorporaciones, las plantillas, ha sido origen de un nuevo paradigma de programación (meta programación). Cualquier lenguaje de propósito general que como C++, permita tocar ambos mundos, la programación de bajo nivel y altos niveles de abstracción, resultará siempre e inevitablemente complejo. Ocurre lo mismo con los lenguajes naturales que son también extraordinariamente complejos (esto lo saben bien los gramáticos). Cualquier comunicación entre humanos presupone una ingente cantidad de conocimientos y suposiciones previas entre los interlocutores. A pesar de lo cual, la comunicación exacta y sin ambigüedades entre dos personas no resulta fácil. 1. Ejemplo de "Hola mundo" en C++
EDDY ESEQUIEL MORENO BENAVIDES 7 Conceptos básicos ¿Qué es un algoritmo? Este se entiende a un conjunto finito de instrucciones que se deben seguir para resolver un problema. No obstante, desde el punto de vista de la programación de ordenadores, la definición del algoritmo como la especificación de una serie de pasos, es incompleta. Debe observarse que los ordenadores son equipos que tienen limitaciones físicas en cuanto a capacidad de almacenamiento y procesamiento. Por consiguiente debemos refinar un poco más nuestra definición de algoritmo para hacerla aplicable de manera efectiva en el ámbito de la informática. El algoritmo es un conjunto de pasos, instrucciones o acciones que se deben seguir para resolver un problema. Existen una gran cantidad de algoritmos, hay que escoger el más efectivo. Hay dos tipos de algoritmos que son los cualitativos y cuantitativos. Cualitativos son todos aquellos pasos o instrucciones descritos por medio de palabras que sirven para llegar a la obtención de una respuesta o solución de un problema. Cuantitativos son todos aquellos pasos o instrucciones que involucran cálculos numéricos para llegar a un resultado satisfactorio. Estos tienen que ser:  Preciso.  Bien definido.  Finito.  Adaptables.  Independiente según donde se implemente.
EDDY ESEQUIEL MORENO BENAVIDES 8 Ejecutable o programa de computador Es un algoritmo que ha sido desarrollado en un determinado lenguaje de programación, para ser utilizado por la computadora que ha pasado por el proceso de compilación o traducción a lenguaje de máquina para este fin. En el sistema operativo de Windows se suele utilizar la extensión .EXE para indicar que ese archivo es un ejecutable. Etapas o pasos para la creación de un programa  Definición del problema  Análisis del problema  Diseño y técnicas para la formulación de un algoritmo  Codificación  Prueba y depuración  Documentación  Mantenimiento
EDDY ESEQUIEL MORENO BENAVIDES 9 Datos En cada tipo de lenguaje de programación existen los datos, estos son la esencia en cada programa ya que logran la creación, obtención y reproducción de información. Tipos de datos Cada programa trabaja con diferentes tipos de datos los cuales son de diferentes tipos y tienen un rango determinado para el uso de estos pero siempre son extensos para que no exista una limitante. Estos pueden ser de tipo numérico, lógico o caracteres y normalmente poseen variantes que cambian sus propiedades. El tamaño y la extensión de estos tipos de valores varían según el compilador que es utilizado y a veces el IDE también influye debido a algunos sistemas de autocompletar en áreas que se recomienda su uso; por lo cual los datos que aparecen en la tabla son solo estimaciones. Puntos a tomar en cuenta  En el lenguaje C no existe el tipo bool, pero en C++ esto cambia. En C se utiliza el orden de 0 1; siendo el 1 verdadero y el 0 falso en C++.  Se utiliza el juego de caracteres ASCII para representar los caracteres básicos en este lenguaje.  Existe el tipo de dato vacío (Void) y normalmente se utiliza en subprocesos que no retornan ningún valor.  En C++ se conoce la existencia del tipo de valor Cadena (String), aunque este solo es un arreglo de caracteres que no tiene que definirse en ningún momento.
EDDY ESEQUIEL MORENO BENAVIDES 10 Datos básicos Tipo Identificador Bytes en memoria Rango Entero Entero corto short 2 De -32768 a 32767 Entero int 4 De -2147483648 a +2147483647 Entero largo long 4 De -2147483648 a +2147483647 Carácter char 1 De -128 a 127 Enteros especiales Entero corto signed short 2 De -32768 a 32767 Entero corto sin signo unsigned short 2 De 0 a 65535 Entero signed int 4 De -2147483648 a +2147483647 Entero sin signo unsigned int 4 De 0 a 4294967295 Entero largo signed long 4 De -2147483648 a +2147483647 Entero largo sin signo unsigned long 4 De 0 a 4294967295 Carácter signed char 1 De -128 a 127 Carácter sin signo unsigned char 1 De 0 a 255 Flotantes Real float 4 Positivos: 3.4E- 38 a 3.4E38 Negativos: -3.4E- 38 a -3.4E38 Real doble double 8 Positivos: 1.7E- 308 a 1.7E308 Negativos: -1.7E- 308 a -1.7E308 Real doble largo long double 10 Positivos: 3.4E- 4932 a 1.1E4932 Negativos: -3.4E- 4932 a - 1.1E4932 Lógicos Dato lógico bool 1 0 a 1
EDDY ESEQUIEL MORENO BENAVIDES 11 Identificadores Estos son nombres que le otorga el usuario a los espacios de memoria para su fácil manejo, siendo un código formado por letras, números y guiones bajos. Se le puede dar un identificador a variables, constantes y funciones. Reglas al nombrar identificadores  Deben iniciar con una letra perteneciente al código ASCII, puede ser mayúscula o minúscula porque estas se diferencian.  No usar palabras reservadas.  Solo se pueden utilizar números, guion bajo como complemento al identificador.  No pueden existir dos identificadores iguales.  No puede contener espacios en blancos. 2. Ejemplo claro de todo lo que se puede utilizar al declarar
EDDY ESEQUIEL MORENO BENAVIDES 12 Palabras reservadas Estas son palabras que ya tienen una función otorgada que ha sido definida previamente, y debido a eso no pueden ser utilizados como identificadores. Estas tienen un significado especial para el compilador, son universales y presentan una instrucción propia de sus lenguajes. Existe una lista que ya incluye el lenguaje de C, otras que son exclusivas para C++ y se pueden agregar más a partir de librerías externas por lo que se debe consultar cada librería para sacar el máximo provecho de estas. Las que se muestran en la tabla siguiente son solo una muy pequeña parte de palabras reservadas que existen: Término Significado stream Flujo de datos cin Entrada estándar cout Salida estándar cerr Salida de mensajes de error streambuf Operación de I/O a bajo nivel istream Operación de I/O a alto nivel ostream Operación de I/O a alto nivel iostream Operación de I/O a alto nivel ios Clase para el manejo de la I/O a alto nivel setf() Método de la clase ios para inicializar los indic de formato flags() Método de la clase ios para inicializar los indic de formato unsetf() Método de la clase ios para desactivar los indic de formato width() Función declarada en las clases istream, ostream e iostream precision() Función declarada en las clases istream, ostream e iostream fill() Función declarada en las clases istream, ostream e iostream endl Manipulador sin argumentos definidos en iomanip.h flush Manipulador sin argumentos definidos en iomanip.h << ó >> Operadores de inserción o extracción de flujo ifstream Clase necesaria para la inserción de flujo de datos en ficheros. ofstream Clase necesaria para la extracción de flujo de datos en ficheros. fstream Clase necesaria para la I/O de flujo de datos en ficheros. endl Se imprime un ‘n’ y se vacía el buffer de salida fflush Limpia el buffer case Si se cumple un caso default Ningunas opciones de la selectiva múltiple typedef Crea un nuevo nombre de tipo para un tipo de dato ya definido
EDDY ESEQUIEL MORENO BENAVIDES 13 for Estructura repetitiva (o de ciclo) int Tipo de dato entero } Fin del programa o de un bloque do Estructura repetitiva printf Imprime en pantalla puts Imprime una cadena { Inicio del programa o un bloque scanf Lee una variable gets Lee una cadena de caracteres clrscr Borra el contenido de la pantalla while Estructura repetitiva void Valor nulo main Programa principal sqrt Calcula raíz Cuadrada float Tipo de dato real struct Registro o estructura return Regresa valor a otra función break Terminar el caso switch Estructura selectiva múltiple if Estructura selectiva else La parte falsa de la selectiva
EDDY ESEQUIEL MORENO BENAVIDES 14 Declaración de variables La declaración de las variables es lo primero que se debe realizar antes de hacer uso de estas, siempre tienen asignado un tipo, y no puede cambiar de tipo una vez que ya ha sido asignada; pero esto no impide que pueda cambiar su valor. En si lo que se realiza al declarar una variable es asignarle un espacio de memoria que equivale a su peso en byte dependiendo del tipo de dato asignado. La sintaxis que se sigue en la declaración de variables inicia con el <tipo de la variable> <identificador> y <valor> seguido por un punto y coma. En este lenguaje la sintaxis en ejemplo a seguir es la siguiente para los distintos tipos de variables: 3. Declaración de variables enteras En esta se le otorga el número o valor sin importar nada más. 4. Declaración de variables tipo carácter
EDDY ESEQUIEL MORENO BENAVIDES 15 En las declaraciones de tipo carácter solo se puede ingresar un carácter, este tiene que ser ingresado entre comillas simples. 5. Declaración de variable tipo cadena En la declaración de variables tipo cadena el valor a otorgar tiene que ser encerrado entre comillas dobles para su correcto uso. 6. Declaración de variables tipo flotante En las variables tipo flotante es el mismo caso que en las variables enteras. 7. Declaración de variables lógicas En la declaración de las variables de tipo lógico el valor se les será otorgado por las palabras reservadas “true” o “false”.
EDDY ESEQUIEL MORENO BENAVIDES 16 Constantes Las constantes son los datos que no pueden ser alterados en ninguna parte del algoritmo, su valor siempre será estático. Estos pueden ser de cualquier tipo de los existentes; y se usa por medio del “const” o “#define”. 8. Demostración de la declaración de las constantes Si se intenta realizar un cambio en el valor de una constante el IDE encontrara un error al intentar compilar, el cual dirá que hay un conflicto en el espacio de memoria al desear guardar.
EDDY ESEQUIEL MORENO BENAVIDES 17 Constante de carácter Son constantes que están representadas por una barra y una letra las cuales tienen una función específica dependiendo de la que se use. Por ejemplo: Al usar t se llama a la constante de tabulación la cual procede a dar 4 espacios en el texto. Secuencia de escape Significado a Alerta b Espacio atrás f Salto de Pagina n Salto de línea r Retorno de carro t Tabulación Horizontal v Tabulación Vertical Barra invertida ’ Comilla simple ” Comilla doble ooo Visualiza un carácter cuyo código ASCII es 000 octal
EDDY ESEQUIEL MORENO BENAVIDES 18 9. Demostración del uso en constantes especiales
EDDY ESEQUIEL MORENO BENAVIDES 19 Juego de caracteres El texto de un programa de C++ se almacena en archivos de código fuente que usan una codificación de caracteres determinada. El estándar de C++ especifica un juego básico de caracteres de código fuente para los archivos de código fuente y un juego básico de caracteres de ejecución para los archivos compilados. La manera en que se codifican los caracteres depende totalmente del ordenador y compilador, siendo el más común los caracteres de 1 byte. Con ese tamaño se encuentran a disposición 256 caracteres, siendo los primeros 128 de estos pertenecientes a la norma ASCII. En la norma ASCII (0-128) se encuentran a disposición del usuario para escribir solamente los caracteres imprimibles los cuales van desde el 32 hasta el 127, y están representados en la siguiente tabla: Decimal Carácter Decimal Carácter Decimal Carácter 32 espacio 64 @ 96 ` 33 ! 65 A 97 a 34 " 66 B 98 b 35 # 67 C 99 c 36 $ 68 D 100 d 37 % 69 E 101 e 38 & 70 F 102 f 39 ' 71 G 103 g 40 ( 72 H 104 h 41 ) 73 I 105 i 42 * 74 J 106 j 43 + 75 K 107 k 44 , 76 L 108 l
EDDY ESEQUIEL MORENO BENAVIDES 20 La mayoría de los compiladores de la actualidad permiten agregar caracteres que son ajenos al juego básico de caracteres ASCII, por lo cual se llega a utilizar la norma ASCII de caracteres extendidos o como se le llama comúnmente ASCII Extendido. Siendo esto útil en nuestro idioma, ya que en el ASCII básico no se encuentran caracteres como:  Ñ  ¡  ¿  Letras tildadas  Entre otros. 45 - 77 M 109 m 46 . 78 N 110 n 47 / 79 O 111 o 48 0 80 P 112 p 49 1 81 Q 113 q 50 2 82 R 114 r 51 3 83 S 115 s 52 4 84 T 116 t 53 5 85 U 117 u 54 6 86 V 118 v 55 7 87 W 119 w 56 8 88 X 120 x 57 9 89 Y 121 y 58 : 90 Z 122 z 59 ; 91 [ 123 { 60 < 92 124 | 61 = 93 ] 125 } 62 > 94 ^ 126 ~
EDDY ESEQUIEL MORENO BENAVIDES 21 Operadores Son símbolos que permiten que exista una relación entre datos en una expresión, y evaluar el resultado de la operación. Esto es la esencia del procesamiento de datos ya que aquí se realizan las funciones básicas del computador. Los operadores se diferencian por la función que realizan en un ambiente, normalmente se dividen en:  Aritméticos  Lógicos y relacionales  De asignación Operadores Aritméticos Los operadores aritméticos son todos aquellos que realizan cálculos para lograr un resultado, los que se incluyen en esta categoría son:  Suma ( + )  Resta ( - )  Multiplicación ( * )  División ( / )  Residuo ( % ) Existen también los operadores de incremento y decremento, estos se manejan de 1 en 1, por lo cual al aplicarlo el cambio solamente será de un digito menor o mayor. Normalmente el uso que se les da es en bucles de instrucciones, por lo cual el aprendizaje de estos es esencial. Estos se encuentran como:  Incremento (++ ): Esto permite el incremento en 1 de una variable.  Decremento ( -- ): Esto permite el decremento en 1 de una variable.
EDDY ESEQUIEL MORENO BENAVIDES 22 Operadores lógicos y relacionales Los operadores relacionales realizan una relación entre 2 valores que se verá determinada por el operador usado. Estas relaciones darán por resultado un valor lógico que se representa como verdadero o falso Describen una relación entre 2 valores, por lo tanto, se usan para expresar condiciones y comparar dos valores. El resultado de una expresión relaciones es un valor tipo lógico o booleano, solo puede ser verdadero o falso. El lenguaje C representa como verdadero el valor 1 y como falso el valor 0. Mientras que los lógicos la única que no realiza una relación es la “!” la cual solo establece una búsqueda o inversa de la variable usada. Operador Significado > Mayor que < Menor que = = Igual que >= Mayor o igual que <= Menor o igual que ! = Distinto a && Y || O ! No Operadores de asignación El operador de asignación su única función es otorgar un valor a una variable. Se realiza con un signo igual ( = ).
EDDY ESEQUIEL MORENO BENAVIDES 23 Prioridad de Operadores Es el orden en el que el computador realiza los procesos aritméticos, lógicos y relacionales. Estos no son difíciles de aprender y seguro ya se tiene conocimiento de esto porque son los que se aplican en la vida diaria. 1. Las expresiones que están encerradas entre paréntesis son las primeras a evaluar. 2. Se continua con el orden jerárquico de las operaciones a. Potencia b. Multiplicación c. División d. Modulo e. Suma f. Resta 10. Jerarquía de operadores en demostración
EDDY ESEQUIEL MORENO BENAVIDES 24 Comentarios Estos se utilizan para crear documentación dentro del programa mismo, para que cuando alguien inspeccione el código le sea de fácil comprensión en todo proceso que se desarrolle. Se debe considerar importante su uso en cada parte del código, sin importar su exceso debido a que entre más documentado este el código menos posibilidad existe de perderse dentro del mismo. Se puede comentar de 2 maneras.  Comentario por bloques /* (Para abrir comentario) */ (Para cerrar comentario.  Comentario por línea // 11. Ejemplo de comentarios por tipos
EDDY ESEQUIEL MORENO BENAVIDES 25 Cast Esto es la transformación de un tipo de datos a otro que se almacenara en una variable dada, se realiza mediante la multiplicación del tipo de dato deseado por la variable a transformar que se terminara almacenando en una variable con el tipo de dato deseado y llega a ser una transformación forzada. 12. Se realiza un cast de un valor flotante a uno entero
EDDY ESEQUIEL MORENO BENAVIDES 26 Librerías Se le llama librerías a cierto tipo de archivos que podemos importar o incluir en nuestro programa. Estos archivos contienen las especificaciones de diferentes funcionalidades ya construidas y utilizables que podremos agregar a nuestro programa. Al poder incluir estas librerías con definiciones de diferentes funcionalidades podremos ahorrarnos gran cantidad de cosas, imaginemos por ejemplo que cada vez que necesitemos leer por teclado, debamos entonces crear una función que lo haga, al poder contar con las librerías en C++, se podrá hacer uso de la gran variedad de funciones que incluyen estas las cuales facilitan nuestras vidas. Es esencial agregar después de las librerías un “using namespace std;”, lo cual separara las funciones del espacio de declaración de las librerías. Las librerías no son únicamente archivos externos creados por otros, también es posible crear nuestras propias librerías y utilizarlas en nuestros programas. Las librerías pueden tener varias extensiones diferentes, las más comunes son: .lib, .bpl, .a, .dll, .h y algunas más ya no tan comunes. Hay un conjunto librerías muy especiales, que se incluyen con todos los compiladores de C y de C++. Son las librerías ANSI o estándar. La declaración de estas se debe realizar desde el principio del código, antes de la declaración de cualquier función o línea de código, debemos indicarle al compilador que librerías usar, para el saber que términos estarán correctos en la escritura de nuestro código y cuáles no. La sintaxis es la siguiente: #include <nombre de la librería> 13. Una declaración de librerías de carácter normal
EDDY ESEQUIEL MORENO BENAVIDES 27 A continuación se mencionan algunas de las librerías de uso común de C++ que aplique durante el curso y que forman parte de las librerías estándar de este lenguaje. Nombre de la librería Descripción de la librería math Contiene los prototipos de las funciones y otras definiciones para el uso y manipulación de funciones matemáticas. iostream Parte del a STL que contiene los algoritmos estándar, es quizá la más usada e importante (aunque no indispensable). stdio Contiene los prototipos de las funciones, macros, y tipos para manipular datos de entrada y salida. stdlib Contiene los prototipos de las funciones, macros, y tipos para utilidades de uso general. string Parte de la STL relativa a contenedores tipo string; una generalización de las cadenas alfanuméricas para albergar cadenas de objetos. vector Parte de la STL relativa a los contenedores tipo vector; una generalización de las matrices unidimensionales C/C++
EDDY ESEQUIEL MORENO BENAVIDES 28 Arreglos Es un tipo de dato de un determinado orden que almacena en el nombre de una sola variable un conjunto limitado de datos o elementos del mismo tipo que dependen del índice que les fue otorgado. Asimismo, es un conjunto de localidades de memoria contiguas donde la dirección más baja corresponde al primer elemento y la dirección más alta al último. Estos al ser declarados no puede cambiar el tipo de dato que les fue otorgado. Estos empiezan a enumerarse a partir del 0 y el índice que les fue otorgado en un inicio es la cantidad de espacios total que tendrá a disposición. Declaración Los arreglos pueden contener un orden infinito de a*b*c*d…*n pero el uso común que se les da es en arreglos de orden unidimensional y bidimensional. La sintaxis para declarar un arreglo unidimensional es: <Tipo de dato> <identificador> < [tamaño del arreglo]>; La sintaxis para declarar un arreglo de a…*n dimensiones es el siguiente: <Tipo de dato> <identificador> < [orden 1] [orden 2]>; 14. Declaración común de un arreglo
EDDY ESEQUIEL MORENO BENAVIDES 29 Acceso al arreglo Para lograr acceso a un arreglo se realiza mediante el uso del subíndice al que se desea acceder justo después del identificador y a continuación ser tratado como una variable más. 15. Acceso al arreglo e impresión del mismo
EDDY ESEQUIEL MORENO BENAVIDES 30 Estructuras Es un grupo en el que se puede declarar una variable pasando a ser esta un miembro de la estructura. Esta se tiene que declarar con anterioridad para poder acceder a sus miembros. Para poder crear una estructura primero se debe definir el tipo estructura (struct) con el nombre que tendrá esta. Siguiendo la siguiente sintaxis: Struct nombre_estructura { Int a = 2; Int b = 3; char[12]= “ejemplo”; } <Identificador de la estructura>; 16. Declaración de una estructura y sus miembros
EDDY ESEQUIEL MORENO BENAVIDES 31 Acceso a estructuras Para lograr acceder a los miembros de la estructura se utiliza el punto ( . ) empezando por el nombre de la estructura y luego del punto seguido del miembro a usar sin que exista espacio alguno. Sintaxis: <Identificador de la estructura>. <Nombre de la variable miembro a usar; 17. Dando valor a un entero en estructura e imprimiéndolo desde el main
EDDY ESEQUIEL MORENO BENAVIDES 32 Entrada y salida de datos en C Formatos Antes de hablar sobre las entradas y salidas en este lenguaje de programación se tiene que hablar sobre su base y como se utilizan los formatos en estos, por lo cual es esencial el manejar el tipo de formato que se desea usar en cualquier momento. Estos formatos son usados en la lectura y escritura de C, por lo cual no debe ser tomado a la ligera. Dato básico Tipo Identificador Código de formato Carácter Carácter char %c Carácter sin signo unsigned char %u Carácter char %s Carácter imprime el carácter % % Entero Entero Decimal int %d,%i Entero Decimal sin signo unsigned int %u Entero corto decimal short int %hd Entero corto decimal sin signo unsigned short int %hu Entero corto decimal con signo signed short int %d Entero largo decimal long int %ld Entero largo decimal sin signo unsigned long int %lu Entero largo decimal con signo signed long it %l Flotante Real(punto flotante) float %f, %g,%G, %e,%E Real double %lf, %lg,%Lg %le, %Le Real long double %lf, %lg,%Lg %le, %Le
EDDY ESEQUIEL MORENO BENAVIDES 33 Entrada de datos La función scanf () se utiliza para ingresar datos y estos pueden ser tecleados para asignarlos a variables, usarlos en cualquier momento o realizar cálculos del valor tomando. Estos proceden a ser guardados con un formato determinado por el programador el cual corresponde al tipo de dato asignado. La sintaxis que se utiliza es: int a; scanf(“ %d ”, a); Con esto sucede que el formato hará referencia al tipo de dato, tomando la cadena de control o formatos entre comillas. 18. Demostración del uso de scanf
EDDY ESEQUIEL MORENO BENAVIDES 34 Salida de Datos La función printf () es similar a la función scanf (), pero este usa para la salida permite escribir textos y datos en la pantalla con determinado formato. Sintaxis: char a = ‘a’; printf(“ %c ”, a); Al imprimir datos en pantalla se puede realizar entre argumentos de la sentencia de control. 1. Los caracteres que se imprimirán en la pantalla 2. Secuencias de escape 3. Uno o varios códigos de formato 19. Impresión de valores con la función especial de C, con su respectivo formato
EDDY ESEQUIEL MORENO BENAVIDES 35 Funciones sin formato Función Descripción getche() Lee un carácter del teclado, no hay que esperar hasta que se pulse la tecla enter. Visualiza el eco del carácter. getchar() Lee un carácter del teclado, espera hasta que se pulsa la tecla enter. getch() Lee un carácter del teclado, no hay que esperar que se pulse la tecla enter. putchar() Imprime un carácter en la pantalla en la posición actual del cursor gets() Lee una cadena de caracteres introducida por el teclado puts() Imprime una cadena en la pantalla, seguida de un carácter de salto de línea.
EDDY ESEQUIEL MORENO BENAVIDES 36 Entrada y salida de datos en C++ Para la entrada y salida de datos se emplea el uso de las palabras reservada CIN y COUT, la ventaja de este a comparación de C es que este no requiere de ningún formato para sacar o leerlos. Para manejar la entrada se utilizan los signo ( >> ) y para la salida se utiliza el signo ( << ). Los datos que se utilizan pueden ser de tipo fundamental o cadenas de caracteres. Los operadores de inserción pueden realizar concatenaciones para poder mostrar en pantalla mayor cantidad de información con variaciones x. Se utiliza el “endl” en C++ para realizar un salto de línea, este es concatenado en las salidas. Para realizar una entrada estándar en un programa se utilizan de igual manera los signos de inserción ( >> ), esto permite obtener el tipo de dato al que va a ir a alojarse el dato. La sintaxis para la lectura es: cin>> <variable>; La sintaxis para la escritura es: cout<< “Texto si se desea”<< <variable>; 20. Demostración del uso de CIN y COUT
EDDY ESEQUIEL MORENO BENAVIDES 37 Sentencias de control If Esta sentencia nos permite elegir si se ejecuta o no un bloque de instrucciones si la condición es verdadera. Si el valor de retorno de la sentencia es 0 esta no se ejecuta, pero si es diferente procede a ejecutar si es distinto de 0. Su sintaxis es: if (condición) { instrucción 1; instrucción 2; instrucción 3; } Else Es la orden de instrucciones que se ejecuta cuando existe un salto en el If, en otras palabras, si el If evaluado resulta como falso se procede a aplicar el Else. Su sintaxis es: if (condición) { Instrucción 1; instrucción 2; } else
EDDY ESEQUIEL MORENO BENAVIDES 38 { instrucción 3; instrucción 4; } Switch-case Esto es una sentencia que permite seleccionar entre diferentes alternativas, y dependiendo de la alternativa seleccionada se ejecutara un bloque de instrucciones. Existen las opciones que ya han sido definidas (case) y la predeterminada (default) que se ejecuta si no se pudo encontrar una opciuon correspondiente. Su sintaxis es: switch (expresión) { case constante1: instrucciones; break; case constante 2: instrucciones; break; · · · default: instrucciones; }
EDDY ESEQUIEL MORENO BENAVIDES 39 For Este pertenece a la sección de bucles; y posee una gran potencia y flexibilidad al ser bastante sencillo y definido. Se debe tener en cuenta que a diferencia de otros bucles este no llegará a ejecutarse si la condición es falsa, ya que la condición se comprueba antes de entrar en el bucle. 21. Descripción grafica del bucle For Su sintaxis es: for(inicialización; condicion; incremento/decremento) { instrucción 1; ........... instrucción N; }
EDDY ESEQUIEL MORENO BENAVIDES 40 While Este es parecido al bucle for, así en el uso de una inicialización, una condición y un incremento. Primero se evalúa la condición y luego procede a ejecutar el bloque de instrucciones siendo el mismo aunque parezca bastante diferente. 22. Descripción grafica de un bucle while-do Su sintaxis es: while (condicion) { instrucción 1; .............. instrucción N; }
EDDY ESEQUIEL MORENO BENAVIDES 41 Do-while Este es el único bucle que por lo menos se ejecutara una vez puesto que este bucle examina la condición una vez se ha ejecutado el bucle, esto es, al final del mismo. El esquema básico de este bucle sería algo así: 23. Descripción grafica del bucle do-while Su sintaxis es: do { instrucción 1; .............. instrucción N; } while (condicion); Break
EDDY ESEQUIEL MORENO BENAVIDES 42 La instrucción de salto break se usa para interrumpir la ejecución normal de un bucle, es decir, la instrucción break finaliza la ejecución de un bucle y, por tanto, el control del programa se transfiere (salta) a la primera instrucción después del bucle. Continue La instrucción de salto continue siempre se usa para interrumpir (romper) la ejecución normal de un bucle. Sin embargo, el control del programa no se transfiere a la primera instrucción después del bucle, como sí hace la instrucción break, es decir, el bucle no finaliza, sino que, finaliza la iteración en curso, transfiriéndose el control del programa a la condición de incremento de contadores y después a la condición de salida del bucle, para decidir si se debe realizar una nueva iteración o no. Return La instrucción de salto return es utilizada en lenguaje C para devolver el control de ejecución desde la función que contiene el return a la rutina que la invocó y para indicar el valor de retorno de una función. Para terminar una función debe de ir el valor return, y para terminar la función Main tiene que aplicarse el return 0 lo cual hace que termine el programa. 24. Clara demostración del uso de las funciones break y return
EDDY ESEQUIEL MORENO BENAVIDES 43 Ficheros El estándar de C contiene funciones para la edición de ficheros, estas están definidas por la librería “stdio.h” y por lo general empiezan estos con la letra f debido a la palabra “File” que es fichero en español. Se utiliza junto a un puntero tipo FILE que determinara las acciones a realizar. Los pasos para realizar uso de los ficheros es:  Crear un apuntador del tipo FILE *  Abrir el archivo utilizando la función fopen y asignándole el resultado de la llamada a nuestro apuntador.  Hacer las diversas operaciones (lectura, escritura, etc).  Cerrar el archivo utilizando la función fclose. Fopen Esta función realiza la creación y apertura de archivos en el disco duro. La sintaxis para su uso es sencilla, solo usando unos cuantos parámetros y realizando un buen análisis de lo que se desea realizar. Y esta es: FILE * fopen (“Nombre del archivo con extensión”, “Modo de apertura”); Los modos de apertura más comunes son los siguientes mencionados: Tipo Descripción general "r" read: Abre un archivo para operaciones de entrada, este debe salir. "w" write: Crea un archivo para operaciones de salida. Si un archive con el mismo nombre existe su contenido es descartado y es tratado como un archivo nuevo. "a" append: Abre un archivo para salida al final del archivo. Las operaciones de salida siempre escriben datos al final del archivo, expandiéndolo. El archivo es creado si no existe. "r+" read/update: Abre un archivo para actualización (entrada y salida). El archive debe existir. "w+" write/update: Crea un archive vacío y lo abre para actualizar (entrada y salida). Si un archivo con el mismo nombre existe su contenido es descartado y es tratado como un fichero nuevo.
EDDY ESEQUIEL MORENO BENAVIDES 44 "a+" append/update: Abre un archivo para actualización (entrada y salida) con todas las operaciones de escritura al final del archivo. Se puede mover el cursor para que afecte a la entrada de datos, pero las operaciones de salida lo mueven al final del archivo. El archivo es creado si no existe. 25. Demostración de creación y apertura de un archivo Fclose Esta función es para poder realizar el cierre de un fichero de manera correcta, si no es aplicado puede corromperse la información usada o crear fallos en el programa. La sintaxis es sencilla, solamente usando la palabra reservada y el puntero del archivo: fclose (<puntero del archivo usado>); Un valor de retorno cero indica que el fichero ha sido correctamente cerrado, si ha habido algún error, el valor de retorno es la constante EOF.
EDDY ESEQUIEL MORENO BENAVIDES 45 26. Demostración de cierre de un archivo Feof Esta función sirve para identificar si ya se encontró el final de un archivo dentro de un fichero. Esta siempre devolverá un valor de falso si no es encontrado el final del archivo, de lo contrario devolverá un valor diferente a este. La sintaxis es la siguiente: feof(<puntero que se está usando en el fichero>); Rewind La función que realiza es devolver el cursor hasta el inicio del archivo, siendo su sintaxis la siguiente: rewind(<puntero del archivo que se está utilizando>); 27. El uso de rewind y FEOF en el código Lectura
EDDY ESEQUIEL MORENO BENAVIDES 46 La lectura de un archivo es importante para poder extraer información de este sin mucha preocupación al tener la información “en peligro”. Se puede trabajar con estos de diferentes formas y diferentes funciones. Pero la función que recomiendo es fgets la cual ha sido la que mayor me ha ayudado debido a su diversidad y fácil uso. Esta función está diseñada para leer cadenas de caracteres. Leerá hasta n-1 caracteres o hasta que lea un cambio de línea 'n' o un final de archivo EOF. En este último caso, el carácter de cambio de línea 'n' también es leído. La sintaxis correspondiente a fgets es la siguiente: fgets(<&apuntador>, <tamaño o largo a extraer>, <puntero del fichero>) Escritura de Archivos Para almacenar información permanentemente se procede a escribir en ficheros, los cuales utilizan varias funciones, de las cuales la que más he encontrado útil es fwrite debido a su diversidad como la función de lectura antes mencionada. Esta función fue pensada para trabajar con registros de longitud constante y forma pareja con fread. Es capaz de escribir hacia un fichero uno o varios registros de la misma longitud almacenados a partir de una dirección de memoria determinada. El valor de retorno es el número de registros escritos, no el número de bytes. La sintaxis de este es: fwrite(<&apuntador>, <tamaño a guardar>, <cantidad de caracteres a guardar>, <puntero>); 28. Aplicación del fgets y fwrite
EDDY ESEQUIEL MORENO BENAVIDES 47 Funciones^ Estas son el conjunto de instrucciones que realizan una tarea específica, algunos llaman a estos subprocesos debido a que siempre van anexados al main (proceso principal), aunque este también es una función. Estos pueden tomar parámetros y tipo de dato de retorno o no. Estos son una herramienta valiosa ya que ayudan a crear módulos y formar el código estructurado. Siempre se debe de declarar al inicio luego del using namespace std. En este lenguaje el uso de parámetros es obligatorio, pero si no se recibe nada hay que dejar el espacio en blanco, lo que significa que si se declarara una función llamada “Ejemplo” que no recibe ningún argumento ni retorna valores se mostrara de la siguiente manera: void Ejemplo( ); Para revisar en específico su sintaxis se realizó el siguiente ejemplo de relleno: <Tipo de valor de retorno> <identificador o nombre de función> < (parámetros)>; Luego de la declaración de este se puede realizar el uso escribiendo lo mismo que en la declaración, sin el punto y coma, y continuando con apertura de llaves en donde se colocara una parte del código a utilizar. 29. Declaración de una función de tipo vacío
EDDY ESEQUIEL MORENO BENAVIDES 48 Punteros Los punteros son aquellos indicadores de memoria volátil del sistema, en los cuales cuya posición en memoria se apuntan valga la redundancia. Siempre que queremos usar el apuntador se debe anteponer el asterisco (*) para indicar que usaremos el valor en la posición de memoria apuntada. De no usar el asterisco el comportamiento sería impredecible. Estaremos haciendo uso de la dirección de memoria más no del valor almacenado en ésta. Mientras que el ampersand es un operador de C++ y es comúnmente utilizado para los punteros. Este operador nos permite obtener la dirección de memoria de una variable cualquiera y es justo esto (la dirección en memoria) lo que utilizan los punteros para referenciar valores, permitiendo la edición global de este mismo. El asterisco es, por decirlo de alguna forma, el operador por excelencia de los punteros. Su utilidad está en apuntar a un espacio de memoria, acceder al valor y copiarlo. 30. Uso del puntero en funciones
EDDY ESEQUIEL MORENO BENAVIDES 49 Anexos Proyecto final de clase (Administrador de apartamentos) Main #include <stdio.h> // Cabecera estándar E/S C #include <stdlib.h> // Cabecera estandar #include "datos.h" // Cabecera en la que se almacenan algunas variables #include <time.h> // Cabecera que se utiliza para extraer el tiempo de la maquina #include <iostream> // Libreria estándar E/S C++ #include <vector> // Libreria para realizar manejo de variables y arrays correctamente #include <conio.h> // Cabecera que se utiliza en el login para "pausar", cambiar el fondo de pantalla, letras de la pantalla y limpiarla. #include <windows.h> // Cabecera que permite realizar ajuste de la ventana del ejecutable #include <sstream> // Permite la manipulacion de cadena de caracteres "Strings" #define ENTER 13 //Funcion usada en el login #define BACKSPACE 8 //Funcion usada en el login using namespace std; void ver_pago(); ///Subproceso que permite ver los pagos realizados en el año por el inquilino. void SubMenuApartamento(FILE *f); //Menu que muestra la opcion de ingresar inquilino, ver inquilino, ver pago.
EDDY ESEQUIEL MORENO BENAVIDES 50 void visualizar(FILE *f); //Muestra los datos del inquilino y muestra un menu que permite su modificacion o eliminacion. void modificar(FILE *f); //Modifica los datos del inquilino a eleccion del usuario. void ingresar(); //Permite ingresar todos los datos de un inquilino nuevo. void pago(); //Realiza el pago de los meses de un inquilino void ver_pago(FILE *f); //Permite ver los meses que se han pagado de un inquilinos void Menu(); //Despliega el menu principal con varias opciones void crearFichero(FILE* f, int &salida); //Si no se ha creado el fichero lo crea void login(int &valido); //Simple login para una persona que no permite el ingreso de alguien ajeno. void eliminar(); //Elimina el registro del inquilino registrado void fecha(); //Permite mostrar la fecha en el programa bool AjustarVentana(int Ancho, int Alto); //Ajusta el tamaño de la ventana del ejecutable bool AjustarVentana(int Ancho, int Alto) { _COORD Coordenada; Coordenada.X = Ancho; Coordenada.Y = Alto; _SMALL_RECT Rect; Rect.Top = 0; Rect.Left = 0; Rect.Right = Ancho - 1; Rect.Bottom = Alto - 1;
EDDY ESEQUIEL MORENO BENAVIDES 51 // Obtener el handle de la consola HANDLE hConsola = GetStdHandle(STD_OUTPUT_HANDLE); // Ajustar el buffer al nuevo tamaño SetConsoleScreenBufferSize(hConsola, Coordenada); // Cambiar tamaño de consola a lo especificado en el buffer SetConsoleWindowInfo(hConsola, TRUE, &Rect); return TRUE; } void login(int &valido) { vector<string> usuarios; // vector de usernames vector<string> passwords; // vector de passwords // Se llena el vector de username con aquellos usarios que tienen permiso para logearse usuarios.push_back("Mercedes"); // Se llena el vector de passwords con las contraseñas de los usuarios passwords.push_back("1234"); string usuario, password; // Variables en donde se reciben los datos del usuario int contador = 0;
EDDY ESEQUIEL MORENO BENAVIDES 52 bool ingresa = false; cout<<"--------------------------------------------------------------------------------------------- -------------------------"<<endl; cout<<",---. | | | ,---. | o o | | " << endl; cout<<"|---|,---.,---.,---.|--- ,---.,-.-.,---.,---.|--- ' ,---. |---|,---|,-.-..,---..,---.|--- ,-- -.,---.|--- ,---.,---." << endl; cout<<"| || |,---|| | ,---|| | ||---'| || `---. | || || | ||| ||`---.| | ,---|| | || " << endl; cout<<"` '|---'`---^` `---'`---^` ' '`---'` '`---' `---' ` '`---'` ' '`` '``---'`---'` `--- ^`---'`---'` " << endl; cout<<" | " << endl; cout<<"--------------------------------------------------------------------------------------------- -------------------------" <<endl; Sleep(4500); do { system("cls"); cout<< "ttt------------------------------"<<endl; cout << "tttLOGIN DE USUARIO" << endl; cout<< "tt Apartament's Administrator"<<endl; cout << "ttt----------------------------" << endl; // Lectura del username cout <<endl<<"tUsuario: ";
EDDY ESEQUIEL MORENO BENAVIDES 53 getline(cin, usuario); // Lectura del password char caracter; cout << "tContrase244a: "; caracter = getch(); password = ""; while (caracter != ENTER) { if (caracter != BACKSPACE) { password.push_back(caracter); cout << "*"; } else { if (password.length() > 0) { cout << "b b"; password = password.substr(0, password.length() - 1); } } caracter = getch();
EDDY ESEQUIEL MORENO BENAVIDES 54 } // Se procede a buscar al usuario y password for (int i = 0; i < usuarios.size(); i++) { if (usuarios[i] == usuario && passwords[i] == password) { ingresa = true; // Se sale del ciclo porque se encontró al usuario } } if (!ingresa) // Entra aquí cuando no se encuentra el usuario { cout << "nntEl usuario y/o password son incorrectos" << endl; cin.get(); contador++; } } while (ingresa == false && contador < 3); if (ingresa == false) { cout << "ntUsted no pudo ingresar al sistema." << endl; } else
EDDY ESEQUIEL MORENO BENAVIDES 55 { cout << "nntBienvenido al sistema Apartament's Administrator " << endl; cin.get(); valido=1; //Esta variable hace que pueda continuar por el if del main() } return; } void Menu() { system("cls"); cout << "__________________________________________"<< endl; cout <<"| |"<< endl; cout <<"| Apartament's Administrator |"<< endl; cout <<"|__________________________________________|"<< endl; cout <<"| B I E N V E N I D O |"<< endl; cout <<"| 1. Ver Apartamento 1 |"<< endl; cout <<"| 2. Ver Apartamento 2 |"<< endl; cout <<"| 3. Ver Apartamento 3 |"<< endl; cout <<"| 4. Ver Apartamento 4 |"<< endl; cout <<"| 5. Ver Apartamento 5 |"<< endl; cout <<"| 6. Ver Apartamento 6 |"<< endl; cout <<"| 7. Ver Apartamento 7 |"<< endl;
EDDY ESEQUIEL MORENO BENAVIDES 56 cout <<"| 8. Salir del Programa |"<< endl; cout <<"| |"<< endl; cout <<"| "; fecha(); //Permite mostrar la fecha del sistema cout<<" |"<< endl; cout <<"|__________________________________________|"<< endl; } void crearFichero(FILE *f, int &salida) { int creacion=0; cout<<"La base de datos no ha sido creada."<< endl; cout<<"¿Desea crearla?"<<endl; cout<<"1. Si."<<endl; cout<<"2. No."<<endl; cin>>creacion; if (creacion==1) { f = fopen("apartamentos", "w"); } else { salida=1; //Permite la salida del main() cout<<"Gracias por utilizar el programa"; }
EDDY ESEQUIEL MORENO BENAVIDES 57 return; } void eliminar() { reg[opc-1].estado=1; //Pone el estado del inquilino seleccionado en modo: Disponible } void modificar(FILE *f) { int x; int opcion; fflush(stdin); cout<<" Archivos abiertos con exito. "<<endl<<endl<<endl; cout << "Ingresa una opcion segun el campo que desea modificar: " << endl; cout << "1: Para modificar el nombre. " << endl; cout << "2: Para modificar la cedula. " << endl; cout << "3: Para modificar la ocupacion. " << endl; cout << "4: Para modificar el telefono. " << endl; cout << "5: Para modificar el sexo. " << endl; cout << "6: Para modificar la edad. " << endl;
EDDY ESEQUIEL MORENO BENAVIDES 58 cout << "7: Regresar al menu" << endl; do { cout << endl<< "Seleccione una opci242n: " << endl; cin >> opcion; switch(opcion) { case 1: { fflush(stdout); cout <<endl<<"Digite el nuevo nombre: " << endl; fflush(stdin); gets(reg[opc-1].nombre); break; } case 2: { fflush(stdout); cout<<endl<<"Digite la nueva c202dula: "<<endl; fflush(stdin); gets(reg[opc-1].cedula); break; } case 3: { fflush(stdout);
EDDY ESEQUIEL MORENO BENAVIDES 59 cout <<endl<< "Digite la nueva ocupaci242n: " << endl; fflush(stdin); gets(reg[opc-1].ocupacion); break; } case 4: { fflush(stdout); cout <<endl<< "Digite el nuevo tel202fono: " << endl; fflush(stdin); gets(reg[opc-1].telefono); break; } case 5: { fflush(stdout); cout <<endl<< "Digite el nuevo sexo: " << endl; fflush(stdin); gets(reg[opc-1].sexo); break; } case 6: { fflush(stdout); cout <<endl<< "Digite la nueva edad: " << endl; fflush(stdin); cin >> reg[opc-1].edad;
EDDY ESEQUIEL MORENO BENAVIDES 60 break; } case 7: { system("cls"); cout<<endl<<endl<<" La ficha de informaci242n del inquilino "<<opc<<" se ha modificado."<<endl<<endl; f= fopen("apartamentos","w"); //Abre el archivo para escribir en el rewind(f); //Para poner el puntero al inicio del archivo for (x=1 ; x<=7; x++) { fwrite(&reg[x-1], sizeof(struct inquilinos), 1, f); //Se realiza un loop para escribir en todas las estructuras del fichero //sin cambiar nada mas que lo seleccionado como inquilino. } break; } default: cout <<endl<< "Digite una opci242n v240lida!" << endl; break; } } while (opcion!=7); system("PAUSE"); system("cls");
EDDY ESEQUIEL MORENO BENAVIDES 61 return; } void ingresar() { system("cls"); fflush(stdin); cout << "Ingrese el nombre del inquilino: " << endl; gets(reg[opc-1].nombre); cout << "Ingrese la c202dula del inquilino: " << endl; fflush(stdin); gets(reg[opc-1].cedula); cout << "Ingrese la edad del inquilino: " << endl; fflush(stdin); cin >> reg[opc-1].edad; cout << "Ingrese la ocupaci242n del inquilino: " << endl; fflush(stdin); gets(reg[opc-1].ocupacion); cout << "Ingrese el tel202fono del inquilino: " << endl;
EDDY ESEQUIEL MORENO BENAVIDES 62 fflush(stdin); gets(reg[opc-1].telefono); cout << "Ingrese el sexo: M/F" << endl; fflush(stdin); gets(reg[opc-1].sexo); reg[opc-1].estado=0; //Al poner el estado en 0 se valida el cuarto como OCUPADO return; } void visualizar(FILE *f) { int opcion; system("cls"); fflush(stdout); cout << "Nombre: " << reg[opc-1].nombre << endl; fflush(stdout); cout << "C202dula: " << reg[opc-1].cedula << endl; fflush(stdout); cout << "Ocupaci242n: " << reg[opc-1].ocupacion << endl; fflush(stdout); cout << "Tel202fono: " << reg[opc-1].telefono << endl; fflush(stdout);
EDDY ESEQUIEL MORENO BENAVIDES 63 cout << "Edad: " << reg[opc-1].edad << endl; fflush(stdout); cout << "Sexo: " << reg[opc-1].sexo << endl<<endl; do { cout << "Seleccione una Opci242n: " << endl; cout << " ____________________________ "<< endl; cout << "| |"<< endl; cout << "|1. Modificar inquilino |"<< endl; cout << "|2. Eliminar inquilino |"<< endl; cout << "|3. Regresar al men243 |"<< endl; cout << "|____________________________|"<< endl; fflush(stdin); cin >> opcion; switch(opcion) { case 1: { system("cls"); fclose(f); modificar(f); break; } case 2: {
EDDY ESEQUIEL MORENO BENAVIDES 64 system("cls"); eliminar(); break; } case 3: { break; } default: { cout<<"Opci242n incorrecta"; break; } } } while(opcion!=3); return; } void SubMenuApartamento(FILE *f) { int opcion = 0; cout<<"Usted seleccion242 el apartamento "<< opc << endl;
EDDY ESEQUIEL MORENO BENAVIDES 65 cout<<"Estado:"; if (reg[opc-1].estado==1) { do { cout << " Disponible"<< endl; cout <<" ________________________________"<< endl; cout <<"| |"<< endl; cout <<"| 1 - Ingresar nuevo Inquilino |"<< endl; cout <<"| 2 - Regresar al men243 principal |"<< endl; cout <<"|________________________________|"<< endl; cout <<"Seleccione Una Opci242n: "; fflush(stdin); cin >> opcion; switch (opcion) { case 1: ingresar(); break; case 2: Menu();
EDDY ESEQUIEL MORENO BENAVIDES 66 break; default: cout<<"Estimado user digite una opci242n v240lida!"<<endl; system("pause"); break; } return; } while (opcion!=2); } else { if (reg[opc-1].estado==0) { cout << " Ocupado" << endl; cout <<" ________________________________"<< endl; cout <<"| |"<< endl; cout <<"| 1 - Ver Inquilino |"<< endl; cout <<"| 2 - Ver Pagos |"<< endl; cout <<"| 3 - Regresar al men243 |"<< endl; cout <<"|________________________________|"<< endl; cout <<"Seleccione Una Opci242n: "; fflush(stdin); cin >> opcion; switch (opcion)
EDDY ESEQUIEL MORENO BENAVIDES 67 { case 1: visualizar(f); break; case 2: ver_pago(f); break; default: system("cls"); break; } } } return; } void pago() { int opcion; do { cout<<"¿A que mes ingresara pago?"<<endl<<endl; cout<<"Seleccione el mes:"<<endl; cout<<"1- Enero"<<endl;
EDDY ESEQUIEL MORENO BENAVIDES 68 cout<<"2- Febrero"<<endl; cout<<"3- Marzo "<<endl; cout<<"4- Abril"<<endl; cout<<"5- Mayo"<<endl; cout<<"6- Junio"<<endl; cout<<"7- Julio"<<endl; cout<<"8- Agosto"<<endl; cout<<"9- Septiembre"<<endl; cout<<"10- Octubre"<<endl; cout<<"11- Noviembre"<<endl; cout<<"12- Diciembre"<<endl<<endl; cout<<"13- Regresar"<<endl; cin>>opcion; if (opcion>=1 && opcion<=12) { reg[opc-1].pago[opcion-1]=true; } else { if (opcion==13) { system("cls"); cout<<"Adi242s, hasta pronto"<<endl; } else
EDDY ESEQUIEL MORENO BENAVIDES 69 { cout<<"Opci242n incorrecta";////// } } if (opcion>=1 && opcion<=12) { cout <<"Se ha registrado el pago del mes "<<opcion<< endl; system("PAUSE"); system("cls"); } } while (opcion!=13); return; } void ver_pago(FILE *f) { int x,opcion; system("cls"); for (x=1; x<=12; x++) { if (x<10) {
EDDY ESEQUIEL MORENO BENAVIDES 70 cout<<"Mes "<<x; } else { cout<<"Mes "<<x; } if (reg[opc-1].pago[x-1]!=false) { cout<<"= Pagado"<<endl; } else { cout<<"= No pagado"<<endl; } } system("pause"); system("cls"); cout<<"Que desea realizar?"<<endl; cout <<" ________________________________"<< endl; cout <<"| |"<< endl; cout <<"| 1 - Realizar pago |"<< endl; cout <<"| 2 - Regresar al menu |"<< endl; cout <<"|________________________________|"<< endl;
EDDY ESEQUIEL MORENO BENAVIDES 71 do { fflush(stdin); cin>>opcion; switch(opcion) { case 1: { system("cls"); pago(); break; } case 2: { system("cls"); break; } default: { cout<<"Estimado user digite una opci242n valida!"<<endl;
EDDY ESEQUIEL MORENO BENAVIDES 72 system("pause"); break; } } return; } while (opcion!=2); } void fecha() { time_t t = time(NULL); struct tm tm= *localtime(&t); //Estructura en la que se guardan todos los datos obtenidos del sistema. int anio; int mes; int dia; anio=tm.tm_year+1900; //Se guarda el año actual, se le suma 1900 ya que este empieza a contar desde el 1900. mes=tm.tm_mon+1; //Se guarda el mes actual, se suma 1 porque empieza a contar desde 0. dia=tm.tm_mday; //Se guarda el dia actual.
EDDY ESEQUIEL MORENO BENAVIDES 73 //number to convert int a string stringstream fechaentradastream; //Se declara una string personalizable o modificable a placer. fechaentradastream << anio<<"/"<<mes<<"/"<<dia;//add the value of Number to the characters in the stream //Se ingresa en esa stream valores enteros. string fechaentrada = fechaentradastream.str(); //Convierte de un tipo raro que no se puede mandar entre subprocesos a string cout<<fechaentrada; //imprime la fecha. } int main() { system("color 5F"); //Cambia el color de letra y fondo system("TITLE Apartament's Administrator "); //Cambia el titulo del ejecutable AjustarVentana(120,25); //Ajusta la ventana del ejecutable int x; int salida=0; int valido=0;
EDDY ESEQUIEL MORENO BENAVIDES 74 login(valido); if (valido==1) { AjustarVentana(65,40); //Ajusta la ventana del ejecutable for (x=1; x<=7; x++) { reg[x-1].estado=1; } FILE *f; f = fopen("apartamentos", "r"); if(!f) { crearFichero(f, salida); } else { for (x=1 ; x<=7; x++) { fread(&reg[x-1],sizeof(struct inquilinos),1,f); /// } fclose(f); }
EDDY ESEQUIEL MORENO BENAVIDES 75 while (salida!=1) { Menu(); cout<<"Digite su opci242n: "; fflush(stdin); cin >> opc; switch (opc) { case 1: case 2: case 3: case 4: case 5: case 6: case 7: system("cls"); SubMenuApartamento(f); break; case 8: cout << "Gracias por utilizar el programa " << endl; salida=1; f=fopen("apartamentos","w"); for (x=1 ; x<=7; x++) { fwrite(&reg[x-1], sizeof(struct inquilinos), 1, f); /// }
EDDY ESEQUIEL MORENO BENAVIDES 76 fclose(f); break; default: cout<<"Estimado user digite una opci242n valida!"<<endl; system("pause"); } } } return 0; } Cabecera datos.h int opc=0; //Opcion global que es necesaria en todos los subprocesos. struct inquilinos { bool pago[12]; //Bool para los pagos del año. char nombre[50]; //Para guardar el nombre char cedula[50]; //Para guardar la cedula char ocupacion[50]; //Para guardar la ocupacion del inquilino char telefono[10]; //Para guardar el telefono del inquilino char sexo[1]; //Para guardar el sexo int edad; //Para guardar la edad int estado; //Para guardar el estado actual del apartamento }reg[7];
EDDY ESEQUIEL MORENO BENAVIDES 77 struct tm_tm; //Estructura de TIME Login + Ejercicios de empleados #include <cstdlib> #include <iostream> #include <fstream> #include <windows.h> #include <conio.h> #include <string.h> #include <stdio.h> #define MAX 4 #define MIN 0 #include <stdlib.h> #include "Empleados_jefe.h" #include "Empleados.h" using namespace std; //SISTEMA DE REGISTRO DE USUARIOS //CONSTANTES const char FINCAD = char(0); const int MAXCAD = 20; const char SP = ' '; //variables
EDDY ESEQUIEL MORENO BENAVIDES 78 char contrasena; int i; int contador=0; //TIPOS typedef char TCadena[MAXCAD+1]; // MAXCAD caracteres + FINCAD //Estructura struct Persona_R { TCadena PASS; }; // CABECERA DE PROCEDIMIENTOS Y FUNCIONES void pausa(); void finalizar_programa(); void borrar_pantalla(); void Ingresar_PASS(Persona_R &p); void confirmar_PASS(Persona_R &p); // Algoritmos de Manejo de Ficheros de Texto void insertarPersonaTXT(TCadena nombreFichero, Persona_R p); void EscribePersonaFicheroTXT(ofstream &fichero, Persona_R p); void verificar_existencia_fichero(TCadena nombreFichero); void verificar_existencia_de_usuario(TCadena nombreFichero); void verificar_contrasena(TCadena nombreFichero,Persona_R &password);
EDDY ESEQUIEL MORENO BENAVIDES 79 struct Empleado emp; void menu () { printf("n ----- MENU PRINCIPAL------ n"); printf("n ------------------------ n"); printf("nt 1: Crear Fichero Empleado n"); printf("nt 2: Agregar Nuevo Empleado n"); printf("nt 3: Consultar un empleado segun INSS n"); printf("nt 4: Ver Empleados registrados n"); printf("nt 5: Eliminar Empleado segun INSS n"); printf("nt 6: Salir n"); } void menuInv () { printf("n ----- MENU PRINCIPAL------ n"); printf("n ------------------------ n"); printf("nt 1: Crear Fichero Empleado n"); printf("nt 2: Consultar un empleado segun INSS n"); printf("nt 3: Ver Empleados registrados n"); printf("nt 4: Salir n"); } void crearFichero(FILE *fichero) { fichero = fopen("empleado","r"); if (!fichero)
EDDY ESEQUIEL MORENO BENAVIDES 80 { fichero = fopen("empleado","w"); printf("n Fichero creado con exito"); } else { printf("n El fichero ya existe"); } fclose(fichero); return; } void InsertarDatos(FILE *fichero) { fichero = fopen("empleado","a+"); fflush(stdin); printf("n Digite su nombre: "); gets(emp.nombresApellidos); fflush(stdin); printf("n"); printf("n Digite su cedula: "); gets(emp.cedula); fflush(stdin); printf("n"); printf("n Digite su numero inss: "); gets(emp.inss); fflush(stdin);
EDDY ESEQUIEL MORENO BENAVIDES 81 printf("n"); printf("n Digite su profesion: "); gets(emp.profesion); fflush(stdin); printf("n"); printf("n Digite su puesto de trabajo: "); gets(emp.puestoTrabajo); fflush(stdin); printf("n"); printf("n Digite su salario: "); scanf("%f",&emp.salario); fflush(stdin); printf("n"); printf("n Digite su sexo, considerando que: "); printf("n 1=Masculino "); printf("n 0=Femenino "); scanf("%d",&emp.sexo); fflush(stdin); printf("n"); fwrite(&emp, sizeof(struct Empleado), 1, fichero); fclose(fichero); return; } void EliminarEmpleado (FILE *fichero, FILE *temp) { bool encontrado=false;
EDDY ESEQUIEL MORENO BENAVIDES 82 fichero=fopen("empleado","r"); temp=fopen("temporal","a+"); char inss[20]; cout<<"Digite el numero INSS: "; cin>>inss; while(!feof(fichero)) { fread(&emp,sizeof(Empleado),1,fichero); if (strcmp(inss,emp.inss)==0) { cout<<"Nombre "<<emp.nombresApellidos<<endl; cout<<"INSS "<<emp.inss<<endl; cout<<"Registro eliminado"<<endl; encontrado=true; } else { fwrite(&emp,sizeof(Empleado),1,temp); } } if (encontrado==false) { cout<<"Clave no encontrada"<<endl; } fclose(fichero); fclose(temp); remove("empleado");
EDDY ESEQUIEL MORENO BENAVIDES 83 rename("temporal","empleado"); system("pause"); } void ConsultarEmpleado (FILE *fichero) { char inss[20]; cout<<"Ingrese el numero inss: "; cin>>inss; fichero=fopen("empleado","r"); while(fread(&emp,sizeof(Empleado),1,fichero)) { if (strcmp(inss,emp.inss)==0) { cout<<"Nombre: "<<emp.nombresApellidos<<endl; cout<<"Cedula: "<<emp.cedula<<endl; cout<<"INSS: "<<emp.inss<<endl; cout<<"Puesto de trabajo: "<<emp.puestoTrabajo<<endl; cout<<"Profesion: "<<emp.profesion<<endl; cout<<"Salario: "<<emp.salario<<endl; cout<<"Sexo: "<<emp.sexo<<endl; } fclose(fichero); system("pause");
EDDY ESEQUIEL MORENO BENAVIDES 84 } } void verDatos (FILE *fichero) { int numero = 1; fichero = fopen("empleado","r"); if (fichero==NULL) { printf("n Archivo empleado no existe!!!"); } fread(&emp, sizeof(struct Empleado), 1, fichero); printf("n t Nombre t Cedula t INSS t Profesion t Puesto de trabajo t Salario t Sexo n"); while(!feof(fichero)) { printf("n t %s t %s t %s t t %s t t %s t %.2f t %d n", emp.nombresApellidos, emp.cedula, emp.inss, emp.profesion, emp.puestoTrabajo, emp.salario, emp.sexo); fread(&emp, sizeof(struct Empleado), 1, fichero); numero++; } fclose(fichero); system("PAUSE"); system("cls"); return; }
EDDY ESEQUIEL MORENO BENAVIDES 85 void modificarEmp(FILE *fichero) { bool encontrado =false; int codEmp=0; FILE *archivoTemp; struct Empleado reg; archivoTemp = fopen("temporal.txt","a+"); fichero=fopen("violento","r"); if(archivoTemp==NULL && fichero==NULL) { printf("Error al abrir los archivos!!!"); } else { fflush(stdin); printf("Archivos abiertos on exito!!! n"); system("PAUSE"); system("cls"); printf("Ingrese el codigo del empleado que desea modificar"); scanf("%d",&codEmp); rewind(fichero); fread(&reg,sizeof(Empleado),1,fichero); while (!feof(fichero))
EDDY ESEQUIEL MORENO BENAVIDES 86 { if(codEmp==emp.inss) { encontrado=true; fflush(stdout); printf("CodEmpleado: %d n", emp.inss); printf("Empleado: %s n", emp.nombresApellidos); printf("Edad: %d n", emp.edad); printf("Sueldo: %.2f n", emp.salario); printf("----------------------------------- n"); int opc=0; fflush(stdin); printf("Ingrese una opcion segun el campo que desea modificar"); printf("1: Para modificar el nombre. n"); printf("2: Para modificar la edad. n"); printf("3: Para modificar el sueldo. n"); printf("opcion: "); scanf("%d", "opc"); switch(opc) { case 1: { fflush(stdout); printf("Digite el nuevo nombre: n");
EDDY ESEQUIEL MORENO BENAVIDES 87 fflush(stdin); gets(emp.nombresApellidos); break; } case 2: {fflush(stdout); printf("Digite la nueva edad: n"); fflush(stdin); gets(emp.edad); break; } case 3: { fflush(stdout); printf("Digite el nuevo sueldo: n"); fflush(stdin); gets(emp.salario); break; } default: printf("Digite una opcion valida!!!!"); break; } fwrite(&emp, sizeof(struct Empleado),1, archivoTemp);
EDDY ESEQUIEL MORENO BENAVIDES 88 printf("Registro modificado!!! n" ); } else { fwrite(&emp, sizeof(struct Empleado),1, archivoTemp); } fread(&emp, sizeof(Empleado),1,fichero); } if (encontrado == false) { printf("Registro no encontrado!!!"); } fclose(archivoTemp); fclose(fichero); } // PROGRAMA PRINCIPAL int main() {
EDDY ESEQUIEL MORENO BENAVIDES 89 Persona_R p; Persona_R password; char opcion; int num; bool fin, encontrado; TCadena nombre_usuario_registrado; int opcion_menu; cout << "Bienvenido" << endl; cout << "----------------------------" << endl; cout << "1. Ingresar como Usuario" << endl; cout << "2. Ingresar como Visitante" << endl; cout << "3. Salir del Programa." << endl; cout << "----------------------------nn" << endl; cout << "Introduzca Opcion: "; cin >> opcion_menu; if (opcion_menu==4) { finalizar_programa(); } if((opcion_menu<MIN)||(opcion_menu>MAX)) { try {
EDDY ESEQUIEL MORENO BENAVIDES 90 system("cls"); cout<<"nnt ============================n" <<"nnt | ESTA OPCION ES INCORRECTA |n" <<"nnt ============================n"; Sleep(1500); system("cls"); main(); } catch(...) { cout << "n UN ERROR HA OCURRIDO " << endl; } } switch(opcion_menu) { case 1: { cout << "n Digite su Nombre de Usuario: ";//INGRESAR COMO USUARIO cin >> nombre_usuario_registrado; verificar_existencia_fichero(nombre_usuario_registrado); system("cls"); //confirmar_PASS(password); verificar_contrasena(nombre_usuario_registrado,password);
EDDY ESEQUIEL MORENO BENAVIDES 91 //Declaraciones system("cls"); int salida = 0; FILE *fichero; FILE *temp; while(!salida) { int opc = 0; menu(); printf("Digite su opcion: "); scanf("%d", &opc); switch(opc) { case 1: system("cls"); crearFichero(fichero); break; case 2: system("cls"); InsertarDatos(fichero); break; case 3: system("cls"); ConsultarEmpleado(fichero);
EDDY ESEQUIEL MORENO BENAVIDES 92 break; case 4: system("cls"); verDatos(fichero); break; case 5: system("cls"); EliminarEmpleado(fichero, temp); break; case 6: system("cls"); salida = 1; finalizar_programa(); break; default: printf("Estimado usuario digite una opcion valida"); } } Sleep(1000);borrar_pantalla();main(); break; } case 2: { cout << "n Hola, usted ha accedido como visitante n"; // Ingresar como visitante int salida = 0; FILE *fichero;
EDDY ESEQUIEL MORENO BENAVIDES 93 FILE *temp; while(!salida) { int opc = 0; menuInv(); printf("Digite su opcion: "); scanf("%d", &opc); switch(opc) { case 1: system("cls"); crearFichero(fichero); break; case 2: system("cls"); ConsultarEmpleado(fichero); break; case 3: system("cls"); verDatos(fichero); break; case 4: system("cls"); salida = 1; finalizar_programa();
EDDY ESEQUIEL MORENO BENAVIDES 94 break; default: printf("Estimado usuario digite una opcion valida"); } } Sleep(1500); borrar_pantalla();main(); break; } } return 0; } // IMPLEMENTACIÓN DE PROCEDIMIENTOS Y FUNCIONES void finalizar_programa() { borrar_pantalla(); printf("El Programa cerrara en segundos"); Sleep(1500); exit(0); } void pausa() { system("PAUSE"); }
EDDY ESEQUIEL MORENO BENAVIDES 95 void borrar_pantalla() { system("CLS"); } void Ingresar_PASS(Persona_R &p) { cout << "Escriba su nueva contraseña: " ; cin >> p.PASS; cout<<"n Se ha registrado de manera correcta"<<endl; Sleep(2500); } void confirmar_PASS(Persona_R &password) { cout << "Escriba su contraseña: " ; cin >> password.PASS; } // Algoritmos de Manejo de Ficheros de Texto void insertarPersonaTXT(TCadena nombreFichero, Persona_R p) { ofstream out; out.open(nombreFichero,ios::app); // Abro el fichero para añadir if (out.bad()) { // El fichero no existe ... lo creo
EDDY ESEQUIEL MORENO BENAVIDES 96 out.open(nombreFichero); } EscribePersonaFicheroTXT(out,p); out.close(); } void EscribePersonaFicheroTXT(ofstream &fichero, Persona_R p) { fichero << p.PASS << SP; } void verificar_existencia_fichero(TCadena nombreFichero) { ifstream archivo(nombreFichero); if (!archivo) { cout<<"n Nombre de usuario incorrecto, pruebe otra vez n"<<endl; Sleep(2500); borrar_pantalla();main(); } else { cout<<"n Nombre de usuario correcto n"<<endl;Sleep(2500); } } void verificar_existencia_de_usuario(TCadena nombreFichero)
EDDY ESEQUIEL MORENO BENAVIDES 97 { ifstream archivo(nombreFichero); if (!archivo) { cout<<"nNombre de usuario disponible n"<<endl;Sleep(2500); } else { cout<<"n Este nombre de usuario ya existe, digite otro "<<endl; Sleep(2500); borrar_pantalla();main(); } } void verificar_contrasena(TCadena nombreFichero,Persona_R &password) { string cadena; string contrase; cout << "Escriba su contraseña: " ; cin >> password.PASS; ifstream fichero(nombreFichero,ios::in); while(!fichero.eof()) { fichero >> cadena; //cadena = strstr (fichero,"simple"); } if(cadena!=password.PASS)
EDDY ESEQUIEL MORENO BENAVIDES 98 { cout<<"n Contraseña incorrecta, pruebe otra vez n"<<endl; Sleep(2000); fichero.close(); } if(cadena==password.PASS) { cout<<"n Contraseña correcta n"<<endl; Sleep(2500); cout<<"n Bienvenido n"<<endl; Sleep(2500); } } Ejercicio de matrices- Algebra lineal #include<iostream> #include<stdio.h> #include<stdlib.h> #include<string.h> #include<math.h> using namespace std; void mult(); void suma(); void menu(int opc);
EDDY ESEQUIEL MORENO BENAVIDES 99 void resta(); void matrizDeDos(); void matrizDeTres(); void matrizDeCuatro(); void matrizDeCinco(); void det(); void inversa(); void acercade(); int main(int opc) { system("color 3F"); system("TITLE MatrixApp"); system("cls"); do { cout<<" ---> Matrices <--- "<<endl; cout<<" 1. Multiplicaci242n: ... "<<endl; cout<<" 2. Suma: ... "<<endl; cout<<" 3. Resta: ... "<<endl; cout<<" 4. Determinante: ... "<<endl; cout<<" 5. Inversa:..."<<endl; cout<<" 6. Acerca de: ..."<<endl; cout<<" 7. Salir:..."<<endl<<endl; cin>>opc;
EDDY ESEQUIEL MORENO BENAVIDES 100 system("cls"); menu(opc); } while(opc!=7); cout<<"Hasta pronto. "<<endl; return 0; } void acercade() { cout<<"Creado por: "<<endl; cout<<"- Eddy Moreno Benavides (eddymoreno10@gmail.com)."<<endl; cout<<"- Axel P240rez Molina (axelleonardoperezm@gmail.com)."<<endl; cout<<"- Agradecimiento a Pablo El241as Galante (Theblackphoenixpolitics@gmail.com)"<<endl; cout<<" por su colaboraci242n."<<endl<<endl; cout<<"Estudiantes de ISI primer axA4o, UCA Nicaragua."<<endl; cout<<"Para la clase de 240lgebra lineal. "<<endl; cout<<"Realizado para el docente: Jos202 Benigno Garc241a. "<<endl<<endl; cout<<"Entregado el: 25 de agosto de 2016."<<endl<<endl<<endl; system("pause"); system("cls"); } void suma()
EDDY ESEQUIEL MORENO BENAVIDES 101 { float matriz[5][5]; /** Matriz primaria **/ float mat[5][5]; /** Matriz Secundaria **/ int f,c;/** F = Filas, C = Columnas**/ bool salida=false; float suma[5][5];/** Matriz que guarda la suma de la matriz primaria y la matriz secundaria**/ while(salida==false) { cout<<"t OJO!!! t"<<endl; cout<<"El orden que se tome de aca, debe ser el mismo"<<endl; cout<<"que el de la segunda matriz "<<endl; system("pause"); system("cls"); cout<<"Ingrese las filas de la matriz 1 y 2"<<endl; cin>>f; cout<<"Ingrese las columnas de la matriz 1 y 2"<<endl; cin>>c; if (f!=c) { cout<<"Matriz incompatible"<<endl; salida=true; } else { cout<<"Ingrese primera matriz"<<endl; for(int i=0; i<f; i++)
EDDY ESEQUIEL MORENO BENAVIDES 102 { for(int j=0; j<c; j++) { cout<<"Elemento ["<<i<<","<<j<<"]"<<endl; cin>>matriz[i][j]; } } system("pause"); system("cls"); cout<<"Ingrese segunda matriz"<<endl; for(int z=0; z<f; z++) { for(int x=0; x<c; x++) { cout<<"Elemento ["<<z<<","<<x<<"]"<<endl; cin>>mat[z][x]; } } system("pause"); system("cls"); for (int i=0; i<f; i++) for (int j=0; j<c; j++) suma[i][j] = 0; for (int i=0; i<f; i++)
EDDY ESEQUIEL MORENO BENAVIDES 103 { for(int j=0; j<c; j++)//SUMA { suma[i][j] = (matriz[i][j]) + (mat[i][j]); } } system("pasue"); system("cls"); /** Mostrar matriz para verificación **/ cout<<"Orden de primera matriz ingresada: "<<f<<"x"<<c<<endl; for (int i=0; i<f ; i++) { for(int j=0; j<c ; j++) { cout<<matriz[i][j]<<"t"; } cout<<endl; } system("pause"); system("cls"); cout<<"Orden de segunda matriz ingresada: "<<f<<"x"<<c<<endl; for (int z=0; z<f; z++) {
EDDY ESEQUIEL MORENO BENAVIDES 104 for(int x=0; x<c ; x++) { cout<<mat[z][x]<<"t"; } cout<<endl; } system("pause"); system("cls"); cout<<"La suma de las 2 matrices es: "<<endl; cout<<endl; for (int i=0; i<f; i++) { for(int j=0; j<c ; j++) { cout<<suma[i][j]<<"t"; } cout<<endl; } } salida=true; }
EDDY ESEQUIEL MORENO BENAVIDES 105 system("pause"); system("cls"); } void resta() { float matriz[5][5]; /** Matriz primaria **/ float mat[5][5]; /** Matriz Secundaria **/ int f,c;/** F = Filas, C = Columnas**/ bool salida=false; float resta[5][5];/** Matriz que guarda la resta de la matriz primaria y la matriz secundaria**/ while(salida==false) { cout<<"t OJO!!! t"<<endl; cout<<"El orden que se tome de aca, debe ser el mismo"<<endl; cout<<"que el de la segunda matriz "<<endl; system("pause"); system("cls"); cout<<"Ingrese las filas de la matriz 1 y 2 "<<endl; cin>>f; cout<<"Ingrese las columnas de la matriz 1 y 2 "<<endl; cin>>c; if (f!=c)
EDDY ESEQUIEL MORENO BENAVIDES 106 { cout<<"Matriz incompatible"<<endl; salida=true; } else { cout<<"Ingrese primera matriz"<<endl; for(int i=0; i<f; i++) { for(int j=0; j<c; j++) { cout<<"Elemento ["<<i<<","<<j<<"]"<<endl; cin>>matriz[i][j]; } } system("pause"); system("cls"); cout<<"Ingrese segunda matriz"<<endl; for(int z=0; z<f; z++) { for(int x=0; x<c; x++) { cout<<"Elemento ["<<z<<","<<x<<"]"<<endl; cin>>mat[z][x]; } }
EDDY ESEQUIEL MORENO BENAVIDES 107 system("pause"); system("cls"); for (int i=0; i<f; i++) for (int j=0; j<c; j++) resta[i][j] = 0; for (int i=0; i<f; i++) { for(int j=0; j<c; j++)//RESTA { resta[i][j] = (matriz[i][j]) - (mat[i][j]); } } system("pasue"); system("cls"); /** Mostrar matriz para verificación **/ cout<<"Orden de la primera matriz ingresada: "<<f<<"x"<<c<<endl; for (int i=0; i<f ; i++) { for(int j=0; j<c ; j++) { cout<<matriz[i][j]<<"t"; }
EDDY ESEQUIEL MORENO BENAVIDES 108 cout<<endl; } system("pause"); system("cls"); cout<<"Orden de la segunda matriz ingresada: "<<f<<"x"<<c<<endl; for (int z=0; z<f; z++) { for(int x=0; x<c ; x++) { cout<<mat[z][x]<<"t"; } cout<<endl; } system("pause"); system("cls"); cout<<"Resta de las 2 matrices es: "<<endl; cout<<endl; for (int i=0; i<f; i++) { for(int j=0; j<c ; j++) { cout<<resta[i][j]<<"t"; }
EDDY ESEQUIEL MORENO BENAVIDES 109 cout<<endl; } } salida=true; } system("pause"); system("cls"); } void mult() { float matriz[5][5]; /** Matriz primaria **/ float mat[5][5]; /** Matriz Secundaria **/ float matrix[5][5];/** Matriz que guarda producto de matriz primaria y matriz secundaria**/ int f,c,f2,c2;/** F = Filas, C = Columnas**/ bool salida=false; while(salida==false) { cout<<"Ingrese las filas de la matriz primaria. "<<endl; cin>>f; cout<<"Ingrese las columas de la matriz pimaria. "<<endl;
EDDY ESEQUIEL MORENO BENAVIDES 110 cin>>c; cout<<"Ingrese Primer matriz"<<endl; for (int i=0; i<f; i++) { cout<<endl; for(int j=0; j<c; j++) { cout<<"Elemento ["<<i<<","<<j<<"]"<<endl; cin>>matriz[i][j]; } cout<<endl; } system("pause"); system("cls"); /*--------------------------------*/ cout<<"Ingrese las filas de la matriz secundaria. "<<endl; cin>>f2; cout<<"Ingrese las columas de la matriz secundaria. "<<endl; cin>>c2; system("cls"); cout<<"Ingresar segunda matriz"<<endl; for (int z=0; z<f2; z++) { for(int x=0; x<c2; x++) {
EDDY ESEQUIEL MORENO BENAVIDES 111 cout<<"Elemento ["<<z<<","<<x<<"]"<<endl; cin>>mat[z][x]; } cout<<endl; } system("pasue"); system("cls"); if(c!=f2) { cout<<"Matriz incompatible"<<endl; salida=true; } else { /** Mostrar matriz para verificación **/ cout<<"Orden de la primera matriz ingresada: "<<f<<"x"<<c<<endl; for (int i=0; i<f ; i++) { for(int j=0; j<c ; j++) { cout<<matriz[i][j]<<"t";
EDDY ESEQUIEL MORENO BENAVIDES 112 } cout<<endl; } system("pause"); system("cls"); cout<<"Orden de la segunda matriz ingresada: "<<f2<<"x"<<c2<<endl; for (int z=0; z<f2; z++) { for(int x=0; x<c2 ; x++) { cout<<mat[z][x]<<"t"; } cout<<endl; } system("pause"); system("cls"); /**Proceso De Multiplicación Matricial **/ for (int i=0; i<f; i++) for (int j=0; j<c; j++) matrix[i][j] = 0; ///PARA INICIALIZAR LA VARIABLE MULT EN MULTIPLES ARRAYS
EDDY ESEQUIEL MORENO BENAVIDES 113 for (int i=0; i<f; i++) ///PROCESO DE MULTIPLICACION { for (int j=0; j<c2; j++) { for (int a=0; a<c; a++) { matrix[i][j] = (matrix[i][j])+(matriz[i][a])*(mat[a][j]); } } } cout<<"El producto de las 2 matrices es:"<<endl; cout<<endl; for (int i=0; i<f; i++) { for(int j=0; j<c2 ; j++) { cout<<matrix[i][j]<<"t"; } cout<<endl; } } salida=true; } system("pause"); system("cls");
EDDY ESEQUIEL MORENO BENAVIDES 114 } void det() { int f=0,c=0;/** F = Filas, C = Columnas**/ bool salida=false; while(salida==false) { cout<<"Ingrese el orden de filas"<<endl; cin>>f; cout<<"Ingrese el orden de columnas"<<endl; cin>>c; if(f==3 && c==3) { cout<<"Matriz compatible!"<<endl; system("pause"); system("cls"); matrizDeTres(); salida=true; } else { if(f==2 &&c==2) { matrizDeDos();
EDDY ESEQUIEL MORENO BENAVIDES 115 salida=true; } else { if (f==4 && c==4) { matrizDeCuatro(); salida=true; } else { if(f==5 && c==5) { matrizDeCinco(); salida=true; } } } } } system("pause"); system("cls"); } void matrizDeCinco()
EDDY ESEQUIEL MORENO BENAVIDES 116 { float matriz[5][5]; int f=5; int c=5; float det1; bool salida=false; det1=matriz[5][5]; for(int i=0; i<f; i++) { for(int j=0; j<c; j++) { cout<<"Elemento ["<<i<<","<<j<<"]"<<endl; cin>>matriz[i][j]; } cout<<endl; } float proc[f][c]; for(int a=0; a<f; a++) { int c1=a+1; for(int f=c1; f<c-1; f++) { for(c=c1; c<f; c++) { proc[f][c]=((matriz[a][a])*(matriz[f][c]))- ((matriz[a][c])*(matriz[f][a]))/(matriz[a][a]); }
EDDY ESEQUIEL MORENO BENAVIDES 117 det1=(det1)*(proc[a+1][a+1]); } } cout<<"El determinante es: "<<det1<<endl; salida=true; system("pause"); system("cls"); } void matrizDeDos() { float matriz[5][5]; int f=2; int c=2; for(int i=0; i<f; i++) { for(int j=0; j<c; j++) { cout<<"Elemento ["<<i<<","<<j<<"]"<<endl; cin>>matriz[i][j]; } } cout<<"Matriz: "<<endl; for(int i=0; i<f; i++)
EDDY ESEQUIEL MORENO BENAVIDES 118 { for(int j=0; j<c; j++) { cout<<matriz[i][j]<<" t "; } cout<<endl; } system("pause"); system("cls"); int det=0; int a=0; int b=1; system("pause"); system("cls"); det=((matriz[a][a])*(matriz[b][b]))-((matriz[a][b])*(matriz[b][a])); cout<<"El determinante es: "<<det<<endl; } void matrizDeCuatro() { float matriz[5][5]; int f=4; int c=4; for (int i=0; i<f; i++) {
EDDY ESEQUIEL MORENO BENAVIDES 119 for(int j=0; j<c; j++) { cout<<"Elemento ["<<i<<","<<j<<"]"<<endl; cin>>matriz[i][j]; } } cout<<"Matriz: "<<endl; for(int i=0; i<f; i++) { for(int j=0; j<c; j++) { cout<<matriz[i][j]<<" "; } cout<<"t"<<endl; cout<<endl; } system("pause"); system("cls"); int det1=0; int det2=0; int det3=0; int det4=0; int det=0; int a=0; int b=1; int y=2;
EDDY ESEQUIEL MORENO BENAVIDES 120 int z=3; det1=(matriz[b][b])*((matriz[y][y])*(matriz[z][z])-(matriz[z][y])*(matriz[y][z]))- (matriz[b][y])*((matriz[y][b])*(matriz[z][z])- (matriz[z][b])*(matriz[y][z]))+(matriz[b][z])*((matriz[y][b])*(matriz[z][y])- (matriz[z][b])*(matriz[y][y])); det2=(matriz[b][a])*((matriz[y][y])*(matriz[z][z])-(matriz[z][y])*(matriz[y][z]))- (matriz[b][y])*((matriz[y][a])*(matriz[z][z])- (matriz[z][a])*(matriz[y][z]))+(matriz[b][z])*((matriz[y][a])*(matriz[z][y])- (matriz[z][a])*(matriz[y][y])); det3=(matriz[b][a])*((matriz[y][b])*(matriz[z][z])-(matriz[z][b])*(matriz[y][z]))- (matriz[b][b])*((matriz[y][a])*(matriz[z][z])- (matriz[z][a])*(matriz[y][z]))+(matriz[b][z])*((matriz[y][a])*(matriz[z][b])- (matriz[z][a])*(matriz[y][b])); det4=(matriz[b][a])*((matriz[y][b])*(matriz[z][y])- (matriz[z][b])*(matriz[y][y]))-(matriz[b][b])*((matriz[y][a])*(matriz[z][y])- (matriz[z][a])*(matriz[y][y]))+(matriz[b][y])*((matriz[y][a])*(matriz[z][b])- (matriz[z][a])*(matriz[y][b])); det=((matriz[a][a])*(det1))-((matriz[a][b])*(det2))+((matriz[a][y])*(det3))- ((matriz[a][z])*(det4)); cout<<"El determinante es: "<<det<<endl; } void matrizDeTres() { float matriz[5][5]; int f=3; int c=3; for(int i=0; i<f; i++) { for(int j=0; j<c; j++)
EDDY ESEQUIEL MORENO BENAVIDES 121 { cout<<"Elemento ["<<i<<","<<j<<"]"<<endl; cin>>matriz[i][j]; } } cout<<"Matriz: "<<endl; for(int i=0; i<f; i++) { for(int j=0; j<c; j++) { cout<<matriz[i][j]<<" "; } cout<<"t"<<endl; cout<<endl; } system("pause"); system("cls"); int det=0; int a=0; int b=1; int k=2; system("pause"); system("cls");
EDDY ESEQUIEL MORENO BENAVIDES 122 det=(matriz[a][a])*((matriz[b][b])*(matriz[k][k])-(matriz[k][b])*(matriz[b][k]))- (matriz[a][b])*((matriz[b][a])*(matriz[k][k])- (matriz[k][a])*(matriz[b][k]))+(matriz[a][k])*((matriz[b][a])*(matriz[k][b])- (matriz[k][a])*(matriz[b][b])); cout<<"El determinante es: "<<det<<endl; } void inversa() { cout<<"TamaxA4o m240ximo de la matriz (3,3)"<<endl; system("pause"); system("cls"); float matriz[5][5]; int f=0; int c=0; cout<<"Ingrese el orden de filas de la matriz"<<endl; cin>>f; cout<<"Ingrese el orden de las columnas de la matriz"<<endl; cin>>c; if (f>3 && c>3) { cout<<"Lo sentimos, matriz no permitida."<<endl; return ; }
EDDY ESEQUIEL MORENO BENAVIDES 123 system("pause"); system("cls"); cout<<"Ingrese Matriz: "<<endl; for(int i=0; i<f; i++) { for(int j=0; j<c; j++) { cout<<"Elemento ["<<i<<","<<j<<"]"<<endl; cin>>matriz[i][j]; } } cout<<"Su Matriz es: "<<endl; for(int i=0; i<f; i++) { for(int j=0; j<c; j++) { cout<<matriz[i][j]<<" "; } cout<<"t"<<endl; cout<<endl; } if(f==3 && c==3) { float det=0.0;
EDDY ESEQUIEL MORENO BENAVIDES 124 int a=0; int b=1; int k=2; system("pause"); system("cls"); det=(matriz[a][a])*((matriz[b][b])*(matriz[k][k])- (matriz[k][b])*(matriz[b][k]))-(matriz[a][b])*((matriz[b][a])*(matriz[k][k])- (matriz[k][a])*(matriz[b][k]))+(matriz[a][k])*((matriz[b][a])*(matriz[k][b])- (matriz[k][a])*(matriz[b][b])); cout<<"El determinante es: "<<det<<endl; if(det==0) { cout<<"No existe matriz inversa."<<endl; system("pause"); return ; } else { int a=0; int b=1; int c=2; float c11,c12,c13; float c21,c22,c23;
EDDY ESEQUIEL MORENO BENAVIDES 125 float c31,c32,c33; c11=((+1)*((matriz[b][b])*(matriz[c][c])-(matriz[c][b])*(matriz[b][c]))); c12=((-1)*((matriz[b][a])*(matriz[c][c])-(matriz[c][a])*(matriz[b][c]))); c13=((+1)*((matriz[b][a])*(matriz[c][b])-(matriz[c][a])*(matriz[b][b]))); c21=((-1)*((matriz[a][b])*(matriz[c][c])-(matriz[c][b])*(matriz[a][c]))); c22=((+1)*((matriz[a][a])*(matriz[c][c])-(matriz[c][a])*(matriz[a][c]))); c23=((-1)*((matriz[a][a])*(matriz[c][b])-(matriz[c][a])*(matriz[a][b]))); c31=((+1)*((matriz[a][b])*(matriz[b][c])-(matriz[b][b])*(matriz[a][c]))); c32=((-1)*((matriz[a][a])*(matriz[b][c])-(matriz[b][a])*(matriz[a][c]))); c33=((+1)*((matriz[a][a])*(matriz[b][b])-(matriz[b][a])*(matriz[a][b]))); cout<<"Matriz Inversa: "<<endl; cout<<c11/det<<"t"<<c21/det<<"t"<<c31/det<<endl; cout<<c12/det<<"t"<<c22/det<<"t"<<c32/det<<endl; cout<<c13/det<<"t"<<c23/det<<"t"<<c33/det<<endl; } } else { if(f==2 && c==2) { float det=0.0; int a=0; int b=1; system("pause"); system("cls");
EDDY ESEQUIEL MORENO BENAVIDES 126 det=((matriz[a][a])*(matriz[b][b]))-((matriz[a][b])*(matriz[b][a])); cout<<"El determinante es: "<<det<<endl; if(det==0) { cout<<"No existe matriz inversa."<<endl; system("pause"); return ; } else { int a=0; int b=1; float c11,c12,c21,c22; c11=((-1)*(-1))*(matriz[b][b]); c12=((-1)*(-1)*(-1))*(matriz[b][a]); c21=((-1)*(-1)*(-1))*(matriz[a][b]); c22=((-1)*(-1)*(-1)*(-1))*(matriz[a][a]); cout<<"Matriz Inversa: "<<endl; cout<<c11/det<<"t"<<c21/det<<endl; cout<<c12/det<<"t"<<c22/det<<endl; } }
EDDY ESEQUIEL MORENO BENAVIDES 127 } system("pause"); system("cls"); } void menu(int opc) { switch (opc) { case 1: mult(); break; case 2: suma(); break; case 3:
EDDY ESEQUIEL MORENO BENAVIDES 128 resta(); break; case 4: det(); break; case 5: inversa(); break; case 6: acercade(); case 7: break; default: cout<<"opci242n incorrecta!!!"<<endl; break; } } Manejo de empleados #include <stdio.h> #include <stdlib.h>
EDDY ESEQUIEL MORENO BENAVIDES 129 struct emp { int codigo; char nombre[30]; int edad; float sueldo; } reg; void crear(FILE *f) { f=fopen("empleado.txt", "r"); if(!f) { fopen("empleado.txt", "w"); printf("Se acaba de crear el fichero.n"); } else { printf("El fichero ya ha sido creado antes.n"); } fclose(f); return; }
EDDY ESEQUIEL MORENO BENAVIDES 130 void agregar (FILE *f) { f=fopen("empleado.txt","r"); if (f==NULL) { printf("El fichero para guardar registros no ha sido creado aun.n"); } else { f=fopen("empleado.txt", "a"); printf("Ingrese su codigo de empleado n"); scanf("%d", &reg.codigo); printf("Digite su nombre n"); scanf("%s", reg.nombre); fflush(stdin); printf("Digite su edad n"); scanf("%d", &reg.edad); printf("Digite su salario n"); scanf("%f", &reg.sueldo); fwrite(&reg, sizeof(reg),1,f); fclose(f); return; } return; }
EDDY ESEQUIEL MORENO BENAVIDES 131 void buscarEmp(FILE *f) { f = fopen("empleado.txt", "r"); if (f==NULL) { printf("El fichero con registros no existe!n"); return; } struct emp reg; int codTemp = 0; printf("Digite el codigo del empleado que desea buscar: n"); scanf("%d", &codTemp); printf("n"); rewind(f); while (!feof(f)) { fread(&reg, sizeof(reg),1,f); if (reg.codigo==codTemp) { printf("CodEmpleado: %d n", reg.codigo); printf("Empleado: %s n", reg.nombre); printf("Edad: %d n", reg.edad); printf("Sueldo: %.2f n", reg.sueldo); break;
EDDY ESEQUIEL MORENO BENAVIDES 132 } } } void menu() { printf("t****MENU****n"); printf("1. Crear ficherosn"); printf("2. Agregar registron"); printf("3. Visualizarn"); printf("4. Buscar empleadon"); printf("5. Modificar empleadon"); printf("6. Remover empleadon"); printf("7. Salirn"); return; }; void ver(FILE *f) { int n=1; f=fopen("empleado.txt", "r"); if (f==NULL) { printf("Tienes que crear el fichero primero.n"); return; }
EDDY ESEQUIEL MORENO BENAVIDES 133 fread(&reg, sizeof(reg),1,f); printf("tNumero tCodigo tNombre tEdad tSueldo"); while (!feof(f)) { printf("n t%d t%d t%s t%d t%.2f n", n, reg.codigo, reg.nombre, reg.edad, reg.sueldo); fread(&reg, sizeof(reg),1,f); n++; } fclose(f); return; } void modificar_empleado(FILE *f) { bool encontrado; int codEmp=0; FILE *archivoTemp; struct sRegistro reg; archivoTemp= fopen("temporal.txt","a+"); f= fopen("empleado","r"); if (archivoTemp==NULL && f==NULL) {
EDDY ESEQUIEL MORENO BENAVIDES 134 printf("Error al abrir los archivos!"); } else { fflush(stdin); printf("Archivos abiertos con exito! n"); system("PAUSE"); system("cls"); printf("Ingrese el codigo del empleado que desea modificar"); scanf("%d",&cod); rewind(f); fread (&reg,sizeof(sRegistro),1,f); while (!feof(f)); { if (codEmp==reg.codigo) { encontrado=true; ffludh(stdout); printf("-------------------------------------------- n"); printf("CodEmpleado: %d n",reg.codigo); printf("Empleado: %s n",reg.nombre); printf("Edad: %d n",reg.edad); printf("Sueldo: %.2f n",reg.sueldo); printf("--------------------------------------- n"); int opc=0; fflush(stdin);
EDDY ESEQUIEL MORENO BENAVIDES 135 printf("Ingresa una opcion segun el campo que desea modificar:"); printf("1. Para modificar el nombre. n"); printf("2. Para modificar la edad. n"); printf("3. Para modificar el sueldo. n"); printf("Opcion: "); scanf("%d",&opc); switch(opc) { case 1: { fflush(stdout); printf("Digite el nuevo nombre: n"); fflush(stdin); gets(reg.nombre); break; } case 2: { fflush(stdout); printf("Digite la nueva edad: n"); fflush(stdin); scanf("%d",&reg.edad); break; }
EDDY ESEQUIEL MORENO BENAVIDES 136 case 3: { fflush(stdout); printf("Digite el nuevo sueldo: n"); fflush(stdin); scanf("%d",&reg.sueldo); break; } default: {printf("Digite una opcion valida!"); break; } fwrite(&reg,sizeof(struct sRegistro),1,archivoTemp) printf("Registro modificado! n"); } else { fweite (&reg sizeof(struct sRegistro),1,archivoTemp); } fread(&reg,sizeof(sRegistro),1,f) }
EDDY ESEQUIEL MORENO BENAVIDES 137 if(encontrado==false) { printf("Registro no encontrado! n"); } } //Cerramos los archivos fclose(archivoTemp); fclose(fichero); remove ("empleado"); rename ("temporal.txt","empleado"); } } void remover_fichero(FILE *f) { f=fopen("empleado.txt","r"); if (f==NULL) { printf("No existe fichero para eliminar.n"); } else { int x; x= remove("empleados.txt"); if (x==0) {
EDDY ESEQUIEL MORENO BENAVIDES 138 printf("El archivo se elimino correctamente nn"); } else { printf("El archivo no se pudo eliminar nn"); } return; } } int main() { FILE *f; int opcion=0; do { menu(); printf("Ingrese su opcionn"); scanf("%d", &opcion); switch(opcion) { case 1:
EDDY ESEQUIEL MORENO BENAVIDES 139 { system("cls"); crear(f); break; } case 2: { system("cls"); agregar(f); break; } case 3: { system("cls"); ver(f); break; } case 4: { system("cls"); buscarEmp(f); break; } case 5: { system("cls");
EDDY ESEQUIEL MORENO BENAVIDES 140 modificar_empleado(f); break; } default: { printf("Opcion incorrecta n"); break; } } system("pause"); system("cls"); fflush(stdin); } while(opcion!=7); return 0; }
EDDY ESEQUIEL MORENO BENAVIDES 141 Fuentes:  http://www.zator.com/Cpp/E1_2.htm  https://blanchardspace.wordpress.com/2013/05/06/introduccion-a-c- que-es/  https://es.wikibooks.org/wiki/Fundamentos_de_programaci%C3%B3n/Al goritmos_y_programas  https://msdn.microsoft.com/es-es/library/mt589696.aspx  http://decsai.ugr.es/~jfv/ed1/c++/cdrom3/TIC- CD/web/tema21/palabras.htm  https://www.programarya.com/Cursos/C++/Bibliotecas-O-Librerias  http://www.monografias.com/trabajos16/entrada-y-salida/entrada-y- salida.shtml  http://ejercicioscpp.blogspot.com/2012/11/estructuras-de-control-en- c.html  https://www.programarya.com/Cursos/C++/Estructuras-De- Datos/Punteros  https://es.wikibooks.org/wiki/Programaci%C3%B3n_en_C%2B%2B/Punte ros  http://www.cplusplus.com/reference/cstdio/fwrite/

Más contenido relacionado

PPT
Curso c++
omar_cuvi
 
PDF
Cursocpp
zotek
 
PDF
/Media/tom nissim/cursocpp
Tom Zambrano
 
DOCX
Proyecto
Alejandro Gaspar
 
PDF
Fundamentos de programamacion c#
Robert Rodriguez
 
DOCX
Zanjai-como-entorno-de-programacion
juanpi1991
 
PDF
Programacion C#.NET
Saviotec
 
DOCX
Lenguaje C sharp
Raul Martinez
 
Curso c++
omar_cuvi
 
Cursocpp
zotek
 
/Media/tom nissim/cursocpp
Tom Zambrano
 
Proyecto
Alejandro Gaspar
 
Fundamentos de programamacion c#
Robert Rodriguez
 
Zanjai-como-entorno-de-programacion
juanpi1991
 
Programacion C#.NET
Saviotec
 
Lenguaje C sharp
Raul Martinez
 

La actualidad más candente (15)

DOCX
Historia de c++
edwin562
 
DOCX
Historia de c++
edwin562
 
PDF
Tipos Datos y Operadores en Visual C# (C sharp)
Pedro Antonio Villalta (Pavillalta)
 
PDF
Users c#guia total del programador
Santos Rivera Luján
 
PDF
Apuntes de introduccion a la programación
victdiazm
 
PDF
C# 5 los fundamentos del lenguaje
Diego Alejandro Sanchez Palomo
 
PDF
Unidad i programacion visual elementos basicos
fabiandelphi
 
PDF
C# DidáCtico
semuvi
 
PDF
Manual poo-unidad-visual-basic
Raul Hernandez
 
PDF
Introduccion a Visual C Sharp
Pedro Antonio Villalta (Pavillalta)
 
PPTX
Code blocks & lenguaje c++
aldaircausado11
 
PDF
Curso Programacion C#
Marlon Gomez Solis
 
PDF
INFOSAN Curso de delphi básico
FRANCIACOCO
 
PDF
Programacion ii modulo2-leccion1
karlalopezbello
 
PDF
Resolviendo problemas-con-cplusplus
Abefo
 
Historia de c++
edwin562
 
Historia de c++
edwin562
 
Tipos Datos y Operadores en Visual C# (C sharp)
Pedro Antonio Villalta (Pavillalta)
 
Users c#guia total del programador
Santos Rivera Luján
 
Apuntes de introduccion a la programación
victdiazm
 
C# 5 los fundamentos del lenguaje
Diego Alejandro Sanchez Palomo
 
Unidad i programacion visual elementos basicos
fabiandelphi
 
C# DidáCtico
semuvi
 
Manual poo-unidad-visual-basic
Raul Hernandez
 
Introduccion a Visual C Sharp
Pedro Antonio Villalta (Pavillalta)
 
Code blocks & lenguaje c++
aldaircausado11
 
Curso Programacion C#
Marlon Gomez Solis
 
INFOSAN Curso de delphi básico
FRANCIACOCO
 
Programacion ii modulo2-leccion1
karlalopezbello
 
Resolviendo problemas-con-cplusplus
Abefo
 
Publicidad

Destacado (7)

DOCX
Manual
Estudiantes ISI_UCA
 
DOCX
Manual C-C++ Pablo
Estudiantes ISI_UCA
 
DOCX
Manual C/C++ Jason Martinez
Estudiantes ISI_UCA
 
DOCX
Manual programación
Estudiantes ISI_UCA
 
DOCX
Manual de programación en C/C++
Estudiantes ISI_UCA
 
DOCX
Manual de c c++
Estudiantes ISI_UCA
 
PPT
FUERZAS QUE EJERCEN FLUIDO EN MOVIMIENTO(tuberia en vuelta)
Cristhian Ney Gutierrez Lujan
 
Manual
Estudiantes ISI_UCA
 
Manual C-C++ Pablo
Estudiantes ISI_UCA
 
Manual C/C++ Jason Martinez
Estudiantes ISI_UCA
 
Manual programación
Estudiantes ISI_UCA
 
Manual de programación en C/C++
Estudiantes ISI_UCA
 
Manual de c c++
Estudiantes ISI_UCA
 
FUERZAS QUE EJERCEN FLUIDO EN MOVIMIENTO(tuberia en vuelta)
Cristhian Ney Gutierrez Lujan
 
Publicidad

Similar a Manual C/C++ (20)

PDF
Programacion estructurada
johitafresh
 
DOCX
Manual C/C++ Néstor Flores
Estudiantes ISI_UCA
 
DOCX
Manual laboratorio de programación#1
Estudiantes ISI_UCA
 
PDF
Grupo 201
Ricardo Axel G
 
PDF
lengua c++
Ricardo Axel
 
DOCX
Consulta c++
elianaconstanza
 
PDF
Trans t3
Leydi Gutiérrez Hernandez
 
DOCX
Manual C/C++ Carlos Diaz
Estudiantes ISI_UCA
 
PDF
Clase 1 Introducción a C++ y demás cosa
removed_6f8a307e4583584cc77a0cadc648fbe9
 
DOCX
Lenguaje c 2_neo
estefania loredo cortes
 
PDF
CURSO C ++ (1).pdf
EdilbertoEstrada1
 
PDF
CURSO C ++ (1).pdf
EdilbertoEstrada1
 
PDF
mprogintc++.pdf
AngeleliecerChireoje2
 
DOCX
Manual AGFV
Estudiantes ISI_UCA
 
PDF
Mprogintc++ regular
payasito1980
 
PDF
Mprogintc++
Chuy Hack
 
PDF
Mprogintc++ prog(3)
desi2907
 
PDF
Apuntes de progra c++
leonardo alcaraz
 
PDF
Manual de programacion en lenguaje c++
Samuel Ballén
 
PDF
Programación en c++
K-rlos Pac
 
Programacion estructurada
johitafresh
 
Manual C/C++ Néstor Flores
Estudiantes ISI_UCA
 
Manual laboratorio de programación#1
Estudiantes ISI_UCA
 
Grupo 201
Ricardo Axel G
 
lengua c++
Ricardo Axel
 
Consulta c++
elianaconstanza
 
Trans t3
Leydi Gutiérrez Hernandez
 
Manual C/C++ Carlos Diaz
Estudiantes ISI_UCA
 
Clase 1 Introducción a C++ y demás cosa
removed_6f8a307e4583584cc77a0cadc648fbe9
 
Lenguaje c 2_neo
estefania loredo cortes
 
CURSO C ++ (1).pdf
EdilbertoEstrada1
 
CURSO C ++ (1).pdf
EdilbertoEstrada1
 
mprogintc++.pdf
AngeleliecerChireoje2
 
Manual AGFV
Estudiantes ISI_UCA
 
Mprogintc++ regular
payasito1980
 
Mprogintc++
Chuy Hack
 
Mprogintc++ prog(3)
desi2907
 
Apuntes de progra c++
leonardo alcaraz
 
Manual de programacion en lenguaje c++
Samuel Ballén
 
Programación en c++
K-rlos Pac
 

Más de Estudiantes ISI_UCA (17)

DOCX
Manual de usuario c
Estudiantes ISI_UCA
 
DOCX
Manual C / C++ Melvin
Estudiantes ISI_UCA
 
DOCX
Manual de Programación c/c++ Ricky Bonilla
Estudiantes ISI_UCA
 
DOCX
Manual programación
Estudiantes ISI_UCA
 
DOCX
Manual de usuario (C/C++)
Estudiantes ISI_UCA
 
DOCX
Manualito C/C++ - Leonardo Aquino
Estudiantes ISI_UCA
 
PDF
Lenguaje de programacion en c
Estudiantes ISI_UCA
 
DOCX
manualitoRodolfo
Estudiantes ISI_UCA
 
DOCX
Manual Francis Jarquin R
Estudiantes ISI_UCA
 
DOCX
Manual C/C++
Estudiantes ISI_UCA
 
DOCX
Manual c
Estudiantes ISI_UCA
 
DOCX
Manual de c/c++
Estudiantes ISI_UCA
 
DOCX
Manual de usuario - christian García
Estudiantes ISI_UCA
 
DOCX
Manual henry hernadez
Estudiantes ISI_UCA
 
DOCX
Manual laboratorio de programación i
Estudiantes ISI_UCA
 
DOCX
Manual de c
Estudiantes ISI_UCA
 
DOCX
Manual de programacion
Estudiantes ISI_UCA
 
Manual de usuario c
Estudiantes ISI_UCA
 
Manual C / C++ Melvin
Estudiantes ISI_UCA
 
Manual de Programación c/c++ Ricky Bonilla
Estudiantes ISI_UCA
 
Manual programación
Estudiantes ISI_UCA
 
Manual de usuario (C/C++)
Estudiantes ISI_UCA
 
Manualito C/C++ - Leonardo Aquino
Estudiantes ISI_UCA
 
Lenguaje de programacion en c
Estudiantes ISI_UCA
 
manualitoRodolfo
Estudiantes ISI_UCA
 
Manual Francis Jarquin R
Estudiantes ISI_UCA
 
Manual C/C++
Estudiantes ISI_UCA
 
Manual c
Estudiantes ISI_UCA
 
Manual de c/c++
Estudiantes ISI_UCA
 
Manual de usuario - christian García
Estudiantes ISI_UCA
 
Manual henry hernadez
Estudiantes ISI_UCA
 
Manual laboratorio de programación i
Estudiantes ISI_UCA
 
Manual de c
Estudiantes ISI_UCA
 
Manual de programacion
Estudiantes ISI_UCA
 

Último (20)

DOCX
Fisiopatologia bdjdbd resumen de cierta parte
blancaheredia7
 
PDF
Modelo Educativo SUB 2023versión final.pdf
YessicaMenachoyugar
 
PDF
Telos 127 Generacion Al fa Beta - fundaciontelefonica
abbottellison124
 
PDF
Lo que hacen los Mejores Profesores de la Universidad - Ken Bain Ccesa007.pdf
Demetrio Ccesa Rayme
 
PDF
El Genero y Nuestros Cerebros - Gina Ripon Ccesa007.pdf
Demetrio Ccesa Rayme
 
PDF
NOM-020-SSA-2025.pdf Para establecimientos de salud y el reconocimiento de l...
utclpensenanza
 
PDF
Didáctica de las literaturas infantiles.
AdrianaPaz45
 
PDF
Jodorowsky, Alejandro - Manual de Psicomagia.pdf
ssuser48cd15
 
PDF
La lluvia sabe por qué: una historia sobre amistad, resiliencia y esperanza e...
JhonabrahamBravocard
 
PDF
Mi Primer Millon - Poissant - Godefroy Ccesa007.pdf
Demetrio Ccesa Rayme
 
PDF
Aqui No Hay Reglas Hastings-Meyer Ccesa007.pdf
Demetrio Ccesa Rayme
 
PDF
LIBRO 2-SALUD Y AMBIENTE-4TO CEBA avanzado.pdf
jmazel2033
 
PDF
Como Potenciar las Emociones Positivas y Afrontar las Negativas Ccesa007.pdf
Demetrio Ccesa Rayme
 
PDF
ACERTIJO EL CONJURO DEL CAZAFANTASMAS MATEMÁTICO. Por JAVIER SOLIS NOYOLA
JAVIER SOLIS NOYOLA
 
PDF
Házlo con Miedo - Scott Allan Ccesa007.pdf
Demetrio Ccesa Rayme
 
PDF
CURRICULAR DE PRIMARIA santa ursula..pdf
ivelezz30
 
PDF
ciencia_tecnologia_sociedad Mitcham Carl. (1994)..pdf
Paola Masa
 
PDF
Aumente su Autoestima - Lair Ribeiro Ccesa007.pdf
Demetrio Ccesa Rayme
 
PDF
Aprendizaje Emocionante - Begoña Ibarrola SM2 Ccesa007.pdf
Demetrio Ccesa Rayme
 
PDF
Manual del Gobierno Escolar -MINEDUC.pdf
JoselinPortillo2
 
Fisiopatologia bdjdbd resumen de cierta parte
blancaheredia7
 
Modelo Educativo SUB 2023versión final.pdf
YessicaMenachoyugar
 
Telos 127 Generacion Al fa Beta - fundaciontelefonica
abbottellison124
 
Lo que hacen los Mejores Profesores de la Universidad - Ken Bain Ccesa007.pdf
Demetrio Ccesa Rayme
 
El Genero y Nuestros Cerebros - Gina Ripon Ccesa007.pdf
Demetrio Ccesa Rayme
 
NOM-020-SSA-2025.pdf Para establecimientos de salud y el reconocimiento de l...
utclpensenanza
 
Didáctica de las literaturas infantiles.
AdrianaPaz45
 
Jodorowsky, Alejandro - Manual de Psicomagia.pdf
ssuser48cd15
 
La lluvia sabe por qué: una historia sobre amistad, resiliencia y esperanza e...
JhonabrahamBravocard
 
Mi Primer Millon - Poissant - Godefroy Ccesa007.pdf
Demetrio Ccesa Rayme
 
Aqui No Hay Reglas Hastings-Meyer Ccesa007.pdf
Demetrio Ccesa Rayme
 
LIBRO 2-SALUD Y AMBIENTE-4TO CEBA avanzado.pdf
jmazel2033
 
Como Potenciar las Emociones Positivas y Afrontar las Negativas Ccesa007.pdf
Demetrio Ccesa Rayme
 
ACERTIJO EL CONJURO DEL CAZAFANTASMAS MATEMÁTICO. Por JAVIER SOLIS NOYOLA
JAVIER SOLIS NOYOLA
 
Házlo con Miedo - Scott Allan Ccesa007.pdf
Demetrio Ccesa Rayme
 
CURRICULAR DE PRIMARIA santa ursula..pdf
ivelezz30
 
ciencia_tecnologia_sociedad Mitcham Carl. (1994)..pdf
Paola Masa
 
Aumente su Autoestima - Lair Ribeiro Ccesa007.pdf
Demetrio Ccesa Rayme
 
Aprendizaje Emocionante - Begoña Ibarrola SM2 Ccesa007.pdf
Demetrio Ccesa Rayme
 
Manual del Gobierno Escolar -MINEDUC.pdf
JoselinPortillo2
 

Manual C/C++

  • 1. [Título del documento] 2016 INGENIERIA EN SISTEMAS DE INFORMACION |UNIVERSIDAD CENTROAMERICANA Universidad Centroamericana FACULTAD DE CIENCIA, TECNOLOGÍA Y AMBIENTE DEPARTAMENTO DE DESARROLLO TECNOLÓGICO Manual C/C++ Autor: Eddy Esequiel Moreno Benavides. Docente: Elsner Boanerge González Ortega.
  • 2. EDDY ESEQUIEL MORENO BENAVIDES 1 Tabla de contenido Historia de C++ ................................................................................................................. 4 Conceptos básicos ............................................................................................................ 7 ¿Qué es un algoritmo?............................................................................7 Ejecutable o programa de computador.....................................................8 Etapas o pasos para la creación de un programa .......................................8 Datos................................................................................................................................. 9 Tipos de datos .......................................................................................9 Puntos a tomar en cuenta..................................................................................................................................9 Identificadores ....................................................................................11 Reglas al nombrar identificadores.................................................................................................................11 Palabras reservadas .............................................................................12 Declaración de variables .......................................................................14 Constantes..........................................................................................16 Constante de carácter ..........................................................................17 Juego de caracteres..............................................................................19 Operadores .........................................................................................21 Operadores Aritméticos..................................................................................................................................21 Operadores lógicos y relacionales.................................................................................................................22 Operadores de asignación..............................................................................................................................22 Prioridad de Operadores.......................................................................23 Comentarios........................................................................................24 Cast....................................................................................................25 Librerías.......................................................................................................................... 26 Arreglos .......................................................................................................................... 28 Declaración .........................................................................................28 Acceso al arreglo..................................................................................29 Estructuras...................................................................................................................... 30 Acceso a estructuras ............................................................................31 Entrada y salida de datos en C ...................................................................................... 32 Formatos ............................................................................................32 Entrada de datos..................................................................................33
  • 3. EDDY ESEQUIEL MORENO BENAVIDES 2 Salida de Datos....................................................................................34 Funciones sin formato ..........................................................................35 Función...............................................................................................35 Descripción .........................................................................................35 getche() ..............................................................................................35 getchar() .............................................................................................35 getch() ................................................................................................35 putchar().............................................................................................35 gets()..................................................................................................35 puts()..................................................................................................35 Entrada y salida de datos en C++ .................................................................................. 36 Sentencias de control ..................................................................................................... 37 If........................................................................................................37 Else ....................................................................................................37 Switch-case .........................................................................................38 For .....................................................................................................39 While..................................................................................................40 Do-while .............................................................................................41 Break..................................................................................................41 Continue .............................................................................................42 Return ................................................................................................42 Ficheros........................................................................................................................... 43 Fopen .................................................................................................43 Fclose .................................................................................................44 Feof....................................................................................................45 Rewind ...............................................................................................45 Lectura ...............................................................................................45 Escritura de Archivos............................................................................46 Funciones........................................................................................................................ 47 Punteros.......................................................................................................................... 48
  • 4. EDDY ESEQUIEL MORENO BENAVIDES 3 Anexos ............................................................................................................................ 49 Proyecto final de clase (Administrador de apartamentos) ........................49 Main....................................................................................................................................................................49 Cabecera datos.h..............................................................................................................................................76 Login + Ejercicios de empleados.............................................................77 Ejercicio de matrices- Algebra lineal.......................................................98 Manejo de empleados ........................................................................128
  • 5. EDDY ESEQUIEL MORENO BENAVIDES 4 Historia de C++ C++ es un lenguaje imperativo orientado a objetos derivado del C. En realidad un superconjunto de C, que nació para añadirle cualidades y características de las que carecía. El resultado es que como su ancestro, sigue muy ligado al hardware subyacente, manteniendo una considerable potencia para programación a bajo nivel, pero se la han añadido elementos que le permiten también un estilo de programación con alto nivel de abstracción. Estrictamente hablando, C no es un subconjunto de C++; de hecho es posible escribir código C que es ilegal en C++. Pero a efectos prácticos, dado el esfuerzo de compatibilidad desplegado en su diseño, puede considerarse que C++ es una extensión del C clásico. La definición "oficial" del lenguaje nos dice que C++ es un lenguaje de propósito general basado en el C, al que se han añadido nuevos tipos de datos, clases, plantillas, mecanismo de excepciones, sistema de espacios de nombres, funciones inline, sobrecarga de operadores, referencias, operadores para manejo de memoria persistente, y algunas utilidades adicionales de librería (en realidad la librería Estándar C es un subconjunto de la librería C++). Respecto a su antecesor, se ha procurado mantener una exquisita compatibilidad hacia atrás por dos razones: poder reutilizar la enorme cantidad de código C existente, y facilitar una transición lo más fluida posible a los programadores de C clásico, de forma que pudieran pasar sus programas a C++ e ir modificándolos (haciéndolos más "++") de forma gradual. De hecho, los primeros compiladores C++ lo que hacían en realidad era traducir (pre procesar) a C y compilar después. Por lo general puede compilarse un programa C bajo C++, pero no a la inversa si el programa utiliza alguna de las características especiales de C++. Algunas situaciones requieren especial cuidado. Por ejemplo, si se declara una función dos veces con diferente tipo de argumentos, el compilador C invoca un error de "Nombre duplicado", mientras que en C++ quizás sea interpretado como una
  • 6. EDDY ESEQUIEL MORENO BENAVIDES 5 sobrecarga de la primera función (que sea o no legal depende de otras circunstancias). Se trata simplemente del sucesor de un lenguaje de programación hecho por programadores (de alto nivel) para programadores, lo que se traduce en un diseño pragmático al que se le han ido añadiendo todos los elementos que la práctica aconsejaba como necesarios, con independencia de su belleza o purismo conceptual. Estos condicionantes tienen su cara y su cruz; en ocasiones son motivo de ciertos "reproches" por parte de sus detractores, en otras, estas características son precisamente una cualidad. De hecho, en el diseño de la Librería Estándar C++ se ha usado ampliamente esta dualidad (ser mezcla de un lenguaje tradicional con elementos de POO), lo que ha permitido un modelo muy avanzado de programación extraordinariamente flexible (programación genérica). Aunque C++ introduce nuevas palabras clave y operadores para manejo de clases, algunas de sus extensiones tienen aplicación fuera del contexto de programación con objetos (fuera del ámbito de las clases), de hecho, muchos aspectos de C++ que pueden ser usados independientemente de las clases. Del C se ha dicho: "Por naturaleza, el lenguaje C es permisivo e intenta hacer algo razonable con lo que se haya escrito. Aunque normalmente esto es una virtud, también puede hacer que ciertos errores sean difíciles de descubrir”. Respecto al C++ podríamos decir otro tanto, pero hemos de reconocer que su sistema de detección de errores es mucho más robusto que el de C, por lo que algunos errores de este serán rápidamente detectados. Desde luego, C++ es un lenguaje de programación extremadamente largo y complejo; cuando nos adentramos en él parece no acabar nunca. Justo cuando aprendemos un significado descubrimos que una mano negra ha añadido otras dos o tres acepciones para la misma palabra. También descubrimos que prácticamente no hay una regla sin su correspondiente excepción. Cuando aprendemos que algo no se puede hacer, hay siempre algún truco escondido para hacerlo, y cuando nos dicen que es un lenguaje fuertemente tipeado, resulta completamente falso. A pesar de todo, ha experimentado un extraordinario éxito desde su creación. De hecho, muchos sistemas operativos, compiladores e intérpretes han sido
  • 7. EDDY ESEQUIEL MORENO BENAVIDES 6 escritos en C++ (el propio Windows y Java). Una de las razones de su éxito es ser un lenguaje de propósito general que se adapta a múltiples situaciones. Tanto sus fervientes defensores como sus acérrimos detractores han hecho correr ríos de tinta ensalzando sus cualidades o subrayando sus miserias, aunque todo el mundo parece estar de acuerdo en que es largo y complejo. Ha servido de justificación para el diseño de otros lenguajes que intentan eliminar sus inconvenientes al tiempo que mantener sus virtudes (C# y Java por ejemplo), y una de sus última incorporaciones, las plantillas, ha sido origen de un nuevo paradigma de programación (meta programación). Cualquier lenguaje de propósito general que como C++, permita tocar ambos mundos, la programación de bajo nivel y altos niveles de abstracción, resultará siempre e inevitablemente complejo. Ocurre lo mismo con los lenguajes naturales que son también extraordinariamente complejos (esto lo saben bien los gramáticos). Cualquier comunicación entre humanos presupone una ingente cantidad de conocimientos y suposiciones previas entre los interlocutores. A pesar de lo cual, la comunicación exacta y sin ambigüedades entre dos personas no resulta fácil. 1. Ejemplo de "Hola mundo" en C++
  • 8. EDDY ESEQUIEL MORENO BENAVIDES 7 Conceptos básicos ¿Qué es un algoritmo? Este se entiende a un conjunto finito de instrucciones que se deben seguir para resolver un problema. No obstante, desde el punto de vista de la programación de ordenadores, la definición del algoritmo como la especificación de una serie de pasos, es incompleta. Debe observarse que los ordenadores son equipos que tienen limitaciones físicas en cuanto a capacidad de almacenamiento y procesamiento. Por consiguiente debemos refinar un poco más nuestra definición de algoritmo para hacerla aplicable de manera efectiva en el ámbito de la informática. El algoritmo es un conjunto de pasos, instrucciones o acciones que se deben seguir para resolver un problema. Existen una gran cantidad de algoritmos, hay que escoger el más efectivo. Hay dos tipos de algoritmos que son los cualitativos y cuantitativos. Cualitativos son todos aquellos pasos o instrucciones descritos por medio de palabras que sirven para llegar a la obtención de una respuesta o solución de un problema. Cuantitativos son todos aquellos pasos o instrucciones que involucran cálculos numéricos para llegar a un resultado satisfactorio. Estos tienen que ser:  Preciso.  Bien definido.  Finito.  Adaptables.  Independiente según donde se implemente.
  • 9. EDDY ESEQUIEL MORENO BENAVIDES 8 Ejecutable o programa de computador Es un algoritmo que ha sido desarrollado en un determinado lenguaje de programación, para ser utilizado por la computadora que ha pasado por el proceso de compilación o traducción a lenguaje de máquina para este fin. En el sistema operativo de Windows se suele utilizar la extensión .EXE para indicar que ese archivo es un ejecutable. Etapas o pasos para la creación de un programa  Definición del problema  Análisis del problema  Diseño y técnicas para la formulación de un algoritmo  Codificación  Prueba y depuración  Documentación  Mantenimiento
  • 10. EDDY ESEQUIEL MORENO BENAVIDES 9 Datos En cada tipo de lenguaje de programación existen los datos, estos son la esencia en cada programa ya que logran la creación, obtención y reproducción de información. Tipos de datos Cada programa trabaja con diferentes tipos de datos los cuales son de diferentes tipos y tienen un rango determinado para el uso de estos pero siempre son extensos para que no exista una limitante. Estos pueden ser de tipo numérico, lógico o caracteres y normalmente poseen variantes que cambian sus propiedades. El tamaño y la extensión de estos tipos de valores varían según el compilador que es utilizado y a veces el IDE también influye debido a algunos sistemas de autocompletar en áreas que se recomienda su uso; por lo cual los datos que aparecen en la tabla son solo estimaciones. Puntos a tomar en cuenta  En el lenguaje C no existe el tipo bool, pero en C++ esto cambia. En C se utiliza el orden de 0 1; siendo el 1 verdadero y el 0 falso en C++.  Se utiliza el juego de caracteres ASCII para representar los caracteres básicos en este lenguaje.  Existe el tipo de dato vacío (Void) y normalmente se utiliza en subprocesos que no retornan ningún valor.  En C++ se conoce la existencia del tipo de valor Cadena (String), aunque este solo es un arreglo de caracteres que no tiene que definirse en ningún momento.
  • 11. EDDY ESEQUIEL MORENO BENAVIDES 10 Datos básicos Tipo Identificador Bytes en memoria Rango Entero Entero corto short 2 De -32768 a 32767 Entero int 4 De -2147483648 a +2147483647 Entero largo long 4 De -2147483648 a +2147483647 Carácter char 1 De -128 a 127 Enteros especiales Entero corto signed short 2 De -32768 a 32767 Entero corto sin signo unsigned short 2 De 0 a 65535 Entero signed int 4 De -2147483648 a +2147483647 Entero sin signo unsigned int 4 De 0 a 4294967295 Entero largo signed long 4 De -2147483648 a +2147483647 Entero largo sin signo unsigned long 4 De 0 a 4294967295 Carácter signed char 1 De -128 a 127 Carácter sin signo unsigned char 1 De 0 a 255 Flotantes Real float 4 Positivos: 3.4E- 38 a 3.4E38 Negativos: -3.4E- 38 a -3.4E38 Real doble double 8 Positivos: 1.7E- 308 a 1.7E308 Negativos: -1.7E- 308 a -1.7E308 Real doble largo long double 10 Positivos: 3.4E- 4932 a 1.1E4932 Negativos: -3.4E- 4932 a - 1.1E4932 Lógicos Dato lógico bool 1 0 a 1
  • 12. EDDY ESEQUIEL MORENO BENAVIDES 11 Identificadores Estos son nombres que le otorga el usuario a los espacios de memoria para su fácil manejo, siendo un código formado por letras, números y guiones bajos. Se le puede dar un identificador a variables, constantes y funciones. Reglas al nombrar identificadores  Deben iniciar con una letra perteneciente al código ASCII, puede ser mayúscula o minúscula porque estas se diferencian.  No usar palabras reservadas.  Solo se pueden utilizar números, guion bajo como complemento al identificador.  No pueden existir dos identificadores iguales.  No puede contener espacios en blancos. 2. Ejemplo claro de todo lo que se puede utilizar al declarar
  • 13. EDDY ESEQUIEL MORENO BENAVIDES 12 Palabras reservadas Estas son palabras que ya tienen una función otorgada que ha sido definida previamente, y debido a eso no pueden ser utilizados como identificadores. Estas tienen un significado especial para el compilador, son universales y presentan una instrucción propia de sus lenguajes. Existe una lista que ya incluye el lenguaje de C, otras que son exclusivas para C++ y se pueden agregar más a partir de librerías externas por lo que se debe consultar cada librería para sacar el máximo provecho de estas. Las que se muestran en la tabla siguiente son solo una muy pequeña parte de palabras reservadas que existen: Término Significado stream Flujo de datos cin Entrada estándar cout Salida estándar cerr Salida de mensajes de error streambuf Operación de I/O a bajo nivel istream Operación de I/O a alto nivel ostream Operación de I/O a alto nivel iostream Operación de I/O a alto nivel ios Clase para el manejo de la I/O a alto nivel setf() Método de la clase ios para inicializar los indic de formato flags() Método de la clase ios para inicializar los indic de formato unsetf() Método de la clase ios para desactivar los indic de formato width() Función declarada en las clases istream, ostream e iostream precision() Función declarada en las clases istream, ostream e iostream fill() Función declarada en las clases istream, ostream e iostream endl Manipulador sin argumentos definidos en iomanip.h flush Manipulador sin argumentos definidos en iomanip.h << ó >> Operadores de inserción o extracción de flujo ifstream Clase necesaria para la inserción de flujo de datos en ficheros. ofstream Clase necesaria para la extracción de flujo de datos en ficheros. fstream Clase necesaria para la I/O de flujo de datos en ficheros. endl Se imprime un ‘n’ y se vacía el buffer de salida fflush Limpia el buffer case Si se cumple un caso default Ningunas opciones de la selectiva múltiple typedef Crea un nuevo nombre de tipo para un tipo de dato ya definido
  • 14. EDDY ESEQUIEL MORENO BENAVIDES 13 for Estructura repetitiva (o de ciclo) int Tipo de dato entero } Fin del programa o de un bloque do Estructura repetitiva printf Imprime en pantalla puts Imprime una cadena { Inicio del programa o un bloque scanf Lee una variable gets Lee una cadena de caracteres clrscr Borra el contenido de la pantalla while Estructura repetitiva void Valor nulo main Programa principal sqrt Calcula raíz Cuadrada float Tipo de dato real struct Registro o estructura return Regresa valor a otra función break Terminar el caso switch Estructura selectiva múltiple if Estructura selectiva else La parte falsa de la selectiva
  • 15. EDDY ESEQUIEL MORENO BENAVIDES 14 Declaración de variables La declaración de las variables es lo primero que se debe realizar antes de hacer uso de estas, siempre tienen asignado un tipo, y no puede cambiar de tipo una vez que ya ha sido asignada; pero esto no impide que pueda cambiar su valor. En si lo que se realiza al declarar una variable es asignarle un espacio de memoria que equivale a su peso en byte dependiendo del tipo de dato asignado. La sintaxis que se sigue en la declaración de variables inicia con el <tipo de la variable> <identificador> y <valor> seguido por un punto y coma. En este lenguaje la sintaxis en ejemplo a seguir es la siguiente para los distintos tipos de variables: 3. Declaración de variables enteras En esta se le otorga el número o valor sin importar nada más. 4. Declaración de variables tipo carácter
  • 16. EDDY ESEQUIEL MORENO BENAVIDES 15 En las declaraciones de tipo carácter solo se puede ingresar un carácter, este tiene que ser ingresado entre comillas simples. 5. Declaración de variable tipo cadena En la declaración de variables tipo cadena el valor a otorgar tiene que ser encerrado entre comillas dobles para su correcto uso. 6. Declaración de variables tipo flotante En las variables tipo flotante es el mismo caso que en las variables enteras. 7. Declaración de variables lógicas En la declaración de las variables de tipo lógico el valor se les será otorgado por las palabras reservadas “true” o “false”.
  • 17. EDDY ESEQUIEL MORENO BENAVIDES 16 Constantes Las constantes son los datos que no pueden ser alterados en ninguna parte del algoritmo, su valor siempre será estático. Estos pueden ser de cualquier tipo de los existentes; y se usa por medio del “const” o “#define”. 8. Demostración de la declaración de las constantes Si se intenta realizar un cambio en el valor de una constante el IDE encontrara un error al intentar compilar, el cual dirá que hay un conflicto en el espacio de memoria al desear guardar.
  • 18. EDDY ESEQUIEL MORENO BENAVIDES 17 Constante de carácter Son constantes que están representadas por una barra y una letra las cuales tienen una función específica dependiendo de la que se use. Por ejemplo: Al usar t se llama a la constante de tabulación la cual procede a dar 4 espacios en el texto. Secuencia de escape Significado a Alerta b Espacio atrás f Salto de Pagina n Salto de línea r Retorno de carro t Tabulación Horizontal v Tabulación Vertical Barra invertida ’ Comilla simple ” Comilla doble ooo Visualiza un carácter cuyo código ASCII es 000 octal
  • 19. EDDY ESEQUIEL MORENO BENAVIDES 18 9. Demostración del uso en constantes especiales
  • 20. EDDY ESEQUIEL MORENO BENAVIDES 19 Juego de caracteres El texto de un programa de C++ se almacena en archivos de código fuente que usan una codificación de caracteres determinada. El estándar de C++ especifica un juego básico de caracteres de código fuente para los archivos de código fuente y un juego básico de caracteres de ejecución para los archivos compilados. La manera en que se codifican los caracteres depende totalmente del ordenador y compilador, siendo el más común los caracteres de 1 byte. Con ese tamaño se encuentran a disposición 256 caracteres, siendo los primeros 128 de estos pertenecientes a la norma ASCII. En la norma ASCII (0-128) se encuentran a disposición del usuario para escribir solamente los caracteres imprimibles los cuales van desde el 32 hasta el 127, y están representados en la siguiente tabla: Decimal Carácter Decimal Carácter Decimal Carácter 32 espacio 64 @ 96 ` 33 ! 65 A 97 a 34 " 66 B 98 b 35 # 67 C 99 c 36 $ 68 D 100 d 37 % 69 E 101 e 38 & 70 F 102 f 39 ' 71 G 103 g 40 ( 72 H 104 h 41 ) 73 I 105 i 42 * 74 J 106 j 43 + 75 K 107 k 44 , 76 L 108 l
  • 21. EDDY ESEQUIEL MORENO BENAVIDES 20 La mayoría de los compiladores de la actualidad permiten agregar caracteres que son ajenos al juego básico de caracteres ASCII, por lo cual se llega a utilizar la norma ASCII de caracteres extendidos o como se le llama comúnmente ASCII Extendido. Siendo esto útil en nuestro idioma, ya que en el ASCII básico no se encuentran caracteres como:  Ñ  ¡  ¿  Letras tildadas  Entre otros. 45 - 77 M 109 m 46 . 78 N 110 n 47 / 79 O 111 o 48 0 80 P 112 p 49 1 81 Q 113 q 50 2 82 R 114 r 51 3 83 S 115 s 52 4 84 T 116 t 53 5 85 U 117 u 54 6 86 V 118 v 55 7 87 W 119 w 56 8 88 X 120 x 57 9 89 Y 121 y 58 : 90 Z 122 z 59 ; 91 [ 123 { 60 < 92 124 | 61 = 93 ] 125 } 62 > 94 ^ 126 ~
  • 22. EDDY ESEQUIEL MORENO BENAVIDES 21 Operadores Son símbolos que permiten que exista una relación entre datos en una expresión, y evaluar el resultado de la operación. Esto es la esencia del procesamiento de datos ya que aquí se realizan las funciones básicas del computador. Los operadores se diferencian por la función que realizan en un ambiente, normalmente se dividen en:  Aritméticos  Lógicos y relacionales  De asignación Operadores Aritméticos Los operadores aritméticos son todos aquellos que realizan cálculos para lograr un resultado, los que se incluyen en esta categoría son:  Suma ( + )  Resta ( - )  Multiplicación ( * )  División ( / )  Residuo ( % ) Existen también los operadores de incremento y decremento, estos se manejan de 1 en 1, por lo cual al aplicarlo el cambio solamente será de un digito menor o mayor. Normalmente el uso que se les da es en bucles de instrucciones, por lo cual el aprendizaje de estos es esencial. Estos se encuentran como:  Incremento (++ ): Esto permite el incremento en 1 de una variable.  Decremento ( -- ): Esto permite el decremento en 1 de una variable.
  • 23. EDDY ESEQUIEL MORENO BENAVIDES 22 Operadores lógicos y relacionales Los operadores relacionales realizan una relación entre 2 valores que se verá determinada por el operador usado. Estas relaciones darán por resultado un valor lógico que se representa como verdadero o falso Describen una relación entre 2 valores, por lo tanto, se usan para expresar condiciones y comparar dos valores. El resultado de una expresión relaciones es un valor tipo lógico o booleano, solo puede ser verdadero o falso. El lenguaje C representa como verdadero el valor 1 y como falso el valor 0. Mientras que los lógicos la única que no realiza una relación es la “!” la cual solo establece una búsqueda o inversa de la variable usada. Operador Significado > Mayor que < Menor que = = Igual que >= Mayor o igual que <= Menor o igual que ! = Distinto a && Y || O ! No Operadores de asignación El operador de asignación su única función es otorgar un valor a una variable. Se realiza con un signo igual ( = ).
  • 24. EDDY ESEQUIEL MORENO BENAVIDES 23 Prioridad de Operadores Es el orden en el que el computador realiza los procesos aritméticos, lógicos y relacionales. Estos no son difíciles de aprender y seguro ya se tiene conocimiento de esto porque son los que se aplican en la vida diaria. 1. Las expresiones que están encerradas entre paréntesis son las primeras a evaluar. 2. Se continua con el orden jerárquico de las operaciones a. Potencia b. Multiplicación c. División d. Modulo e. Suma f. Resta 10. Jerarquía de operadores en demostración
  • 25. EDDY ESEQUIEL MORENO BENAVIDES 24 Comentarios Estos se utilizan para crear documentación dentro del programa mismo, para que cuando alguien inspeccione el código le sea de fácil comprensión en todo proceso que se desarrolle. Se debe considerar importante su uso en cada parte del código, sin importar su exceso debido a que entre más documentado este el código menos posibilidad existe de perderse dentro del mismo. Se puede comentar de 2 maneras.  Comentario por bloques /* (Para abrir comentario) */ (Para cerrar comentario.  Comentario por línea // 11. Ejemplo de comentarios por tipos
  • 26. EDDY ESEQUIEL MORENO BENAVIDES 25 Cast Esto es la transformación de un tipo de datos a otro que se almacenara en una variable dada, se realiza mediante la multiplicación del tipo de dato deseado por la variable a transformar que se terminara almacenando en una variable con el tipo de dato deseado y llega a ser una transformación forzada. 12. Se realiza un cast de un valor flotante a uno entero
  • 27. EDDY ESEQUIEL MORENO BENAVIDES 26 Librerías Se le llama librerías a cierto tipo de archivos que podemos importar o incluir en nuestro programa. Estos archivos contienen las especificaciones de diferentes funcionalidades ya construidas y utilizables que podremos agregar a nuestro programa. Al poder incluir estas librerías con definiciones de diferentes funcionalidades podremos ahorrarnos gran cantidad de cosas, imaginemos por ejemplo que cada vez que necesitemos leer por teclado, debamos entonces crear una función que lo haga, al poder contar con las librerías en C++, se podrá hacer uso de la gran variedad de funciones que incluyen estas las cuales facilitan nuestras vidas. Es esencial agregar después de las librerías un “using namespace std;”, lo cual separara las funciones del espacio de declaración de las librerías. Las librerías no son únicamente archivos externos creados por otros, también es posible crear nuestras propias librerías y utilizarlas en nuestros programas. Las librerías pueden tener varias extensiones diferentes, las más comunes son: .lib, .bpl, .a, .dll, .h y algunas más ya no tan comunes. Hay un conjunto librerías muy especiales, que se incluyen con todos los compiladores de C y de C++. Son las librerías ANSI o estándar. La declaración de estas se debe realizar desde el principio del código, antes de la declaración de cualquier función o línea de código, debemos indicarle al compilador que librerías usar, para el saber que términos estarán correctos en la escritura de nuestro código y cuáles no. La sintaxis es la siguiente: #include <nombre de la librería> 13. Una declaración de librerías de carácter normal
  • 28. EDDY ESEQUIEL MORENO BENAVIDES 27 A continuación se mencionan algunas de las librerías de uso común de C++ que aplique durante el curso y que forman parte de las librerías estándar de este lenguaje. Nombre de la librería Descripción de la librería math Contiene los prototipos de las funciones y otras definiciones para el uso y manipulación de funciones matemáticas. iostream Parte del a STL que contiene los algoritmos estándar, es quizá la más usada e importante (aunque no indispensable). stdio Contiene los prototipos de las funciones, macros, y tipos para manipular datos de entrada y salida. stdlib Contiene los prototipos de las funciones, macros, y tipos para utilidades de uso general. string Parte de la STL relativa a contenedores tipo string; una generalización de las cadenas alfanuméricas para albergar cadenas de objetos. vector Parte de la STL relativa a los contenedores tipo vector; una generalización de las matrices unidimensionales C/C++
  • 29. EDDY ESEQUIEL MORENO BENAVIDES 28 Arreglos Es un tipo de dato de un determinado orden que almacena en el nombre de una sola variable un conjunto limitado de datos o elementos del mismo tipo que dependen del índice que les fue otorgado. Asimismo, es un conjunto de localidades de memoria contiguas donde la dirección más baja corresponde al primer elemento y la dirección más alta al último. Estos al ser declarados no puede cambiar el tipo de dato que les fue otorgado. Estos empiezan a enumerarse a partir del 0 y el índice que les fue otorgado en un inicio es la cantidad de espacios total que tendrá a disposición. Declaración Los arreglos pueden contener un orden infinito de a*b*c*d…*n pero el uso común que se les da es en arreglos de orden unidimensional y bidimensional. La sintaxis para declarar un arreglo unidimensional es: <Tipo de dato> <identificador> < [tamaño del arreglo]>; La sintaxis para declarar un arreglo de a…*n dimensiones es el siguiente: <Tipo de dato> <identificador> < [orden 1] [orden 2]>; 14. Declaración común de un arreglo
  • 30. EDDY ESEQUIEL MORENO BENAVIDES 29 Acceso al arreglo Para lograr acceso a un arreglo se realiza mediante el uso del subíndice al que se desea acceder justo después del identificador y a continuación ser tratado como una variable más. 15. Acceso al arreglo e impresión del mismo
  • 31. EDDY ESEQUIEL MORENO BENAVIDES 30 Estructuras Es un grupo en el que se puede declarar una variable pasando a ser esta un miembro de la estructura. Esta se tiene que declarar con anterioridad para poder acceder a sus miembros. Para poder crear una estructura primero se debe definir el tipo estructura (struct) con el nombre que tendrá esta. Siguiendo la siguiente sintaxis: Struct nombre_estructura { Int a = 2; Int b = 3; char[12]= “ejemplo”; } <Identificador de la estructura>; 16. Declaración de una estructura y sus miembros
  • 32. EDDY ESEQUIEL MORENO BENAVIDES 31 Acceso a estructuras Para lograr acceder a los miembros de la estructura se utiliza el punto ( . ) empezando por el nombre de la estructura y luego del punto seguido del miembro a usar sin que exista espacio alguno. Sintaxis: <Identificador de la estructura>. <Nombre de la variable miembro a usar; 17. Dando valor a un entero en estructura e imprimiéndolo desde el main
  • 33. EDDY ESEQUIEL MORENO BENAVIDES 32 Entrada y salida de datos en C Formatos Antes de hablar sobre las entradas y salidas en este lenguaje de programación se tiene que hablar sobre su base y como se utilizan los formatos en estos, por lo cual es esencial el manejar el tipo de formato que se desea usar en cualquier momento. Estos formatos son usados en la lectura y escritura de C, por lo cual no debe ser tomado a la ligera. Dato básico Tipo Identificador Código de formato Carácter Carácter char %c Carácter sin signo unsigned char %u Carácter char %s Carácter imprime el carácter % % Entero Entero Decimal int %d,%i Entero Decimal sin signo unsigned int %u Entero corto decimal short int %hd Entero corto decimal sin signo unsigned short int %hu Entero corto decimal con signo signed short int %d Entero largo decimal long int %ld Entero largo decimal sin signo unsigned long int %lu Entero largo decimal con signo signed long it %l Flotante Real(punto flotante) float %f, %g,%G, %e,%E Real double %lf, %lg,%Lg %le, %Le Real long double %lf, %lg,%Lg %le, %Le
  • 34. EDDY ESEQUIEL MORENO BENAVIDES 33 Entrada de datos La función scanf () se utiliza para ingresar datos y estos pueden ser tecleados para asignarlos a variables, usarlos en cualquier momento o realizar cálculos del valor tomando. Estos proceden a ser guardados con un formato determinado por el programador el cual corresponde al tipo de dato asignado. La sintaxis que se utiliza es: int a; scanf(“ %d ”, a); Con esto sucede que el formato hará referencia al tipo de dato, tomando la cadena de control o formatos entre comillas. 18. Demostración del uso de scanf
  • 35. EDDY ESEQUIEL MORENO BENAVIDES 34 Salida de Datos La función printf () es similar a la función scanf (), pero este usa para la salida permite escribir textos y datos en la pantalla con determinado formato. Sintaxis: char a = ‘a’; printf(“ %c ”, a); Al imprimir datos en pantalla se puede realizar entre argumentos de la sentencia de control. 1. Los caracteres que se imprimirán en la pantalla 2. Secuencias de escape 3. Uno o varios códigos de formato 19. Impresión de valores con la función especial de C, con su respectivo formato
  • 36. EDDY ESEQUIEL MORENO BENAVIDES 35 Funciones sin formato Función Descripción getche() Lee un carácter del teclado, no hay que esperar hasta que se pulse la tecla enter. Visualiza el eco del carácter. getchar() Lee un carácter del teclado, espera hasta que se pulsa la tecla enter. getch() Lee un carácter del teclado, no hay que esperar que se pulse la tecla enter. putchar() Imprime un carácter en la pantalla en la posición actual del cursor gets() Lee una cadena de caracteres introducida por el teclado puts() Imprime una cadena en la pantalla, seguida de un carácter de salto de línea.
  • 37. EDDY ESEQUIEL MORENO BENAVIDES 36 Entrada y salida de datos en C++ Para la entrada y salida de datos se emplea el uso de las palabras reservada CIN y COUT, la ventaja de este a comparación de C es que este no requiere de ningún formato para sacar o leerlos. Para manejar la entrada se utilizan los signo ( >> ) y para la salida se utiliza el signo ( << ). Los datos que se utilizan pueden ser de tipo fundamental o cadenas de caracteres. Los operadores de inserción pueden realizar concatenaciones para poder mostrar en pantalla mayor cantidad de información con variaciones x. Se utiliza el “endl” en C++ para realizar un salto de línea, este es concatenado en las salidas. Para realizar una entrada estándar en un programa se utilizan de igual manera los signos de inserción ( >> ), esto permite obtener el tipo de dato al que va a ir a alojarse el dato. La sintaxis para la lectura es: cin>> <variable>; La sintaxis para la escritura es: cout<< “Texto si se desea”<< <variable>; 20. Demostración del uso de CIN y COUT
  • 38. EDDY ESEQUIEL MORENO BENAVIDES 37 Sentencias de control If Esta sentencia nos permite elegir si se ejecuta o no un bloque de instrucciones si la condición es verdadera. Si el valor de retorno de la sentencia es 0 esta no se ejecuta, pero si es diferente procede a ejecutar si es distinto de 0. Su sintaxis es: if (condición) { instrucción 1; instrucción 2; instrucción 3; } Else Es la orden de instrucciones que se ejecuta cuando existe un salto en el If, en otras palabras, si el If evaluado resulta como falso se procede a aplicar el Else. Su sintaxis es: if (condición) { Instrucción 1; instrucción 2; } else
  • 39. EDDY ESEQUIEL MORENO BENAVIDES 38 { instrucción 3; instrucción 4; } Switch-case Esto es una sentencia que permite seleccionar entre diferentes alternativas, y dependiendo de la alternativa seleccionada se ejecutara un bloque de instrucciones. Existen las opciones que ya han sido definidas (case) y la predeterminada (default) que se ejecuta si no se pudo encontrar una opciuon correspondiente. Su sintaxis es: switch (expresión) { case constante1: instrucciones; break; case constante 2: instrucciones; break; · · · default: instrucciones; }
  • 40. EDDY ESEQUIEL MORENO BENAVIDES 39 For Este pertenece a la sección de bucles; y posee una gran potencia y flexibilidad al ser bastante sencillo y definido. Se debe tener en cuenta que a diferencia de otros bucles este no llegará a ejecutarse si la condición es falsa, ya que la condición se comprueba antes de entrar en el bucle. 21. Descripción grafica del bucle For Su sintaxis es: for(inicialización; condicion; incremento/decremento) { instrucción 1; ........... instrucción N; }
  • 41. EDDY ESEQUIEL MORENO BENAVIDES 40 While Este es parecido al bucle for, así en el uso de una inicialización, una condición y un incremento. Primero se evalúa la condición y luego procede a ejecutar el bloque de instrucciones siendo el mismo aunque parezca bastante diferente. 22. Descripción grafica de un bucle while-do Su sintaxis es: while (condicion) { instrucción 1; .............. instrucción N; }
  • 42. EDDY ESEQUIEL MORENO BENAVIDES 41 Do-while Este es el único bucle que por lo menos se ejecutara una vez puesto que este bucle examina la condición una vez se ha ejecutado el bucle, esto es, al final del mismo. El esquema básico de este bucle sería algo así: 23. Descripción grafica del bucle do-while Su sintaxis es: do { instrucción 1; .............. instrucción N; } while (condicion); Break
  • 43. EDDY ESEQUIEL MORENO BENAVIDES 42 La instrucción de salto break se usa para interrumpir la ejecución normal de un bucle, es decir, la instrucción break finaliza la ejecución de un bucle y, por tanto, el control del programa se transfiere (salta) a la primera instrucción después del bucle. Continue La instrucción de salto continue siempre se usa para interrumpir (romper) la ejecución normal de un bucle. Sin embargo, el control del programa no se transfiere a la primera instrucción después del bucle, como sí hace la instrucción break, es decir, el bucle no finaliza, sino que, finaliza la iteración en curso, transfiriéndose el control del programa a la condición de incremento de contadores y después a la condición de salida del bucle, para decidir si se debe realizar una nueva iteración o no. Return La instrucción de salto return es utilizada en lenguaje C para devolver el control de ejecución desde la función que contiene el return a la rutina que la invocó y para indicar el valor de retorno de una función. Para terminar una función debe de ir el valor return, y para terminar la función Main tiene que aplicarse el return 0 lo cual hace que termine el programa. 24. Clara demostración del uso de las funciones break y return
  • 44. EDDY ESEQUIEL MORENO BENAVIDES 43 Ficheros El estándar de C contiene funciones para la edición de ficheros, estas están definidas por la librería “stdio.h” y por lo general empiezan estos con la letra f debido a la palabra “File” que es fichero en español. Se utiliza junto a un puntero tipo FILE que determinara las acciones a realizar. Los pasos para realizar uso de los ficheros es:  Crear un apuntador del tipo FILE *  Abrir el archivo utilizando la función fopen y asignándole el resultado de la llamada a nuestro apuntador.  Hacer las diversas operaciones (lectura, escritura, etc).  Cerrar el archivo utilizando la función fclose. Fopen Esta función realiza la creación y apertura de archivos en el disco duro. La sintaxis para su uso es sencilla, solo usando unos cuantos parámetros y realizando un buen análisis de lo que se desea realizar. Y esta es: FILE * fopen (“Nombre del archivo con extensión”, “Modo de apertura”); Los modos de apertura más comunes son los siguientes mencionados: Tipo Descripción general "r" read: Abre un archivo para operaciones de entrada, este debe salir. "w" write: Crea un archivo para operaciones de salida. Si un archive con el mismo nombre existe su contenido es descartado y es tratado como un archivo nuevo. "a" append: Abre un archivo para salida al final del archivo. Las operaciones de salida siempre escriben datos al final del archivo, expandiéndolo. El archivo es creado si no existe. "r+" read/update: Abre un archivo para actualización (entrada y salida). El archive debe existir. "w+" write/update: Crea un archive vacío y lo abre para actualizar (entrada y salida). Si un archivo con el mismo nombre existe su contenido es descartado y es tratado como un fichero nuevo.
  • 45. EDDY ESEQUIEL MORENO BENAVIDES 44 "a+" append/update: Abre un archivo para actualización (entrada y salida) con todas las operaciones de escritura al final del archivo. Se puede mover el cursor para que afecte a la entrada de datos, pero las operaciones de salida lo mueven al final del archivo. El archivo es creado si no existe. 25. Demostración de creación y apertura de un archivo Fclose Esta función es para poder realizar el cierre de un fichero de manera correcta, si no es aplicado puede corromperse la información usada o crear fallos en el programa. La sintaxis es sencilla, solamente usando la palabra reservada y el puntero del archivo: fclose (<puntero del archivo usado>); Un valor de retorno cero indica que el fichero ha sido correctamente cerrado, si ha habido algún error, el valor de retorno es la constante EOF.
  • 46. EDDY ESEQUIEL MORENO BENAVIDES 45 26. Demostración de cierre de un archivo Feof Esta función sirve para identificar si ya se encontró el final de un archivo dentro de un fichero. Esta siempre devolverá un valor de falso si no es encontrado el final del archivo, de lo contrario devolverá un valor diferente a este. La sintaxis es la siguiente: feof(<puntero que se está usando en el fichero>); Rewind La función que realiza es devolver el cursor hasta el inicio del archivo, siendo su sintaxis la siguiente: rewind(<puntero del archivo que se está utilizando>); 27. El uso de rewind y FEOF en el código Lectura
  • 47. EDDY ESEQUIEL MORENO BENAVIDES 46 La lectura de un archivo es importante para poder extraer información de este sin mucha preocupación al tener la información “en peligro”. Se puede trabajar con estos de diferentes formas y diferentes funciones. Pero la función que recomiendo es fgets la cual ha sido la que mayor me ha ayudado debido a su diversidad y fácil uso. Esta función está diseñada para leer cadenas de caracteres. Leerá hasta n-1 caracteres o hasta que lea un cambio de línea 'n' o un final de archivo EOF. En este último caso, el carácter de cambio de línea 'n' también es leído. La sintaxis correspondiente a fgets es la siguiente: fgets(<&apuntador>, <tamaño o largo a extraer>, <puntero del fichero>) Escritura de Archivos Para almacenar información permanentemente se procede a escribir en ficheros, los cuales utilizan varias funciones, de las cuales la que más he encontrado útil es fwrite debido a su diversidad como la función de lectura antes mencionada. Esta función fue pensada para trabajar con registros de longitud constante y forma pareja con fread. Es capaz de escribir hacia un fichero uno o varios registros de la misma longitud almacenados a partir de una dirección de memoria determinada. El valor de retorno es el número de registros escritos, no el número de bytes. La sintaxis de este es: fwrite(<&apuntador>, <tamaño a guardar>, <cantidad de caracteres a guardar>, <puntero>); 28. Aplicación del fgets y fwrite
  • 48. EDDY ESEQUIEL MORENO BENAVIDES 47 Funciones^ Estas son el conjunto de instrucciones que realizan una tarea específica, algunos llaman a estos subprocesos debido a que siempre van anexados al main (proceso principal), aunque este también es una función. Estos pueden tomar parámetros y tipo de dato de retorno o no. Estos son una herramienta valiosa ya que ayudan a crear módulos y formar el código estructurado. Siempre se debe de declarar al inicio luego del using namespace std. En este lenguaje el uso de parámetros es obligatorio, pero si no se recibe nada hay que dejar el espacio en blanco, lo que significa que si se declarara una función llamada “Ejemplo” que no recibe ningún argumento ni retorna valores se mostrara de la siguiente manera: void Ejemplo( ); Para revisar en específico su sintaxis se realizó el siguiente ejemplo de relleno: <Tipo de valor de retorno> <identificador o nombre de función> < (parámetros)>; Luego de la declaración de este se puede realizar el uso escribiendo lo mismo que en la declaración, sin el punto y coma, y continuando con apertura de llaves en donde se colocara una parte del código a utilizar. 29. Declaración de una función de tipo vacío
  • 49. EDDY ESEQUIEL MORENO BENAVIDES 48 Punteros Los punteros son aquellos indicadores de memoria volátil del sistema, en los cuales cuya posición en memoria se apuntan valga la redundancia. Siempre que queremos usar el apuntador se debe anteponer el asterisco (*) para indicar que usaremos el valor en la posición de memoria apuntada. De no usar el asterisco el comportamiento sería impredecible. Estaremos haciendo uso de la dirección de memoria más no del valor almacenado en ésta. Mientras que el ampersand es un operador de C++ y es comúnmente utilizado para los punteros. Este operador nos permite obtener la dirección de memoria de una variable cualquiera y es justo esto (la dirección en memoria) lo que utilizan los punteros para referenciar valores, permitiendo la edición global de este mismo. El asterisco es, por decirlo de alguna forma, el operador por excelencia de los punteros. Su utilidad está en apuntar a un espacio de memoria, acceder al valor y copiarlo. 30. Uso del puntero en funciones
  • 50. EDDY ESEQUIEL MORENO BENAVIDES 49 Anexos Proyecto final de clase (Administrador de apartamentos) Main #include <stdio.h> // Cabecera estándar E/S C #include <stdlib.h> // Cabecera estandar #include "datos.h" // Cabecera en la que se almacenan algunas variables #include <time.h> // Cabecera que se utiliza para extraer el tiempo de la maquina #include <iostream> // Libreria estándar E/S C++ #include <vector> // Libreria para realizar manejo de variables y arrays correctamente #include <conio.h> // Cabecera que se utiliza en el login para "pausar", cambiar el fondo de pantalla, letras de la pantalla y limpiarla. #include <windows.h> // Cabecera que permite realizar ajuste de la ventana del ejecutable #include <sstream> // Permite la manipulacion de cadena de caracteres "Strings" #define ENTER 13 //Funcion usada en el login #define BACKSPACE 8 //Funcion usada en el login using namespace std; void ver_pago(); ///Subproceso que permite ver los pagos realizados en el año por el inquilino. void SubMenuApartamento(FILE *f); //Menu que muestra la opcion de ingresar inquilino, ver inquilino, ver pago.
  • 51. EDDY ESEQUIEL MORENO BENAVIDES 50 void visualizar(FILE *f); //Muestra los datos del inquilino y muestra un menu que permite su modificacion o eliminacion. void modificar(FILE *f); //Modifica los datos del inquilino a eleccion del usuario. void ingresar(); //Permite ingresar todos los datos de un inquilino nuevo. void pago(); //Realiza el pago de los meses de un inquilino void ver_pago(FILE *f); //Permite ver los meses que se han pagado de un inquilinos void Menu(); //Despliega el menu principal con varias opciones void crearFichero(FILE* f, int &salida); //Si no se ha creado el fichero lo crea void login(int &valido); //Simple login para una persona que no permite el ingreso de alguien ajeno. void eliminar(); //Elimina el registro del inquilino registrado void fecha(); //Permite mostrar la fecha en el programa bool AjustarVentana(int Ancho, int Alto); //Ajusta el tamaño de la ventana del ejecutable bool AjustarVentana(int Ancho, int Alto) { _COORD Coordenada; Coordenada.X = Ancho; Coordenada.Y = Alto; _SMALL_RECT Rect; Rect.Top = 0; Rect.Left = 0; Rect.Right = Ancho - 1; Rect.Bottom = Alto - 1;
  • 52. EDDY ESEQUIEL MORENO BENAVIDES 51 // Obtener el handle de la consola HANDLE hConsola = GetStdHandle(STD_OUTPUT_HANDLE); // Ajustar el buffer al nuevo tamaño SetConsoleScreenBufferSize(hConsola, Coordenada); // Cambiar tamaño de consola a lo especificado en el buffer SetConsoleWindowInfo(hConsola, TRUE, &Rect); return TRUE; } void login(int &valido) { vector<string> usuarios; // vector de usernames vector<string> passwords; // vector de passwords // Se llena el vector de username con aquellos usarios que tienen permiso para logearse usuarios.push_back("Mercedes"); // Se llena el vector de passwords con las contraseñas de los usuarios passwords.push_back("1234"); string usuario, password; // Variables en donde se reciben los datos del usuario int contador = 0;
  • 53. EDDY ESEQUIEL MORENO BENAVIDES 52 bool ingresa = false; cout<<"--------------------------------------------------------------------------------------------- -------------------------"<<endl; cout<<",---. | | | ,---. | o o | | " << endl; cout<<"|---|,---.,---.,---.|--- ,---.,-.-.,---.,---.|--- ' ,---. |---|,---|,-.-..,---..,---.|--- ,-- -.,---.|--- ,---.,---." << endl; cout<<"| || |,---|| | ,---|| | ||---'| || `---. | || || | ||| ||`---.| | ,---|| | || " << endl; cout<<"` '|---'`---^` `---'`---^` ' '`---'` '`---' `---' ` '`---'` ' '`` '``---'`---'` `--- ^`---'`---'` " << endl; cout<<" | " << endl; cout<<"--------------------------------------------------------------------------------------------- -------------------------" <<endl; Sleep(4500); do { system("cls"); cout<< "ttt------------------------------"<<endl; cout << "tttLOGIN DE USUARIO" << endl; cout<< "tt Apartament's Administrator"<<endl; cout << "ttt----------------------------" << endl; // Lectura del username cout <<endl<<"tUsuario: ";
  • 54. EDDY ESEQUIEL MORENO BENAVIDES 53 getline(cin, usuario); // Lectura del password char caracter; cout << "tContrase244a: "; caracter = getch(); password = ""; while (caracter != ENTER) { if (caracter != BACKSPACE) { password.push_back(caracter); cout << "*"; } else { if (password.length() > 0) { cout << "b b"; password = password.substr(0, password.length() - 1); } } caracter = getch();
  • 55. EDDY ESEQUIEL MORENO BENAVIDES 54 } // Se procede a buscar al usuario y password for (int i = 0; i < usuarios.size(); i++) { if (usuarios[i] == usuario && passwords[i] == password) { ingresa = true; // Se sale del ciclo porque se encontró al usuario } } if (!ingresa) // Entra aquí cuando no se encuentra el usuario { cout << "nntEl usuario y/o password son incorrectos" << endl; cin.get(); contador++; } } while (ingresa == false && contador < 3); if (ingresa == false) { cout << "ntUsted no pudo ingresar al sistema." << endl; } else
  • 56. EDDY ESEQUIEL MORENO BENAVIDES 55 { cout << "nntBienvenido al sistema Apartament's Administrator " << endl; cin.get(); valido=1; //Esta variable hace que pueda continuar por el if del main() } return; } void Menu() { system("cls"); cout << "__________________________________________"<< endl; cout <<"| |"<< endl; cout <<"| Apartament's Administrator |"<< endl; cout <<"|__________________________________________|"<< endl; cout <<"| B I E N V E N I D O |"<< endl; cout <<"| 1. Ver Apartamento 1 |"<< endl; cout <<"| 2. Ver Apartamento 2 |"<< endl; cout <<"| 3. Ver Apartamento 3 |"<< endl; cout <<"| 4. Ver Apartamento 4 |"<< endl; cout <<"| 5. Ver Apartamento 5 |"<< endl; cout <<"| 6. Ver Apartamento 6 |"<< endl; cout <<"| 7. Ver Apartamento 7 |"<< endl;
  • 57. EDDY ESEQUIEL MORENO BENAVIDES 56 cout <<"| 8. Salir del Programa |"<< endl; cout <<"| |"<< endl; cout <<"| "; fecha(); //Permite mostrar la fecha del sistema cout<<" |"<< endl; cout <<"|__________________________________________|"<< endl; } void crearFichero(FILE *f, int &salida) { int creacion=0; cout<<"La base de datos no ha sido creada."<< endl; cout<<"¿Desea crearla?"<<endl; cout<<"1. Si."<<endl; cout<<"2. No."<<endl; cin>>creacion; if (creacion==1) { f = fopen("apartamentos", "w"); } else { salida=1; //Permite la salida del main() cout<<"Gracias por utilizar el programa"; }
  • 58. EDDY ESEQUIEL MORENO BENAVIDES 57 return; } void eliminar() { reg[opc-1].estado=1; //Pone el estado del inquilino seleccionado en modo: Disponible } void modificar(FILE *f) { int x; int opcion; fflush(stdin); cout<<" Archivos abiertos con exito. "<<endl<<endl<<endl; cout << "Ingresa una opcion segun el campo que desea modificar: " << endl; cout << "1: Para modificar el nombre. " << endl; cout << "2: Para modificar la cedula. " << endl; cout << "3: Para modificar la ocupacion. " << endl; cout << "4: Para modificar el telefono. " << endl; cout << "5: Para modificar el sexo. " << endl; cout << "6: Para modificar la edad. " << endl;
  • 59. EDDY ESEQUIEL MORENO BENAVIDES 58 cout << "7: Regresar al menu" << endl; do { cout << endl<< "Seleccione una opci242n: " << endl; cin >> opcion; switch(opcion) { case 1: { fflush(stdout); cout <<endl<<"Digite el nuevo nombre: " << endl; fflush(stdin); gets(reg[opc-1].nombre); break; } case 2: { fflush(stdout); cout<<endl<<"Digite la nueva c202dula: "<<endl; fflush(stdin); gets(reg[opc-1].cedula); break; } case 3: { fflush(stdout);
  • 60. EDDY ESEQUIEL MORENO BENAVIDES 59 cout <<endl<< "Digite la nueva ocupaci242n: " << endl; fflush(stdin); gets(reg[opc-1].ocupacion); break; } case 4: { fflush(stdout); cout <<endl<< "Digite el nuevo tel202fono: " << endl; fflush(stdin); gets(reg[opc-1].telefono); break; } case 5: { fflush(stdout); cout <<endl<< "Digite el nuevo sexo: " << endl; fflush(stdin); gets(reg[opc-1].sexo); break; } case 6: { fflush(stdout); cout <<endl<< "Digite la nueva edad: " << endl; fflush(stdin); cin >> reg[opc-1].edad;
  • 61. EDDY ESEQUIEL MORENO BENAVIDES 60 break; } case 7: { system("cls"); cout<<endl<<endl<<" La ficha de informaci242n del inquilino "<<opc<<" se ha modificado."<<endl<<endl; f= fopen("apartamentos","w"); //Abre el archivo para escribir en el rewind(f); //Para poner el puntero al inicio del archivo for (x=1 ; x<=7; x++) { fwrite(&reg[x-1], sizeof(struct inquilinos), 1, f); //Se realiza un loop para escribir en todas las estructuras del fichero //sin cambiar nada mas que lo seleccionado como inquilino. } break; } default: cout <<endl<< "Digite una opci242n v240lida!" << endl; break; } } while (opcion!=7); system("PAUSE"); system("cls");
  • 62. EDDY ESEQUIEL MORENO BENAVIDES 61 return; } void ingresar() { system("cls"); fflush(stdin); cout << "Ingrese el nombre del inquilino: " << endl; gets(reg[opc-1].nombre); cout << "Ingrese la c202dula del inquilino: " << endl; fflush(stdin); gets(reg[opc-1].cedula); cout << "Ingrese la edad del inquilino: " << endl; fflush(stdin); cin >> reg[opc-1].edad; cout << "Ingrese la ocupaci242n del inquilino: " << endl; fflush(stdin); gets(reg[opc-1].ocupacion); cout << "Ingrese el tel202fono del inquilino: " << endl;
  • 63. EDDY ESEQUIEL MORENO BENAVIDES 62 fflush(stdin); gets(reg[opc-1].telefono); cout << "Ingrese el sexo: M/F" << endl; fflush(stdin); gets(reg[opc-1].sexo); reg[opc-1].estado=0; //Al poner el estado en 0 se valida el cuarto como OCUPADO return; } void visualizar(FILE *f) { int opcion; system("cls"); fflush(stdout); cout << "Nombre: " << reg[opc-1].nombre << endl; fflush(stdout); cout << "C202dula: " << reg[opc-1].cedula << endl; fflush(stdout); cout << "Ocupaci242n: " << reg[opc-1].ocupacion << endl; fflush(stdout); cout << "Tel202fono: " << reg[opc-1].telefono << endl; fflush(stdout);
  • 64. EDDY ESEQUIEL MORENO BENAVIDES 63 cout << "Edad: " << reg[opc-1].edad << endl; fflush(stdout); cout << "Sexo: " << reg[opc-1].sexo << endl<<endl; do { cout << "Seleccione una Opci242n: " << endl; cout << " ____________________________ "<< endl; cout << "| |"<< endl; cout << "|1. Modificar inquilino |"<< endl; cout << "|2. Eliminar inquilino |"<< endl; cout << "|3. Regresar al men243 |"<< endl; cout << "|____________________________|"<< endl; fflush(stdin); cin >> opcion; switch(opcion) { case 1: { system("cls"); fclose(f); modificar(f); break; } case 2: {
  • 65. EDDY ESEQUIEL MORENO BENAVIDES 64 system("cls"); eliminar(); break; } case 3: { break; } default: { cout<<"Opci242n incorrecta"; break; } } } while(opcion!=3); return; } void SubMenuApartamento(FILE *f) { int opcion = 0; cout<<"Usted seleccion242 el apartamento "<< opc << endl;
  • 66. EDDY ESEQUIEL MORENO BENAVIDES 65 cout<<"Estado:"; if (reg[opc-1].estado==1) { do { cout << " Disponible"<< endl; cout <<" ________________________________"<< endl; cout <<"| |"<< endl; cout <<"| 1 - Ingresar nuevo Inquilino |"<< endl; cout <<"| 2 - Regresar al men243 principal |"<< endl; cout <<"|________________________________|"<< endl; cout <<"Seleccione Una Opci242n: "; fflush(stdin); cin >> opcion; switch (opcion) { case 1: ingresar(); break; case 2: Menu();
  • 67. EDDY ESEQUIEL MORENO BENAVIDES 66 break; default: cout<<"Estimado user digite una opci242n v240lida!"<<endl; system("pause"); break; } return; } while (opcion!=2); } else { if (reg[opc-1].estado==0) { cout << " Ocupado" << endl; cout <<" ________________________________"<< endl; cout <<"| |"<< endl; cout <<"| 1 - Ver Inquilino |"<< endl; cout <<"| 2 - Ver Pagos |"<< endl; cout <<"| 3 - Regresar al men243 |"<< endl; cout <<"|________________________________|"<< endl; cout <<"Seleccione Una Opci242n: "; fflush(stdin); cin >> opcion; switch (opcion)
  • 68. EDDY ESEQUIEL MORENO BENAVIDES 67 { case 1: visualizar(f); break; case 2: ver_pago(f); break; default: system("cls"); break; } } } return; } void pago() { int opcion; do { cout<<"¿A que mes ingresara pago?"<<endl<<endl; cout<<"Seleccione el mes:"<<endl; cout<<"1- Enero"<<endl;
  • 69. EDDY ESEQUIEL MORENO BENAVIDES 68 cout<<"2- Febrero"<<endl; cout<<"3- Marzo "<<endl; cout<<"4- Abril"<<endl; cout<<"5- Mayo"<<endl; cout<<"6- Junio"<<endl; cout<<"7- Julio"<<endl; cout<<"8- Agosto"<<endl; cout<<"9- Septiembre"<<endl; cout<<"10- Octubre"<<endl; cout<<"11- Noviembre"<<endl; cout<<"12- Diciembre"<<endl<<endl; cout<<"13- Regresar"<<endl; cin>>opcion; if (opcion>=1 && opcion<=12) { reg[opc-1].pago[opcion-1]=true; } else { if (opcion==13) { system("cls"); cout<<"Adi242s, hasta pronto"<<endl; } else
  • 70. EDDY ESEQUIEL MORENO BENAVIDES 69 { cout<<"Opci242n incorrecta";////// } } if (opcion>=1 && opcion<=12) { cout <<"Se ha registrado el pago del mes "<<opcion<< endl; system("PAUSE"); system("cls"); } } while (opcion!=13); return; } void ver_pago(FILE *f) { int x,opcion; system("cls"); for (x=1; x<=12; x++) { if (x<10) {
  • 71. EDDY ESEQUIEL MORENO BENAVIDES 70 cout<<"Mes "<<x; } else { cout<<"Mes "<<x; } if (reg[opc-1].pago[x-1]!=false) { cout<<"= Pagado"<<endl; } else { cout<<"= No pagado"<<endl; } } system("pause"); system("cls"); cout<<"Que desea realizar?"<<endl; cout <<" ________________________________"<< endl; cout <<"| |"<< endl; cout <<"| 1 - Realizar pago |"<< endl; cout <<"| 2 - Regresar al menu |"<< endl; cout <<"|________________________________|"<< endl;
  • 72. EDDY ESEQUIEL MORENO BENAVIDES 71 do { fflush(stdin); cin>>opcion; switch(opcion) { case 1: { system("cls"); pago(); break; } case 2: { system("cls"); break; } default: { cout<<"Estimado user digite una opci242n valida!"<<endl;
  • 73. EDDY ESEQUIEL MORENO BENAVIDES 72 system("pause"); break; } } return; } while (opcion!=2); } void fecha() { time_t t = time(NULL); struct tm tm= *localtime(&t); //Estructura en la que se guardan todos los datos obtenidos del sistema. int anio; int mes; int dia; anio=tm.tm_year+1900; //Se guarda el año actual, se le suma 1900 ya que este empieza a contar desde el 1900. mes=tm.tm_mon+1; //Se guarda el mes actual, se suma 1 porque empieza a contar desde 0. dia=tm.tm_mday; //Se guarda el dia actual.
  • 74. EDDY ESEQUIEL MORENO BENAVIDES 73 //number to convert int a string stringstream fechaentradastream; //Se declara una string personalizable o modificable a placer. fechaentradastream << anio<<"/"<<mes<<"/"<<dia;//add the value of Number to the characters in the stream //Se ingresa en esa stream valores enteros. string fechaentrada = fechaentradastream.str(); //Convierte de un tipo raro que no se puede mandar entre subprocesos a string cout<<fechaentrada; //imprime la fecha. } int main() { system("color 5F"); //Cambia el color de letra y fondo system("TITLE Apartament's Administrator "); //Cambia el titulo del ejecutable AjustarVentana(120,25); //Ajusta la ventana del ejecutable int x; int salida=0; int valido=0;
  • 75. EDDY ESEQUIEL MORENO BENAVIDES 74 login(valido); if (valido==1) { AjustarVentana(65,40); //Ajusta la ventana del ejecutable for (x=1; x<=7; x++) { reg[x-1].estado=1; } FILE *f; f = fopen("apartamentos", "r"); if(!f) { crearFichero(f, salida); } else { for (x=1 ; x<=7; x++) { fread(&reg[x-1],sizeof(struct inquilinos),1,f); /// } fclose(f); }
  • 76. EDDY ESEQUIEL MORENO BENAVIDES 75 while (salida!=1) { Menu(); cout<<"Digite su opci242n: "; fflush(stdin); cin >> opc; switch (opc) { case 1: case 2: case 3: case 4: case 5: case 6: case 7: system("cls"); SubMenuApartamento(f); break; case 8: cout << "Gracias por utilizar el programa " << endl; salida=1; f=fopen("apartamentos","w"); for (x=1 ; x<=7; x++) { fwrite(&reg[x-1], sizeof(struct inquilinos), 1, f); /// }
  • 77. EDDY ESEQUIEL MORENO BENAVIDES 76 fclose(f); break; default: cout<<"Estimado user digite una opci242n valida!"<<endl; system("pause"); } } } return 0; } Cabecera datos.h int opc=0; //Opcion global que es necesaria en todos los subprocesos. struct inquilinos { bool pago[12]; //Bool para los pagos del año. char nombre[50]; //Para guardar el nombre char cedula[50]; //Para guardar la cedula char ocupacion[50]; //Para guardar la ocupacion del inquilino char telefono[10]; //Para guardar el telefono del inquilino char sexo[1]; //Para guardar el sexo int edad; //Para guardar la edad int estado; //Para guardar el estado actual del apartamento }reg[7];
  • 78. EDDY ESEQUIEL MORENO BENAVIDES 77 struct tm_tm; //Estructura de TIME Login + Ejercicios de empleados #include <cstdlib> #include <iostream> #include <fstream> #include <windows.h> #include <conio.h> #include <string.h> #include <stdio.h> #define MAX 4 #define MIN 0 #include <stdlib.h> #include "Empleados_jefe.h" #include "Empleados.h" using namespace std; //SISTEMA DE REGISTRO DE USUARIOS //CONSTANTES const char FINCAD = char(0); const int MAXCAD = 20; const char SP = ' '; //variables
  • 79. EDDY ESEQUIEL MORENO BENAVIDES 78 char contrasena; int i; int contador=0; //TIPOS typedef char TCadena[MAXCAD+1]; // MAXCAD caracteres + FINCAD //Estructura struct Persona_R { TCadena PASS; }; // CABECERA DE PROCEDIMIENTOS Y FUNCIONES void pausa(); void finalizar_programa(); void borrar_pantalla(); void Ingresar_PASS(Persona_R &p); void confirmar_PASS(Persona_R &p); // Algoritmos de Manejo de Ficheros de Texto void insertarPersonaTXT(TCadena nombreFichero, Persona_R p); void EscribePersonaFicheroTXT(ofstream &fichero, Persona_R p); void verificar_existencia_fichero(TCadena nombreFichero); void verificar_existencia_de_usuario(TCadena nombreFichero); void verificar_contrasena(TCadena nombreFichero,Persona_R &password);
  • 80. EDDY ESEQUIEL MORENO BENAVIDES 79 struct Empleado emp; void menu () { printf("n ----- MENU PRINCIPAL------ n"); printf("n ------------------------ n"); printf("nt 1: Crear Fichero Empleado n"); printf("nt 2: Agregar Nuevo Empleado n"); printf("nt 3: Consultar un empleado segun INSS n"); printf("nt 4: Ver Empleados registrados n"); printf("nt 5: Eliminar Empleado segun INSS n"); printf("nt 6: Salir n"); } void menuInv () { printf("n ----- MENU PRINCIPAL------ n"); printf("n ------------------------ n"); printf("nt 1: Crear Fichero Empleado n"); printf("nt 2: Consultar un empleado segun INSS n"); printf("nt 3: Ver Empleados registrados n"); printf("nt 4: Salir n"); } void crearFichero(FILE *fichero) { fichero = fopen("empleado","r"); if (!fichero)
  • 81. EDDY ESEQUIEL MORENO BENAVIDES 80 { fichero = fopen("empleado","w"); printf("n Fichero creado con exito"); } else { printf("n El fichero ya existe"); } fclose(fichero); return; } void InsertarDatos(FILE *fichero) { fichero = fopen("empleado","a+"); fflush(stdin); printf("n Digite su nombre: "); gets(emp.nombresApellidos); fflush(stdin); printf("n"); printf("n Digite su cedula: "); gets(emp.cedula); fflush(stdin); printf("n"); printf("n Digite su numero inss: "); gets(emp.inss); fflush(stdin);
  • 82. EDDY ESEQUIEL MORENO BENAVIDES 81 printf("n"); printf("n Digite su profesion: "); gets(emp.profesion); fflush(stdin); printf("n"); printf("n Digite su puesto de trabajo: "); gets(emp.puestoTrabajo); fflush(stdin); printf("n"); printf("n Digite su salario: "); scanf("%f",&emp.salario); fflush(stdin); printf("n"); printf("n Digite su sexo, considerando que: "); printf("n 1=Masculino "); printf("n 0=Femenino "); scanf("%d",&emp.sexo); fflush(stdin); printf("n"); fwrite(&emp, sizeof(struct Empleado), 1, fichero); fclose(fichero); return; } void EliminarEmpleado (FILE *fichero, FILE *temp) { bool encontrado=false;
  • 83. EDDY ESEQUIEL MORENO BENAVIDES 82 fichero=fopen("empleado","r"); temp=fopen("temporal","a+"); char inss[20]; cout<<"Digite el numero INSS: "; cin>>inss; while(!feof(fichero)) { fread(&emp,sizeof(Empleado),1,fichero); if (strcmp(inss,emp.inss)==0) { cout<<"Nombre "<<emp.nombresApellidos<<endl; cout<<"INSS "<<emp.inss<<endl; cout<<"Registro eliminado"<<endl; encontrado=true; } else { fwrite(&emp,sizeof(Empleado),1,temp); } } if (encontrado==false) { cout<<"Clave no encontrada"<<endl; } fclose(fichero); fclose(temp); remove("empleado");
  • 84. EDDY ESEQUIEL MORENO BENAVIDES 83 rename("temporal","empleado"); system("pause"); } void ConsultarEmpleado (FILE *fichero) { char inss[20]; cout<<"Ingrese el numero inss: "; cin>>inss; fichero=fopen("empleado","r"); while(fread(&emp,sizeof(Empleado),1,fichero)) { if (strcmp(inss,emp.inss)==0) { cout<<"Nombre: "<<emp.nombresApellidos<<endl; cout<<"Cedula: "<<emp.cedula<<endl; cout<<"INSS: "<<emp.inss<<endl; cout<<"Puesto de trabajo: "<<emp.puestoTrabajo<<endl; cout<<"Profesion: "<<emp.profesion<<endl; cout<<"Salario: "<<emp.salario<<endl; cout<<"Sexo: "<<emp.sexo<<endl; } fclose(fichero); system("pause");
  • 85. EDDY ESEQUIEL MORENO BENAVIDES 84 } } void verDatos (FILE *fichero) { int numero = 1; fichero = fopen("empleado","r"); if (fichero==NULL) { printf("n Archivo empleado no existe!!!"); } fread(&emp, sizeof(struct Empleado), 1, fichero); printf("n t Nombre t Cedula t INSS t Profesion t Puesto de trabajo t Salario t Sexo n"); while(!feof(fichero)) { printf("n t %s t %s t %s t t %s t t %s t %.2f t %d n", emp.nombresApellidos, emp.cedula, emp.inss, emp.profesion, emp.puestoTrabajo, emp.salario, emp.sexo); fread(&emp, sizeof(struct Empleado), 1, fichero); numero++; } fclose(fichero); system("PAUSE"); system("cls"); return; }
  • 86. EDDY ESEQUIEL MORENO BENAVIDES 85 void modificarEmp(FILE *fichero) { bool encontrado =false; int codEmp=0; FILE *archivoTemp; struct Empleado reg; archivoTemp = fopen("temporal.txt","a+"); fichero=fopen("violento","r"); if(archivoTemp==NULL && fichero==NULL) { printf("Error al abrir los archivos!!!"); } else { fflush(stdin); printf("Archivos abiertos on exito!!! n"); system("PAUSE"); system("cls"); printf("Ingrese el codigo del empleado que desea modificar"); scanf("%d",&codEmp); rewind(fichero); fread(&reg,sizeof(Empleado),1,fichero); while (!feof(fichero))
  • 87. EDDY ESEQUIEL MORENO BENAVIDES 86 { if(codEmp==emp.inss) { encontrado=true; fflush(stdout); printf("CodEmpleado: %d n", emp.inss); printf("Empleado: %s n", emp.nombresApellidos); printf("Edad: %d n", emp.edad); printf("Sueldo: %.2f n", emp.salario); printf("----------------------------------- n"); int opc=0; fflush(stdin); printf("Ingrese una opcion segun el campo que desea modificar"); printf("1: Para modificar el nombre. n"); printf("2: Para modificar la edad. n"); printf("3: Para modificar el sueldo. n"); printf("opcion: "); scanf("%d", "opc"); switch(opc) { case 1: { fflush(stdout); printf("Digite el nuevo nombre: n");
  • 88. EDDY ESEQUIEL MORENO BENAVIDES 87 fflush(stdin); gets(emp.nombresApellidos); break; } case 2: {fflush(stdout); printf("Digite la nueva edad: n"); fflush(stdin); gets(emp.edad); break; } case 3: { fflush(stdout); printf("Digite el nuevo sueldo: n"); fflush(stdin); gets(emp.salario); break; } default: printf("Digite una opcion valida!!!!"); break; } fwrite(&emp, sizeof(struct Empleado),1, archivoTemp);
  • 89. EDDY ESEQUIEL MORENO BENAVIDES 88 printf("Registro modificado!!! n" ); } else { fwrite(&emp, sizeof(struct Empleado),1, archivoTemp); } fread(&emp, sizeof(Empleado),1,fichero); } if (encontrado == false) { printf("Registro no encontrado!!!"); } fclose(archivoTemp); fclose(fichero); } // PROGRAMA PRINCIPAL int main() {
  • 90. EDDY ESEQUIEL MORENO BENAVIDES 89 Persona_R p; Persona_R password; char opcion; int num; bool fin, encontrado; TCadena nombre_usuario_registrado; int opcion_menu; cout << "Bienvenido" << endl; cout << "----------------------------" << endl; cout << "1. Ingresar como Usuario" << endl; cout << "2. Ingresar como Visitante" << endl; cout << "3. Salir del Programa." << endl; cout << "----------------------------nn" << endl; cout << "Introduzca Opcion: "; cin >> opcion_menu; if (opcion_menu==4) { finalizar_programa(); } if((opcion_menu<MIN)||(opcion_menu>MAX)) { try {
  • 91. EDDY ESEQUIEL MORENO BENAVIDES 90 system("cls"); cout<<"nnt ============================n" <<"nnt | ESTA OPCION ES INCORRECTA |n" <<"nnt ============================n"; Sleep(1500); system("cls"); main(); } catch(...) { cout << "n UN ERROR HA OCURRIDO " << endl; } } switch(opcion_menu) { case 1: { cout << "n Digite su Nombre de Usuario: ";//INGRESAR COMO USUARIO cin >> nombre_usuario_registrado; verificar_existencia_fichero(nombre_usuario_registrado); system("cls"); //confirmar_PASS(password); verificar_contrasena(nombre_usuario_registrado,password);
  • 92. EDDY ESEQUIEL MORENO BENAVIDES 91 //Declaraciones system("cls"); int salida = 0; FILE *fichero; FILE *temp; while(!salida) { int opc = 0; menu(); printf("Digite su opcion: "); scanf("%d", &opc); switch(opc) { case 1: system("cls"); crearFichero(fichero); break; case 2: system("cls"); InsertarDatos(fichero); break; case 3: system("cls"); ConsultarEmpleado(fichero);
  • 93. EDDY ESEQUIEL MORENO BENAVIDES 92 break; case 4: system("cls"); verDatos(fichero); break; case 5: system("cls"); EliminarEmpleado(fichero, temp); break; case 6: system("cls"); salida = 1; finalizar_programa(); break; default: printf("Estimado usuario digite una opcion valida"); } } Sleep(1000);borrar_pantalla();main(); break; } case 2: { cout << "n Hola, usted ha accedido como visitante n"; // Ingresar como visitante int salida = 0; FILE *fichero;
  • 94. EDDY ESEQUIEL MORENO BENAVIDES 93 FILE *temp; while(!salida) { int opc = 0; menuInv(); printf("Digite su opcion: "); scanf("%d", &opc); switch(opc) { case 1: system("cls"); crearFichero(fichero); break; case 2: system("cls"); ConsultarEmpleado(fichero); break; case 3: system("cls"); verDatos(fichero); break; case 4: system("cls"); salida = 1; finalizar_programa();
  • 95. EDDY ESEQUIEL MORENO BENAVIDES 94 break; default: printf("Estimado usuario digite una opcion valida"); } } Sleep(1500); borrar_pantalla();main(); break; } } return 0; } // IMPLEMENTACIÓN DE PROCEDIMIENTOS Y FUNCIONES void finalizar_programa() { borrar_pantalla(); printf("El Programa cerrara en segundos"); Sleep(1500); exit(0); } void pausa() { system("PAUSE"); }
  • 96. EDDY ESEQUIEL MORENO BENAVIDES 95 void borrar_pantalla() { system("CLS"); } void Ingresar_PASS(Persona_R &p) { cout << "Escriba su nueva contraseña: " ; cin >> p.PASS; cout<<"n Se ha registrado de manera correcta"<<endl; Sleep(2500); } void confirmar_PASS(Persona_R &password) { cout << "Escriba su contraseña: " ; cin >> password.PASS; } // Algoritmos de Manejo de Ficheros de Texto void insertarPersonaTXT(TCadena nombreFichero, Persona_R p) { ofstream out; out.open(nombreFichero,ios::app); // Abro el fichero para añadir if (out.bad()) { // El fichero no existe ... lo creo
  • 97. EDDY ESEQUIEL MORENO BENAVIDES 96 out.open(nombreFichero); } EscribePersonaFicheroTXT(out,p); out.close(); } void EscribePersonaFicheroTXT(ofstream &fichero, Persona_R p) { fichero << p.PASS << SP; } void verificar_existencia_fichero(TCadena nombreFichero) { ifstream archivo(nombreFichero); if (!archivo) { cout<<"n Nombre de usuario incorrecto, pruebe otra vez n"<<endl; Sleep(2500); borrar_pantalla();main(); } else { cout<<"n Nombre de usuario correcto n"<<endl;Sleep(2500); } } void verificar_existencia_de_usuario(TCadena nombreFichero)
  • 98. EDDY ESEQUIEL MORENO BENAVIDES 97 { ifstream archivo(nombreFichero); if (!archivo) { cout<<"nNombre de usuario disponible n"<<endl;Sleep(2500); } else { cout<<"n Este nombre de usuario ya existe, digite otro "<<endl; Sleep(2500); borrar_pantalla();main(); } } void verificar_contrasena(TCadena nombreFichero,Persona_R &password) { string cadena; string contrase; cout << "Escriba su contraseña: " ; cin >> password.PASS; ifstream fichero(nombreFichero,ios::in); while(!fichero.eof()) { fichero >> cadena; //cadena = strstr (fichero,"simple"); } if(cadena!=password.PASS)
  • 99. EDDY ESEQUIEL MORENO BENAVIDES 98 { cout<<"n Contraseña incorrecta, pruebe otra vez n"<<endl; Sleep(2000); fichero.close(); } if(cadena==password.PASS) { cout<<"n Contraseña correcta n"<<endl; Sleep(2500); cout<<"n Bienvenido n"<<endl; Sleep(2500); } } Ejercicio de matrices- Algebra lineal #include<iostream> #include<stdio.h> #include<stdlib.h> #include<string.h> #include<math.h> using namespace std; void mult(); void suma(); void menu(int opc);
  • 100. EDDY ESEQUIEL MORENO BENAVIDES 99 void resta(); void matrizDeDos(); void matrizDeTres(); void matrizDeCuatro(); void matrizDeCinco(); void det(); void inversa(); void acercade(); int main(int opc) { system("color 3F"); system("TITLE MatrixApp"); system("cls"); do { cout<<" ---> Matrices <--- "<<endl; cout<<" 1. Multiplicaci242n: ... "<<endl; cout<<" 2. Suma: ... "<<endl; cout<<" 3. Resta: ... "<<endl; cout<<" 4. Determinante: ... "<<endl; cout<<" 5. Inversa:..."<<endl; cout<<" 6. Acerca de: ..."<<endl; cout<<" 7. Salir:..."<<endl<<endl; cin>>opc;
  • 101. EDDY ESEQUIEL MORENO BENAVIDES 100 system("cls"); menu(opc); } while(opc!=7); cout<<"Hasta pronto. "<<endl; return 0; } void acercade() { cout<<"Creado por: "<<endl; cout<<"- Eddy Moreno Benavides (eddymoreno10@gmail.com)."<<endl; cout<<"- Axel P240rez Molina (axelleonardoperezm@gmail.com)."<<endl; cout<<"- Agradecimiento a Pablo El241as Galante (Theblackphoenixpolitics@gmail.com)"<<endl; cout<<" por su colaboraci242n."<<endl<<endl; cout<<"Estudiantes de ISI primer axA4o, UCA Nicaragua."<<endl; cout<<"Para la clase de 240lgebra lineal. "<<endl; cout<<"Realizado para el docente: Jos202 Benigno Garc241a. "<<endl<<endl; cout<<"Entregado el: 25 de agosto de 2016."<<endl<<endl<<endl; system("pause"); system("cls"); } void suma()
  • 102. EDDY ESEQUIEL MORENO BENAVIDES 101 { float matriz[5][5]; /** Matriz primaria **/ float mat[5][5]; /** Matriz Secundaria **/ int f,c;/** F = Filas, C = Columnas**/ bool salida=false; float suma[5][5];/** Matriz que guarda la suma de la matriz primaria y la matriz secundaria**/ while(salida==false) { cout<<"t OJO!!! t"<<endl; cout<<"El orden que se tome de aca, debe ser el mismo"<<endl; cout<<"que el de la segunda matriz "<<endl; system("pause"); system("cls"); cout<<"Ingrese las filas de la matriz 1 y 2"<<endl; cin>>f; cout<<"Ingrese las columnas de la matriz 1 y 2"<<endl; cin>>c; if (f!=c) { cout<<"Matriz incompatible"<<endl; salida=true; } else { cout<<"Ingrese primera matriz"<<endl; for(int i=0; i<f; i++)
  • 103. EDDY ESEQUIEL MORENO BENAVIDES 102 { for(int j=0; j<c; j++) { cout<<"Elemento ["<<i<<","<<j<<"]"<<endl; cin>>matriz[i][j]; } } system("pause"); system("cls"); cout<<"Ingrese segunda matriz"<<endl; for(int z=0; z<f; z++) { for(int x=0; x<c; x++) { cout<<"Elemento ["<<z<<","<<x<<"]"<<endl; cin>>mat[z][x]; } } system("pause"); system("cls"); for (int i=0; i<f; i++) for (int j=0; j<c; j++) suma[i][j] = 0; for (int i=0; i<f; i++)
  • 104. EDDY ESEQUIEL MORENO BENAVIDES 103 { for(int j=0; j<c; j++)//SUMA { suma[i][j] = (matriz[i][j]) + (mat[i][j]); } } system("pasue"); system("cls"); /** Mostrar matriz para verificación **/ cout<<"Orden de primera matriz ingresada: "<<f<<"x"<<c<<endl; for (int i=0; i<f ; i++) { for(int j=0; j<c ; j++) { cout<<matriz[i][j]<<"t"; } cout<<endl; } system("pause"); system("cls"); cout<<"Orden de segunda matriz ingresada: "<<f<<"x"<<c<<endl; for (int z=0; z<f; z++) {
  • 105. EDDY ESEQUIEL MORENO BENAVIDES 104 for(int x=0; x<c ; x++) { cout<<mat[z][x]<<"t"; } cout<<endl; } system("pause"); system("cls"); cout<<"La suma de las 2 matrices es: "<<endl; cout<<endl; for (int i=0; i<f; i++) { for(int j=0; j<c ; j++) { cout<<suma[i][j]<<"t"; } cout<<endl; } } salida=true; }
  • 106. EDDY ESEQUIEL MORENO BENAVIDES 105 system("pause"); system("cls"); } void resta() { float matriz[5][5]; /** Matriz primaria **/ float mat[5][5]; /** Matriz Secundaria **/ int f,c;/** F = Filas, C = Columnas**/ bool salida=false; float resta[5][5];/** Matriz que guarda la resta de la matriz primaria y la matriz secundaria**/ while(salida==false) { cout<<"t OJO!!! t"<<endl; cout<<"El orden que se tome de aca, debe ser el mismo"<<endl; cout<<"que el de la segunda matriz "<<endl; system("pause"); system("cls"); cout<<"Ingrese las filas de la matriz 1 y 2 "<<endl; cin>>f; cout<<"Ingrese las columnas de la matriz 1 y 2 "<<endl; cin>>c; if (f!=c)
  • 107. EDDY ESEQUIEL MORENO BENAVIDES 106 { cout<<"Matriz incompatible"<<endl; salida=true; } else { cout<<"Ingrese primera matriz"<<endl; for(int i=0; i<f; i++) { for(int j=0; j<c; j++) { cout<<"Elemento ["<<i<<","<<j<<"]"<<endl; cin>>matriz[i][j]; } } system("pause"); system("cls"); cout<<"Ingrese segunda matriz"<<endl; for(int z=0; z<f; z++) { for(int x=0; x<c; x++) { cout<<"Elemento ["<<z<<","<<x<<"]"<<endl; cin>>mat[z][x]; } }
  • 108. EDDY ESEQUIEL MORENO BENAVIDES 107 system("pause"); system("cls"); for (int i=0; i<f; i++) for (int j=0; j<c; j++) resta[i][j] = 0; for (int i=0; i<f; i++) { for(int j=0; j<c; j++)//RESTA { resta[i][j] = (matriz[i][j]) - (mat[i][j]); } } system("pasue"); system("cls"); /** Mostrar matriz para verificación **/ cout<<"Orden de la primera matriz ingresada: "<<f<<"x"<<c<<endl; for (int i=0; i<f ; i++) { for(int j=0; j<c ; j++) { cout<<matriz[i][j]<<"t"; }
  • 109. EDDY ESEQUIEL MORENO BENAVIDES 108 cout<<endl; } system("pause"); system("cls"); cout<<"Orden de la segunda matriz ingresada: "<<f<<"x"<<c<<endl; for (int z=0; z<f; z++) { for(int x=0; x<c ; x++) { cout<<mat[z][x]<<"t"; } cout<<endl; } system("pause"); system("cls"); cout<<"Resta de las 2 matrices es: "<<endl; cout<<endl; for (int i=0; i<f; i++) { for(int j=0; j<c ; j++) { cout<<resta[i][j]<<"t"; }
  • 110. EDDY ESEQUIEL MORENO BENAVIDES 109 cout<<endl; } } salida=true; } system("pause"); system("cls"); } void mult() { float matriz[5][5]; /** Matriz primaria **/ float mat[5][5]; /** Matriz Secundaria **/ float matrix[5][5];/** Matriz que guarda producto de matriz primaria y matriz secundaria**/ int f,c,f2,c2;/** F = Filas, C = Columnas**/ bool salida=false; while(salida==false) { cout<<"Ingrese las filas de la matriz primaria. "<<endl; cin>>f; cout<<"Ingrese las columas de la matriz pimaria. "<<endl;
  • 111. EDDY ESEQUIEL MORENO BENAVIDES 110 cin>>c; cout<<"Ingrese Primer matriz"<<endl; for (int i=0; i<f; i++) { cout<<endl; for(int j=0; j<c; j++) { cout<<"Elemento ["<<i<<","<<j<<"]"<<endl; cin>>matriz[i][j]; } cout<<endl; } system("pause"); system("cls"); /*--------------------------------*/ cout<<"Ingrese las filas de la matriz secundaria. "<<endl; cin>>f2; cout<<"Ingrese las columas de la matriz secundaria. "<<endl; cin>>c2; system("cls"); cout<<"Ingresar segunda matriz"<<endl; for (int z=0; z<f2; z++) { for(int x=0; x<c2; x++) {
  • 112. EDDY ESEQUIEL MORENO BENAVIDES 111 cout<<"Elemento ["<<z<<","<<x<<"]"<<endl; cin>>mat[z][x]; } cout<<endl; } system("pasue"); system("cls"); if(c!=f2) { cout<<"Matriz incompatible"<<endl; salida=true; } else { /** Mostrar matriz para verificación **/ cout<<"Orden de la primera matriz ingresada: "<<f<<"x"<<c<<endl; for (int i=0; i<f ; i++) { for(int j=0; j<c ; j++) { cout<<matriz[i][j]<<"t";
  • 113. EDDY ESEQUIEL MORENO BENAVIDES 112 } cout<<endl; } system("pause"); system("cls"); cout<<"Orden de la segunda matriz ingresada: "<<f2<<"x"<<c2<<endl; for (int z=0; z<f2; z++) { for(int x=0; x<c2 ; x++) { cout<<mat[z][x]<<"t"; } cout<<endl; } system("pause"); system("cls"); /**Proceso De Multiplicación Matricial **/ for (int i=0; i<f; i++) for (int j=0; j<c; j++) matrix[i][j] = 0; ///PARA INICIALIZAR LA VARIABLE MULT EN MULTIPLES ARRAYS
  • 114. EDDY ESEQUIEL MORENO BENAVIDES 113 for (int i=0; i<f; i++) ///PROCESO DE MULTIPLICACION { for (int j=0; j<c2; j++) { for (int a=0; a<c; a++) { matrix[i][j] = (matrix[i][j])+(matriz[i][a])*(mat[a][j]); } } } cout<<"El producto de las 2 matrices es:"<<endl; cout<<endl; for (int i=0; i<f; i++) { for(int j=0; j<c2 ; j++) { cout<<matrix[i][j]<<"t"; } cout<<endl; } } salida=true; } system("pause"); system("cls");
  • 115. EDDY ESEQUIEL MORENO BENAVIDES 114 } void det() { int f=0,c=0;/** F = Filas, C = Columnas**/ bool salida=false; while(salida==false) { cout<<"Ingrese el orden de filas"<<endl; cin>>f; cout<<"Ingrese el orden de columnas"<<endl; cin>>c; if(f==3 && c==3) { cout<<"Matriz compatible!"<<endl; system("pause"); system("cls"); matrizDeTres(); salida=true; } else { if(f==2 &&c==2) { matrizDeDos();
  • 116. EDDY ESEQUIEL MORENO BENAVIDES 115 salida=true; } else { if (f==4 && c==4) { matrizDeCuatro(); salida=true; } else { if(f==5 && c==5) { matrizDeCinco(); salida=true; } } } } } system("pause"); system("cls"); } void matrizDeCinco()
  • 117. EDDY ESEQUIEL MORENO BENAVIDES 116 { float matriz[5][5]; int f=5; int c=5; float det1; bool salida=false; det1=matriz[5][5]; for(int i=0; i<f; i++) { for(int j=0; j<c; j++) { cout<<"Elemento ["<<i<<","<<j<<"]"<<endl; cin>>matriz[i][j]; } cout<<endl; } float proc[f][c]; for(int a=0; a<f; a++) { int c1=a+1; for(int f=c1; f<c-1; f++) { for(c=c1; c<f; c++) { proc[f][c]=((matriz[a][a])*(matriz[f][c]))- ((matriz[a][c])*(matriz[f][a]))/(matriz[a][a]); }
  • 118. EDDY ESEQUIEL MORENO BENAVIDES 117 det1=(det1)*(proc[a+1][a+1]); } } cout<<"El determinante es: "<<det1<<endl; salida=true; system("pause"); system("cls"); } void matrizDeDos() { float matriz[5][5]; int f=2; int c=2; for(int i=0; i<f; i++) { for(int j=0; j<c; j++) { cout<<"Elemento ["<<i<<","<<j<<"]"<<endl; cin>>matriz[i][j]; } } cout<<"Matriz: "<<endl; for(int i=0; i<f; i++)
  • 119. EDDY ESEQUIEL MORENO BENAVIDES 118 { for(int j=0; j<c; j++) { cout<<matriz[i][j]<<" t "; } cout<<endl; } system("pause"); system("cls"); int det=0; int a=0; int b=1; system("pause"); system("cls"); det=((matriz[a][a])*(matriz[b][b]))-((matriz[a][b])*(matriz[b][a])); cout<<"El determinante es: "<<det<<endl; } void matrizDeCuatro() { float matriz[5][5]; int f=4; int c=4; for (int i=0; i<f; i++) {
  • 120. EDDY ESEQUIEL MORENO BENAVIDES 119 for(int j=0; j<c; j++) { cout<<"Elemento ["<<i<<","<<j<<"]"<<endl; cin>>matriz[i][j]; } } cout<<"Matriz: "<<endl; for(int i=0; i<f; i++) { for(int j=0; j<c; j++) { cout<<matriz[i][j]<<" "; } cout<<"t"<<endl; cout<<endl; } system("pause"); system("cls"); int det1=0; int det2=0; int det3=0; int det4=0; int det=0; int a=0; int b=1; int y=2;
  • 121. EDDY ESEQUIEL MORENO BENAVIDES 120 int z=3; det1=(matriz[b][b])*((matriz[y][y])*(matriz[z][z])-(matriz[z][y])*(matriz[y][z]))- (matriz[b][y])*((matriz[y][b])*(matriz[z][z])- (matriz[z][b])*(matriz[y][z]))+(matriz[b][z])*((matriz[y][b])*(matriz[z][y])- (matriz[z][b])*(matriz[y][y])); det2=(matriz[b][a])*((matriz[y][y])*(matriz[z][z])-(matriz[z][y])*(matriz[y][z]))- (matriz[b][y])*((matriz[y][a])*(matriz[z][z])- (matriz[z][a])*(matriz[y][z]))+(matriz[b][z])*((matriz[y][a])*(matriz[z][y])- (matriz[z][a])*(matriz[y][y])); det3=(matriz[b][a])*((matriz[y][b])*(matriz[z][z])-(matriz[z][b])*(matriz[y][z]))- (matriz[b][b])*((matriz[y][a])*(matriz[z][z])- (matriz[z][a])*(matriz[y][z]))+(matriz[b][z])*((matriz[y][a])*(matriz[z][b])- (matriz[z][a])*(matriz[y][b])); det4=(matriz[b][a])*((matriz[y][b])*(matriz[z][y])- (matriz[z][b])*(matriz[y][y]))-(matriz[b][b])*((matriz[y][a])*(matriz[z][y])- (matriz[z][a])*(matriz[y][y]))+(matriz[b][y])*((matriz[y][a])*(matriz[z][b])- (matriz[z][a])*(matriz[y][b])); det=((matriz[a][a])*(det1))-((matriz[a][b])*(det2))+((matriz[a][y])*(det3))- ((matriz[a][z])*(det4)); cout<<"El determinante es: "<<det<<endl; } void matrizDeTres() { float matriz[5][5]; int f=3; int c=3; for(int i=0; i<f; i++) { for(int j=0; j<c; j++)
  • 122. EDDY ESEQUIEL MORENO BENAVIDES 121 { cout<<"Elemento ["<<i<<","<<j<<"]"<<endl; cin>>matriz[i][j]; } } cout<<"Matriz: "<<endl; for(int i=0; i<f; i++) { for(int j=0; j<c; j++) { cout<<matriz[i][j]<<" "; } cout<<"t"<<endl; cout<<endl; } system("pause"); system("cls"); int det=0; int a=0; int b=1; int k=2; system("pause"); system("cls");
  • 123. EDDY ESEQUIEL MORENO BENAVIDES 122 det=(matriz[a][a])*((matriz[b][b])*(matriz[k][k])-(matriz[k][b])*(matriz[b][k]))- (matriz[a][b])*((matriz[b][a])*(matriz[k][k])- (matriz[k][a])*(matriz[b][k]))+(matriz[a][k])*((matriz[b][a])*(matriz[k][b])- (matriz[k][a])*(matriz[b][b])); cout<<"El determinante es: "<<det<<endl; } void inversa() { cout<<"TamaxA4o m240ximo de la matriz (3,3)"<<endl; system("pause"); system("cls"); float matriz[5][5]; int f=0; int c=0; cout<<"Ingrese el orden de filas de la matriz"<<endl; cin>>f; cout<<"Ingrese el orden de las columnas de la matriz"<<endl; cin>>c; if (f>3 && c>3) { cout<<"Lo sentimos, matriz no permitida."<<endl; return ; }
  • 124. EDDY ESEQUIEL MORENO BENAVIDES 123 system("pause"); system("cls"); cout<<"Ingrese Matriz: "<<endl; for(int i=0; i<f; i++) { for(int j=0; j<c; j++) { cout<<"Elemento ["<<i<<","<<j<<"]"<<endl; cin>>matriz[i][j]; } } cout<<"Su Matriz es: "<<endl; for(int i=0; i<f; i++) { for(int j=0; j<c; j++) { cout<<matriz[i][j]<<" "; } cout<<"t"<<endl; cout<<endl; } if(f==3 && c==3) { float det=0.0;
  • 125. EDDY ESEQUIEL MORENO BENAVIDES 124 int a=0; int b=1; int k=2; system("pause"); system("cls"); det=(matriz[a][a])*((matriz[b][b])*(matriz[k][k])- (matriz[k][b])*(matriz[b][k]))-(matriz[a][b])*((matriz[b][a])*(matriz[k][k])- (matriz[k][a])*(matriz[b][k]))+(matriz[a][k])*((matriz[b][a])*(matriz[k][b])- (matriz[k][a])*(matriz[b][b])); cout<<"El determinante es: "<<det<<endl; if(det==0) { cout<<"No existe matriz inversa."<<endl; system("pause"); return ; } else { int a=0; int b=1; int c=2; float c11,c12,c13; float c21,c22,c23;
  • 126. EDDY ESEQUIEL MORENO BENAVIDES 125 float c31,c32,c33; c11=((+1)*((matriz[b][b])*(matriz[c][c])-(matriz[c][b])*(matriz[b][c]))); c12=((-1)*((matriz[b][a])*(matriz[c][c])-(matriz[c][a])*(matriz[b][c]))); c13=((+1)*((matriz[b][a])*(matriz[c][b])-(matriz[c][a])*(matriz[b][b]))); c21=((-1)*((matriz[a][b])*(matriz[c][c])-(matriz[c][b])*(matriz[a][c]))); c22=((+1)*((matriz[a][a])*(matriz[c][c])-(matriz[c][a])*(matriz[a][c]))); c23=((-1)*((matriz[a][a])*(matriz[c][b])-(matriz[c][a])*(matriz[a][b]))); c31=((+1)*((matriz[a][b])*(matriz[b][c])-(matriz[b][b])*(matriz[a][c]))); c32=((-1)*((matriz[a][a])*(matriz[b][c])-(matriz[b][a])*(matriz[a][c]))); c33=((+1)*((matriz[a][a])*(matriz[b][b])-(matriz[b][a])*(matriz[a][b]))); cout<<"Matriz Inversa: "<<endl; cout<<c11/det<<"t"<<c21/det<<"t"<<c31/det<<endl; cout<<c12/det<<"t"<<c22/det<<"t"<<c32/det<<endl; cout<<c13/det<<"t"<<c23/det<<"t"<<c33/det<<endl; } } else { if(f==2 && c==2) { float det=0.0; int a=0; int b=1; system("pause"); system("cls");
  • 127. EDDY ESEQUIEL MORENO BENAVIDES 126 det=((matriz[a][a])*(matriz[b][b]))-((matriz[a][b])*(matriz[b][a])); cout<<"El determinante es: "<<det<<endl; if(det==0) { cout<<"No existe matriz inversa."<<endl; system("pause"); return ; } else { int a=0; int b=1; float c11,c12,c21,c22; c11=((-1)*(-1))*(matriz[b][b]); c12=((-1)*(-1)*(-1))*(matriz[b][a]); c21=((-1)*(-1)*(-1))*(matriz[a][b]); c22=((-1)*(-1)*(-1)*(-1))*(matriz[a][a]); cout<<"Matriz Inversa: "<<endl; cout<<c11/det<<"t"<<c21/det<<endl; cout<<c12/det<<"t"<<c22/det<<endl; } }
  • 128. EDDY ESEQUIEL MORENO BENAVIDES 127 } system("pause"); system("cls"); } void menu(int opc) { switch (opc) { case 1: mult(); break; case 2: suma(); break; case 3:
  • 129. EDDY ESEQUIEL MORENO BENAVIDES 128 resta(); break; case 4: det(); break; case 5: inversa(); break; case 6: acercade(); case 7: break; default: cout<<"opci242n incorrecta!!!"<<endl; break; } } Manejo de empleados #include <stdio.h> #include <stdlib.h>
  • 130. EDDY ESEQUIEL MORENO BENAVIDES 129 struct emp { int codigo; char nombre[30]; int edad; float sueldo; } reg; void crear(FILE *f) { f=fopen("empleado.txt", "r"); if(!f) { fopen("empleado.txt", "w"); printf("Se acaba de crear el fichero.n"); } else { printf("El fichero ya ha sido creado antes.n"); } fclose(f); return; }
  • 131. EDDY ESEQUIEL MORENO BENAVIDES 130 void agregar (FILE *f) { f=fopen("empleado.txt","r"); if (f==NULL) { printf("El fichero para guardar registros no ha sido creado aun.n"); } else { f=fopen("empleado.txt", "a"); printf("Ingrese su codigo de empleado n"); scanf("%d", &reg.codigo); printf("Digite su nombre n"); scanf("%s", reg.nombre); fflush(stdin); printf("Digite su edad n"); scanf("%d", &reg.edad); printf("Digite su salario n"); scanf("%f", &reg.sueldo); fwrite(&reg, sizeof(reg),1,f); fclose(f); return; } return; }
  • 132. EDDY ESEQUIEL MORENO BENAVIDES 131 void buscarEmp(FILE *f) { f = fopen("empleado.txt", "r"); if (f==NULL) { printf("El fichero con registros no existe!n"); return; } struct emp reg; int codTemp = 0; printf("Digite el codigo del empleado que desea buscar: n"); scanf("%d", &codTemp); printf("n"); rewind(f); while (!feof(f)) { fread(&reg, sizeof(reg),1,f); if (reg.codigo==codTemp) { printf("CodEmpleado: %d n", reg.codigo); printf("Empleado: %s n", reg.nombre); printf("Edad: %d n", reg.edad); printf("Sueldo: %.2f n", reg.sueldo); break;
  • 133. EDDY ESEQUIEL MORENO BENAVIDES 132 } } } void menu() { printf("t****MENU****n"); printf("1. Crear ficherosn"); printf("2. Agregar registron"); printf("3. Visualizarn"); printf("4. Buscar empleadon"); printf("5. Modificar empleadon"); printf("6. Remover empleadon"); printf("7. Salirn"); return; }; void ver(FILE *f) { int n=1; f=fopen("empleado.txt", "r"); if (f==NULL) { printf("Tienes que crear el fichero primero.n"); return; }
  • 134. EDDY ESEQUIEL MORENO BENAVIDES 133 fread(&reg, sizeof(reg),1,f); printf("tNumero tCodigo tNombre tEdad tSueldo"); while (!feof(f)) { printf("n t%d t%d t%s t%d t%.2f n", n, reg.codigo, reg.nombre, reg.edad, reg.sueldo); fread(&reg, sizeof(reg),1,f); n++; } fclose(f); return; } void modificar_empleado(FILE *f) { bool encontrado; int codEmp=0; FILE *archivoTemp; struct sRegistro reg; archivoTemp= fopen("temporal.txt","a+"); f= fopen("empleado","r"); if (archivoTemp==NULL && f==NULL) {
  • 135. EDDY ESEQUIEL MORENO BENAVIDES 134 printf("Error al abrir los archivos!"); } else { fflush(stdin); printf("Archivos abiertos con exito! n"); system("PAUSE"); system("cls"); printf("Ingrese el codigo del empleado que desea modificar"); scanf("%d",&cod); rewind(f); fread (&reg,sizeof(sRegistro),1,f); while (!feof(f)); { if (codEmp==reg.codigo) { encontrado=true; ffludh(stdout); printf("-------------------------------------------- n"); printf("CodEmpleado: %d n",reg.codigo); printf("Empleado: %s n",reg.nombre); printf("Edad: %d n",reg.edad); printf("Sueldo: %.2f n",reg.sueldo); printf("--------------------------------------- n"); int opc=0; fflush(stdin);
  • 136. EDDY ESEQUIEL MORENO BENAVIDES 135 printf("Ingresa una opcion segun el campo que desea modificar:"); printf("1. Para modificar el nombre. n"); printf("2. Para modificar la edad. n"); printf("3. Para modificar el sueldo. n"); printf("Opcion: "); scanf("%d",&opc); switch(opc) { case 1: { fflush(stdout); printf("Digite el nuevo nombre: n"); fflush(stdin); gets(reg.nombre); break; } case 2: { fflush(stdout); printf("Digite la nueva edad: n"); fflush(stdin); scanf("%d",&reg.edad); break; }
  • 137. EDDY ESEQUIEL MORENO BENAVIDES 136 case 3: { fflush(stdout); printf("Digite el nuevo sueldo: n"); fflush(stdin); scanf("%d",&reg.sueldo); break; } default: {printf("Digite una opcion valida!"); break; } fwrite(&reg,sizeof(struct sRegistro),1,archivoTemp) printf("Registro modificado! n"); } else { fweite (&reg sizeof(struct sRegistro),1,archivoTemp); } fread(&reg,sizeof(sRegistro),1,f) }
  • 138. EDDY ESEQUIEL MORENO BENAVIDES 137 if(encontrado==false) { printf("Registro no encontrado! n"); } } //Cerramos los archivos fclose(archivoTemp); fclose(fichero); remove ("empleado"); rename ("temporal.txt","empleado"); } } void remover_fichero(FILE *f) { f=fopen("empleado.txt","r"); if (f==NULL) { printf("No existe fichero para eliminar.n"); } else { int x; x= remove("empleados.txt"); if (x==0) {
  • 139. EDDY ESEQUIEL MORENO BENAVIDES 138 printf("El archivo se elimino correctamente nn"); } else { printf("El archivo no se pudo eliminar nn"); } return; } } int main() { FILE *f; int opcion=0; do { menu(); printf("Ingrese su opcionn"); scanf("%d", &opcion); switch(opcion) { case 1:
  • 140. EDDY ESEQUIEL MORENO BENAVIDES 139 { system("cls"); crear(f); break; } case 2: { system("cls"); agregar(f); break; } case 3: { system("cls"); ver(f); break; } case 4: { system("cls"); buscarEmp(f); break; } case 5: { system("cls");
  • 141. EDDY ESEQUIEL MORENO BENAVIDES 140 modificar_empleado(f); break; } default: { printf("Opcion incorrecta n"); break; } } system("pause"); system("cls"); fflush(stdin); } while(opcion!=7); return 0; }
  • 142. EDDY ESEQUIEL MORENO BENAVIDES 141 Fuentes:  http://www.zator.com/Cpp/E1_2.htm  https://blanchardspace.wordpress.com/2013/05/06/introduccion-a-c- que-es/  https://es.wikibooks.org/wiki/Fundamentos_de_programaci%C3%B3n/Al goritmos_y_programas  https://msdn.microsoft.com/es-es/library/mt589696.aspx  http://decsai.ugr.es/~jfv/ed1/c++/cdrom3/TIC- CD/web/tema21/palabras.htm  https://www.programarya.com/Cursos/C++/Bibliotecas-O-Librerias  http://www.monografias.com/trabajos16/entrada-y-salida/entrada-y- salida.shtml  http://ejercicioscpp.blogspot.com/2012/11/estructuras-de-control-en- c.html  https://www.programarya.com/Cursos/C++/Estructuras-De- Datos/Punteros  https://es.wikibooks.org/wiki/Programaci%C3%B3n_en_C%2B%2B/Punte ros  http://www.cplusplus.com/reference/cstdio/fwrite/