Upload
estudiantes-isiuca
View
59
Download
1
Embed Size (px)
Citation preview
[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.
Tabla de contenidoHistoria 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.............................................................................................9Puntos a tomar en cuenta..................................................................................................................9
Identificadores........................................................................................... 11Reglas al nombrar identificadores....................................................................................................11
Palabras reservadas...................................................................................12
Declaración de variables............................................................................14
Constantes................................................................................................. 16
Constante de carácter................................................................................17
Juego de caracteres....................................................................................19
Operadores................................................................................................ 21Operadores Aritméticos...................................................................................................................21Operadores lógicos y relacionales....................................................................................................22Operadores 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
EDDY ESEQUIEL MORENO BENAVIDES 1
MANUAL DE C/C++
Entrada de datos........................................................................................ 33
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
EDDY ESEQUIEL MORENO BENAVIDES 2
MANUAL DE C/C++
Punteros..................................................................................................................48
Anexos.....................................................................................................................49
Proyecto final de clase (Administrador de apartamentos)...........................49Main.................................................................................................................................................49Cabecera datos.h..............................................................................................................................76
Login + Ejercicios de empleados.................................................................77
Ejercicio de matrices- Algebra lineal...........................................................98
Manejo de empleados..............................................................................128
EDDY ESEQUIEL MORENO BENAVIDES 3
MANUAL DE C/C++
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 4
MANUAL DE C/C++
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 5
MANUAL DE C/C++
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 6
MANUAL DE C/C++
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 7
MANUAL DE C/C++
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 8
MANUAL DE C/C++
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 9
MANUAL DE C/C++
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 4294967295Cará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.1E4932Negativos: -3.4E-
4932 a -1.1E4932
Lógicos Dato lógico bool 1 0 a 1
EDDY ESEQUIEL MORENO BENAVIDES 10
MANUAL DE C/C++
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 11
MANUAL DE C/C++
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 Significadostream Flujo de datos
cin Entrada estándarcout Salida estándarcerr Salida de mensajes de error
streambuf Operación de I/O a bajo nivelistream Operación de I/O a alto nivelostream Operación de I/O a alto niveliostream Operación de I/O a alto nivel
ios Clase para el manejo de la I/O a alto nivelsetf() Método de la clase ios para inicializar los indic de formatoflags() Método de la clase ios para inicializar los indic de formato
unsetf() Método de la clase ios para desactivar los indic de formatowidth() Función declarada en las clases istream, ostream e iostream
precision() Función declarada en las clases istream, ostream e iostreamfill() Función declarada en las clases istream, ostream e iostreamendl Manipulador sin argumentos definidos en iomanip.hflush Manipulador sin argumentos definidos en iomanip.h
<< ó >> Operadores de inserción o extracción de flujoifstream 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 salidafflush Limpia el buffercase Si se cumple un caso
default Ningunas opciones de la selectiva múltipletypedef Crea un nuevo nombre de tipo para un tipo de dato ya definido
for Estructura repetitiva (o de ciclo)
EDDY ESEQUIEL MORENO BENAVIDES 12
MANUAL DE C/C++
int Tipo de dato entero} Fin del programa o de un bloque
do Estructura repetitivaprintf Imprime en pantallaputs Imprime una cadena
{ Inicio del programa o un bloquescanf Lee una variablegets Lee una cadena de caracteres
clrscr Borra el contenido de la pantallawhile Estructura repetitivavoid Valor nulomain Programa principalsqrt Calcula raíz Cuadradafloat Tipo de dato real
struct Registro o estructurareturn Regresa valor a otra funciónbreak Terminar el casoswitch Estructura selectiva múltiple
if Estructura selectivaelse La parte falsa de la selectiva
EDDY ESEQUIEL MORENO BENAVIDES 13
MANUAL DE C/C++
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 14
MANUAL DE C/C++
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 15
MANUAL DE C/C++
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 16
MANUAL DE C/C++
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 17
MANUAL DE C/C++
9. Demostración del uso en constantes especiales
EDDY ESEQUIEL MORENO BENAVIDES 18
MANUAL DE C/C++
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 19
MANUAL DE C/C++
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 ~
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.
EDDY ESEQUIEL MORENO BENAVIDES 20
MANUAL DE C/C++
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 21
MANUAL DE C/C++
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 22
MANUAL DE C/C++
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 operacionesa. Potenciab. Multiplicaciónc. Divisiónd. Moduloe. Suma f. Resta
10. Jerarquía de operadores en demostración
EDDY ESEQUIEL MORENO BENAVIDES 23
MANUAL DE C/C++
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 24
MANUAL DE C/C++
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 25
MANUAL DE C/C++
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 26
MANUAL DE C/C++
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íamath 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 27
MANUAL DE C/C++
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 28
MANUAL DE C/C++
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 29
MANUAL DE C/C++
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 30
MANUAL DE C/C++
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 31
MANUAL DE C/C++
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 %cCarácter sin signo unsigned char %u
Carácter char %s
Carácter imprime el carácter % %
Entero
Entero Decimal int %d,%iEntero 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 32
MANUAL DE C/C++
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 33
MANUAL DE C/C++
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 pantalla2. Secuencias de escape3. 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 34
MANUAL DE C/C++
Funciones sin formato
Función Descripcióngetche() 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 35
MANUAL DE C/C++
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 36
MANUAL DE C/C++
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 37
MANUAL DE C/C++
{
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 38
MANUAL DE C/C++
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;
}
While
EDDY ESEQUIEL MORENO BENAVIDES 39
MANUAL DE C/C++
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;
}
Do-while
Este es el único bucle que por lo menos se ejecutara una vez puesto que este
EDDY ESEQUIEL MORENO BENAVIDES 40
MANUAL DE C/C++
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
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.
EDDY ESEQUIEL MORENO BENAVIDES 41
MANUAL DE C/C++
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
Ficheros
EDDY ESEQUIEL MORENO BENAVIDES 42
MANUAL DE C/C++
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 43
MANUAL DE C/C++
"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.
26. Demostración de cierre de un archivo
EDDY ESEQUIEL MORENO BENAVIDES 44
MANUAL DE C/C++
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
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.
EDDY ESEQUIEL MORENO BENAVIDES 45
MANUAL DE C/C++
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
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.
EDDY ESEQUIEL MORENO BENAVIDES 46
MANUAL DE C/C++
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
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.
EDDY ESEQUIEL MORENO BENAVIDES 47
MANUAL DE C/C++
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 48
MANUAL DE C/C++
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.
EDDY ESEQUIEL MORENO BENAVIDES 49
MANUAL DE C/C++
void SubMenuApartamento(FILE *f); //Menu que muestra la opcion de ingresar inquilino, ver inquilino, ver pago.
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;
EDDY ESEQUIEL MORENO BENAVIDES 50
MANUAL DE C/C++
Rect.Bottom = Alto - 1;
// 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
EDDY ESEQUIEL MORENO BENAVIDES 51
MANUAL DE C/C++
int contador = 0;
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<< "\t\t\t------------------------------"<<endl;
cout << "\t\t\tLOGIN DE USUARIO" << endl;
cout<< "\t\t Apartament's Administrator"<<endl;
cout << "\t\t\t----------------------------" << endl;
EDDY ESEQUIEL MORENO BENAVIDES 52
MANUAL DE C/C++
// Lectura del username
cout <<endl<<"\tUsuario: ";
getline(cin, usuario);
// Lectura del password
char caracter;
cout << "\tContrase\244a: ";
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);
}
EDDY ESEQUIEL MORENO BENAVIDES 53
MANUAL DE C/C++
}
caracter = getch();
}
// 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 << "\n\n\tEl usuario y/o password son incorrectos" << endl;
cin.get();
contador++;
}
}
while (ingresa == false && contador < 3);
if (ingresa == false)
{
cout << "\n\tUsted no pudo ingresar al sistema." << endl;
EDDY ESEQUIEL MORENO BENAVIDES 54
MANUAL DE C/C++
}
else
{
cout << "\n\n\tBienvenido 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;
EDDY ESEQUIEL MORENO BENAVIDES 55
MANUAL DE C/C++
cout <<"| 6. Ver Apartamento 6 |"<< endl;
cout <<"| 7. Ver Apartamento 7 |"<< endl;
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()
EDDY ESEQUIEL MORENO BENAVIDES 56
MANUAL DE C/C++
cout<<"Gracias por utilizar el programa";
}
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;
EDDY ESEQUIEL MORENO BENAVIDES 57
MANUAL DE C/C++
cout << "5: Para modificar el sexo. " << endl;
cout << "6: Para modificar la edad. " << endl;
cout << "7: Regresar al menu" << endl;
do
{
cout << endl<< "Seleccione una opci\242n: " << 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 c\202dula: "<<endl;
fflush(stdin);
gets(reg[opc-1].cedula);
break;
}
case 3:
EDDY ESEQUIEL MORENO BENAVIDES 58
MANUAL DE C/C++
{
fflush(stdout);
cout <<endl<< "Digite la nueva ocupaci\242n: " << endl;
fflush(stdin);
gets(reg[opc-1].ocupacion);
break;
}
case 4:
{
fflush(stdout);
cout <<endl<< "Digite el nuevo tel\202fono: " << 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;
EDDY ESEQUIEL MORENO BENAVIDES 59
MANUAL DE C/C++
fflush(stdin);
cin >> reg[opc-1].edad;
break;
}
case 7:
{
system("cls");
cout<<endl<<endl<<" La ficha de informaci\242n 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(®[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 opci\242n v\240lida!" << endl;
break;
}
}
while (opcion!=7);
EDDY ESEQUIEL MORENO BENAVIDES 60
MANUAL DE C/C++
system("PAUSE");
system("cls");
return;
}
void ingresar()
{
system("cls");
fflush(stdin);
cout << "Ingrese el nombre del inquilino: " << endl;
gets(reg[opc-1].nombre);
cout << "Ingrese la c\202dula 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 ocupaci\242n del inquilino: " << endl;
fflush(stdin);
gets(reg[opc-1].ocupacion);
EDDY ESEQUIEL MORENO BENAVIDES 61
MANUAL DE C/C++
cout << "Ingrese el tel\202fono del inquilino: " << endl;
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 << "C\202dula: " << reg[opc-1].cedula << endl;
fflush(stdout);
cout << "Ocupaci\242n: " << reg[opc-1].ocupacion << endl;
fflush(stdout);
EDDY ESEQUIEL MORENO BENAVIDES 62
MANUAL DE C/C++
cout << "Tel\202fono: " << reg[opc-1].telefono << endl;
fflush(stdout);
cout << "Edad: " << reg[opc-1].edad << endl;
fflush(stdout);
cout << "Sexo: " << reg[opc-1].sexo << endl<<endl;
do
{
cout << "Seleccione una Opci\242n: " << endl;
cout << " ____________________________ "<< endl;
cout << "| |"<< endl;
cout << "|1. Modificar inquilino |"<< endl;
cout << "|2. Eliminar inquilino |"<< endl;
cout << "|3. Regresar al men\243 |"<< endl;
cout << "|____________________________|"<< endl;
fflush(stdin);
cin >> opcion;
switch(opcion)
{
case 1:
{
system("cls");
fclose(f);
modificar(f);
break;
}
EDDY ESEQUIEL MORENO BENAVIDES 63
MANUAL DE C/C++
case 2:
{
system("cls");
eliminar();
break;
}
case 3:
{
break;
}
default:
{
cout<<"Opci\242n incorrecta";
break;
}
}
}
while(opcion!=3);
return;
}
void SubMenuApartamento(FILE *f)
{
int opcion = 0;
EDDY ESEQUIEL MORENO BENAVIDES 64
MANUAL DE C/C++
cout<<"Usted seleccion\242 el apartamento "<< opc << endl;
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 men\243 principal |"<< endl;
cout <<"|________________________________|"<< endl;
cout <<"Seleccione Una Opci\242n: ";
fflush(stdin);
cin >> opcion;
switch (opcion)
{
case 1:
ingresar();
break;
EDDY ESEQUIEL MORENO BENAVIDES 65
MANUAL DE C/C++
case 2:
Menu();
break;
default:
cout<<"Estimado user digite una opci\242n v\240lida!"<<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 men\243 |"<< endl;
cout <<"|________________________________|"<< endl;
cout <<"Seleccione Una Opci\242n: ";
fflush(stdin);
cin >> opcion;
EDDY ESEQUIEL MORENO BENAVIDES 66
MANUAL DE C/C++
switch (opcion)
{
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;
EDDY ESEQUIEL MORENO BENAVIDES 67
MANUAL DE C/C++
cout<<"Seleccione el mes:"<<endl;
cout<<"1- Enero"<<endl;
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<<"Adi\242s, hasta pronto"<<endl;
EDDY ESEQUIEL MORENO BENAVIDES 68
MANUAL DE C/C++
}
else
{
cout<<"Opci\242n 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++)
{
EDDY ESEQUIEL MORENO BENAVIDES 69
MANUAL DE C/C++
if (x<10)
{
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;
EDDY ESEQUIEL MORENO BENAVIDES 70
MANUAL DE C/C++
cout <<"|________________________________|"<< endl;
do
{
fflush(stdin);
cin>>opcion;
switch(opcion)
{
case 1:
{
system("cls");
pago();
break;
}
case 2:
{
system("cls");
break;
}
default:
EDDY ESEQUIEL MORENO BENAVIDES 71
MANUAL DE C/C++
{
cout<<"Estimado user digite una opci\242n valida!"<<endl;
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.
EDDY ESEQUIEL MORENO BENAVIDES 72
MANUAL DE C/C++
dia=tm.tm_mday; //Se guarda el dia actual.
//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;
EDDY ESEQUIEL MORENO BENAVIDES 73
MANUAL DE C/C++
int valido=0;
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(®[x-1],sizeof(struct inquilinos),1,f); ///
}
fclose(f);
EDDY ESEQUIEL MORENO BENAVIDES 74
MANUAL DE C/C++
}
while (salida!=1)
{
Menu();
cout<<"Digite su opci\242n: ";
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(®[x-1], sizeof(struct inquilinos), 1, f); ///
EDDY ESEQUIEL MORENO BENAVIDES 75
MANUAL DE C/C++
}
fclose(f);
break;
default:
cout<<"Estimado user digite una opci\242n valida!"<<endl;
system("pause");
}
}
}
return 0;
}
Cabecera datos.hint 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
EDDY ESEQUIEL MORENO BENAVIDES 76
MANUAL DE C/C++
}reg[7];
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 = ' ';
EDDY ESEQUIEL MORENO BENAVIDES 77
MANUAL DE C/C++
//variables
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);
EDDY ESEQUIEL MORENO BENAVIDES 78
MANUAL DE C/C++
void verificar_contrasena(TCadena nombreFichero,Persona_R &password);
struct Empleado emp;
void menu ()
{
printf("\n ----- MENU PRINCIPAL------ \n");
printf("\n ------------------------ \n");
printf("\n\t 1: Crear Fichero Empleado \n");
printf("\n\t 2: Agregar Nuevo Empleado \n");
printf("\n\t 3: Consultar un empleado segun INSS \n");
printf("\n\t 4: Ver Empleados registrados \n");
printf("\n\t 5: Eliminar Empleado segun INSS \n");
printf("\n\t 6: Salir \n");
}
void menuInv ()
{
printf("\n ----- MENU PRINCIPAL------ \n");
printf("\n ------------------------ \n");
printf("\n\t 1: Crear Fichero Empleado \n");
printf("\n\t 2: Consultar un empleado segun INSS \n");
printf("\n\t 3: Ver Empleados registrados \n");
printf("\n\t 4: Salir \n");
}
void crearFichero(FILE *fichero)
{
EDDY ESEQUIEL MORENO BENAVIDES 79
MANUAL DE C/C++
fichero = fopen("empleado","r");
if (!fichero)
{
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: ");
EDDY ESEQUIEL MORENO BENAVIDES 80
MANUAL DE C/C++
gets(emp.inss);
fflush(stdin);
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)
EDDY ESEQUIEL MORENO BENAVIDES 81
MANUAL DE C/C++
{
bool encontrado=false;
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);
EDDY ESEQUIEL MORENO BENAVIDES 82
MANUAL DE C/C++
fclose(temp);
remove("empleado");
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;
}
EDDY ESEQUIEL MORENO BENAVIDES 83
MANUAL DE C/C++
fclose(fichero);
system("pause");
}
}
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 84
MANUAL DE C/C++
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);
EDDY ESEQUIEL MORENO BENAVIDES 85
MANUAL DE C/C++
fread(®,sizeof(Empleado),1,fichero);
while (!feof(fichero))
{
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:
{
EDDY ESEQUIEL MORENO BENAVIDES 86
MANUAL DE C/C++
fflush(stdout);
printf("Digite el nuevo nombre: \n");
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;
EDDY ESEQUIEL MORENO BENAVIDES 87
MANUAL DE C/C++
}
fwrite(&emp, sizeof(struct Empleado),1, archivoTemp);
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
EDDY ESEQUIEL MORENO BENAVIDES 88
MANUAL DE C/C++
int main()
{
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 << "----------------------------\n\n" << endl;
cout << "Introduzca Opcion: ";
cin >> opcion_menu;
if (opcion_menu==4)
{
finalizar_programa();
}
if((opcion_menu<MIN)||(opcion_menu>MAX))
{
EDDY ESEQUIEL MORENO BENAVIDES 89
MANUAL DE C/C++
try
{
system("cls");
cout<<"\n\n\t ============================\n"
<<"\n\n\t | ESTA OPCION ES INCORRECTA |\n"
<<"\n\n\t ============================\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");
EDDY ESEQUIEL MORENO BENAVIDES 90
MANUAL DE C/C++
//confirmar_PASS(password);
verificar_contrasena(nombre_usuario_registrado,password);
//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:
EDDY ESEQUIEL MORENO BENAVIDES 91
MANUAL DE C/C++
system("cls");
ConsultarEmpleado(fichero);
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
EDDY ESEQUIEL MORENO BENAVIDES 92
MANUAL DE C/C++
int salida = 0;
FILE *fichero;
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");
EDDY ESEQUIEL MORENO BENAVIDES 93
MANUAL DE C/C++
salida = 1;
finalizar_programa();
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 94
MANUAL DE C/C++
}
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())
EDDY ESEQUIEL MORENO BENAVIDES 95
MANUAL DE C/C++
{
// El fichero no existe ... lo creo
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);
}
}
EDDY ESEQUIEL MORENO BENAVIDES 96
MANUAL DE C/C++
void verificar_existencia_de_usuario(TCadena nombreFichero)
{
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");
EDDY ESEQUIEL MORENO BENAVIDES 97
MANUAL DE C/C++
}
if(cadena!=password.PASS)
{
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();
EDDY ESEQUIEL MORENO BENAVIDES 98
MANUAL DE C/C++
void suma();
void menu(int opc);
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. Multiplicaci\242n: ... "<<endl;
cout<<" 2. Suma: ... "<<endl;
cout<<" 3. Resta: ... "<<endl;
cout<<" 4. Determinante: ... "<<endl;
cout<<" 5. Inversa:..."<<endl;
cout<<" 6. Acerca de: ..."<<endl;
EDDY ESEQUIEL MORENO BENAVIDES 99
MANUAL DE C/C++
cout<<" 7. Salir:..."<<endl<<endl;
cin>>opc;
system("cls");
menu(opc);
}
while(opc!=7);
cout<<"Hasta pronto. "<<endl;
return 0;
}
void acercade()
{
cout<<"Creado por: "<<endl;
cout<<"- Eddy Moreno Benavides ([email protected])."<<endl;
cout<<"- Axel P\240rez Molina ([email protected])."<<endl;
cout<<"- Agradecimiento a Pablo El\241as Galante ([email protected])"<<endl;
cout<<" por su colaboraci\242n."<<endl<<endl;
cout<<"Estudiantes de ISI primer a\xA4o, UCA Nicaragua."<<endl;
cout<<"Para la clase de \240lgebra lineal. "<<endl;
cout<<"Realizado para el docente: Jos\202 Benigno Garc\241a. "<<endl<<endl;
cout<<"Entregado el: 25 de agosto de 2016."<<endl<<endl<<endl;
system("pause");
system("cls");
}
EDDY ESEQUIEL MORENO BENAVIDES 100
MANUAL DE C/C++
void suma()
{
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
{
EDDY ESEQUIEL MORENO BENAVIDES 101
MANUAL DE C/C++
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];
}
}
system("pause");
system("cls");
for (int i=0; i<f; i++)
for (int j=0; j<c; j++)
suma[i][j] = 0;
EDDY ESEQUIEL MORENO BENAVIDES 102
MANUAL DE C/C++
for (int i=0; i<f; i++)
{
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;
EDDY ESEQUIEL MORENO BENAVIDES 103
MANUAL DE C/C++
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<<"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;
}
}
EDDY ESEQUIEL MORENO BENAVIDES 104
MANUAL DE C/C++
salida=true;
}
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;
EDDY ESEQUIEL MORENO BENAVIDES 105
MANUAL DE C/C++
cin>>c;
if (f!=c)
{
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 106
MANUAL DE C/C++
}
}
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 107
MANUAL DE C/C++
}
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 108
MANUAL DE C/C++
}
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;
EDDY ESEQUIEL MORENO BENAVIDES 109
MANUAL DE C/C++
cin>>f;
cout<<"Ingrese las columas de la matriz pimaria. "<<endl;
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++)
{
EDDY ESEQUIEL MORENO BENAVIDES 110
MANUAL DE C/C++
for(int x=0; x<c2; x++)
{
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++)
EDDY ESEQUIEL MORENO BENAVIDES 111
MANUAL DE C/C++
{
cout<<matriz[i][j]<<"\t";
}
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++)
EDDY ESEQUIEL MORENO BENAVIDES 112
MANUAL DE C/C++
matrix[i][j] = 0; ///PARA INICIALIZAR LA VARIABLE MULT EN MULTIPLES ARRAYS
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;
EDDY ESEQUIEL MORENO BENAVIDES 113
MANUAL DE C/C++
}
system("pause");
system("cls");
}
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
{
EDDY ESEQUIEL MORENO BENAVIDES 114
MANUAL DE C/C++
if(f==2 &&c==2)
{
matrizDeDos();
salida=true;
}
else
{
if (f==4 && c==4)
{
matrizDeCuatro();
salida=true;
}
else
{
if(f==5 && c==5)
{
matrizDeCinco();
salida=true;
}
}
}
}
}
system("pause");
system("cls");
EDDY ESEQUIEL MORENO BENAVIDES 115
MANUAL DE C/C++
}
void matrizDeCinco()
{
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++)
{
EDDY ESEQUIEL MORENO BENAVIDES 116
MANUAL DE C/C++
proc[f][c]=((matriz[a][a])*(matriz[f][c]))-((matriz[a][c])*(matriz[f][a]))/(matriz[a][a]);
}
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];
}
EDDY ESEQUIEL MORENO BENAVIDES 117
MANUAL DE C/C++
}
cout<<"Matriz: "<<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");
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;
EDDY ESEQUIEL MORENO BENAVIDES 118
MANUAL DE C/C++
int c=4;
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++)
{
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;
EDDY ESEQUIEL MORENO BENAVIDES 119
MANUAL DE C/C++
int a=0;
int b=1;
int y=2;
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++)
{
EDDY ESEQUIEL MORENO BENAVIDES 120
MANUAL DE C/C++
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 det=0;
int a=0;
int b=1;
int k=2;
system("pause");
system("cls");
EDDY ESEQUIEL MORENO BENAVIDES 121
MANUAL DE C/C++
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<<"Tama\xA4o m\240ximo 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 122
MANUAL DE C/C++
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 123
MANUAL DE C/C++
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 124
MANUAL DE C/C++
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 125
MANUAL DE C/C++
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 126
MANUAL DE C/C++
}
system("pause");
system("cls");
}
void menu(int opc)
{
switch (opc)
{
case 1:
mult();
break;
case 2:
suma();
break;
case 3:
EDDY ESEQUIEL MORENO BENAVIDES 127
MANUAL DE C/C++
resta();
break;
case 4:
det();
break;
case 5:
inversa();
break;
case 6:
acercade();
case 7:
break;
default:
cout<<"opci\242n incorrecta!!!"<<endl;
break;
}
}
Manejo de empleados#include <stdio.h>
#include <stdlib.h>
EDDY ESEQUIEL MORENO BENAVIDES 128
MANUAL DE C/C++
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 129
MANUAL DE C/C++
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", ®.codigo);
printf("Digite su nombre \n");
scanf("%s", reg.nombre);
fflush(stdin);
printf("Digite su edad \n");
scanf("%d", ®.edad);
printf("Digite su salario \n");
scanf("%f", ®.sueldo);
fwrite(®, sizeof(reg),1,f);
fclose(f);
return;
}
return;
}
EDDY ESEQUIEL MORENO BENAVIDES 130
MANUAL DE C/C++
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(®, 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 131
MANUAL DE C/C++
}
}
}
void menu()
{
printf("\t****MENU****\n");
printf("1. Crear ficheros\n");
printf("2. Agregar registro\n");
printf("3. Visualizar\n");
printf("4. Buscar empleado\n");
printf("5. Modificar empleado\n");
printf("6. Remover empleado\n");
printf("7. Salir\n");
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 132
MANUAL DE C/C++
fread(®, 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(®, 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 133
MANUAL DE C/C++
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 (®,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 134
MANUAL DE C/C++
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",®.edad);
break;
}
EDDY ESEQUIEL MORENO BENAVIDES 135
MANUAL DE C/C++
case 3:
{
fflush(stdout);
printf("Digite el nuevo sueldo: \n");
fflush(stdin);
scanf("%d",®.sueldo);
break;
}
default:
{printf("Digite una opcion valida!");
break;
}
fwrite(®,sizeof(struct sRegistro),1,archivoTemp)
printf("Registro modificado! \n");
}
else
{
fweite (® sizeof(struct sRegistro),1,archivoTemp);
}
fread(®,sizeof(sRegistro),1,f)
}
EDDY ESEQUIEL MORENO BENAVIDES 136
MANUAL DE C/C++
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 137
MANUAL DE C/C++
printf("El archivo se elimino correctamente \n\n");
}
else
{
printf("El archivo no se pudo eliminar \n\n");
}
return;
}
}
int main()
{
FILE *f;
int opcion=0;
do
{
menu();
printf("Ingrese su opcion\n");
scanf("%d", &opcion);
switch(opcion)
{
case 1:
EDDY ESEQUIEL MORENO BENAVIDES 138
MANUAL DE C/C++
{
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 139
MANUAL DE C/C++
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 140
MANUAL DE C/C++
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/
Algoritmos_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/
Punteros http://www.cplusplus.com/reference/cstdio/fwrite/
EDDY ESEQUIEL MORENO BENAVIDES 141
MANUAL DE C/C++