Manual C/C++

[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


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


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


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


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++


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.


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


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.


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


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


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)


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


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


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


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.


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


MANUAL DE C/C++

9. Demostración del uso en constantes especiales


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


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.


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.


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 ( = ).


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


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


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


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


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++


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


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


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


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


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


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


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


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.


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


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


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;

}


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


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


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.


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


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.


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


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.


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.


MANUAL DE C/C++

http://c.conclase.net/curso/?cap=003#inicio

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.


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


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.


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;


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


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;


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);

}


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;


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;






MANUAL DE C/C++



cout <<"| 8. Salir del Programa |"<< 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()


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;


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:


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;


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(&reg[x-1], sizeof(struct inquilinos), 1, f); //Se realiza un loop para escribir en todas las estructuras del fichero

//sin cambiar nada mas que lo seleccionado como inquilino.

}

break;

}

default:

cout <<endl<< "Digite una opci\242n v\240lida!" << endl;

break;

}

}

while (opcion!=7);


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);


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);


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;

}


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;


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 <<"| 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;


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 <<"| 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;


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;


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;


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++)

{


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 <<"| 1 - Realizar pago |"<< endl;

cout <<"| 2 - Regresar al menu |"<< endl;


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:


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.


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;


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(&reg[x-1],sizeof(struct inquilinos),1,f); ///

}

fclose(f);


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(&reg[x-1], sizeof(struct inquilinos), 1, f); ///


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


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"


//SISTEMA DE REGISTRO DE USUARIOS

//CONSTANTES

const char FINCAD = char(0);

const int MAXCAD = 20;

const char SP = ' ';


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);


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)

{


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: ");


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)


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);


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;

}


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;

}


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);


MANUAL DE C/C++

fread(&reg,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:

{


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;


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


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))

{


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");


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:


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;


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


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");


MANUAL DE C/C++

salida = 1;


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");


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())


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);

}

}


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");


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>


void mult();


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;


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");

}


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

{


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;


MANUAL DE C/C++


{

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;


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;


{


{

cout<<suma[i][j]<<"\t";

}

cout<<endl;

}

}


MANUAL DE C/C++

salida=true;

}

system("pause");

system("cls");

}

void resta()

{



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**/


{

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;


MANUAL DE C/C++

cin>>c;

if (f!=c)

{


salida=true;

}

else

{

cout<<"Ingrese primera matriz"<<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++)

{


cin>>mat[z][x];


MANUAL DE C/C++

}

}

system("pause");

system("cls");



resta[i][j] = 0;


{

for(int j=0; j<c; j++)//RESTA

{

resta[i][j] = (matriz[i][j]) - (mat[i][j]);

}

}

system("pasue");

system("cls");


cout<<"Orden de la primera matriz ingresada: "<<f<<"x"<<c<<endl;


{


{



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<<endl;

}

system("pause");

system("cls");

cout<<"Resta de las 2 matrices es: "<<endl;

cout<<endl;


{


{

cout<<resta[i][j]<<"\t";


MANUAL DE C/C++

}

cout<<endl;

}

}

salida=true;

}

system("pause");

system("cls");

}

void mult()

{



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;


{

cout<<"Ingrese las filas de la matriz primaria. "<<endl;


MANUAL DE C/C++

cin>>f;

cout<<"Ingrese las columas de la matriz pimaria. "<<endl;

cin>>c;

cout<<"Ingrese Primer matriz"<<endl;


{

cout<<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++)

{


MANUAL DE C/C++

for(int x=0; x<c2; x++)

{


cin>>mat[z][x];

}

cout<<endl;

}

system("pasue");

system("cls");

if(c!=f2)

{


salida=true;

}

else

{


cout<<"Orden de la primera matriz ingresada: "<<f<<"x"<<c<<endl;


{



MANUAL DE C/C++

{


}

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<<endl;

}

system("pause");

system("cls");

/**Proceso De Multiplicación Matricial **/




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 j=0; j<c2 ; j++)

{

cout<<matrix[i][j]<<"\t";

}

cout<<endl;

}

}

salida=true;


MANUAL DE C/C++

}

system("pause");

system("cls");

}

void det()

{

int f=0,c=0;/** F = Filas, C = Columnas**/

bool 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

{


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");


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];


{


{


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++)

{


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;


{


{


cin>>matriz[i][j];

}


MANUAL DE C/C++

}

cout<<"Matriz: "<<endl;


{


{

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;


MANUAL DE C/C++

int c=4;


{


{


cin>>matriz[i][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;


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));


}

void matrizDeTres()

{

float matriz[5][5];

int f=3;

int c=3;


{


MANUAL DE C/C++


{


cin>>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");


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]));


}

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 ;

}


MANUAL DE C/C++

system("pause");

system("cls");

cout<<"Ingrese Matriz: "<<endl;


{


{


cin>>matriz[i][j];

}

}

cout<<"Su Matriz es: "<<endl;


{


{


}

cout<<"\t"<<endl;

cout<<endl;

}

if(f==3 && c==3)

{

float det=0.0;


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]));


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;


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;



}

}

else

{

if(f==2 && c==2)

{

float det=0.0;

int a=0;

int b=1;

system("pause");

system("cls");


MANUAL DE C/C++

det=((matriz[a][a])*(matriz[b][b]))-((matriz[a][b])*(matriz[b][a]));


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;

}

}


MANUAL DE C/C++

}

system("pause");

system("cls");

}

void menu(int opc)

{

switch (opc)

{

case 1:

mult();

break;

case 2:

suma();

break;

case 3:


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>


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;

}


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", &reg.codigo);

printf("Digite su nombre \n");

scanf("%s", reg.nombre);

fflush(stdin);

printf("Digite su edad \n");

scanf("%d", &reg.edad);

printf("Digite su salario \n");

scanf("%f", &reg.sueldo);

fwrite(&reg, sizeof(reg),1,f);

fclose(f);

return;

}

return;

}


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(&reg, sizeof(reg),1,f);

if (reg.codigo==codTemp)

{

printf("CodEmpleado: %d \n", reg.codigo);

printf("Empleado: %s \n", reg.nombre);

printf("Edad: %d \n", reg.edad);

printf("Sueldo: %.2f \n", reg.sueldo);

break;


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;

}


MANUAL DE C/C++


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);


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)

{


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 (&reg,sizeof(sRegistro),1,f);

while (!feof(f));

{

if (codEmp==reg.codigo)

{

encontrado=true;

ffludh(stdout);

printf("-------------------------------------------- \n");

printf("CodEmpleado: %d \n",reg.codigo);

printf("Empleado: %s \n",reg.nombre);

printf("Edad: %d \n",reg.edad);

printf("Sueldo: %.2f \n",reg.sueldo);

printf("--------------------------------------- \n");

int opc=0;

fflush(stdin);


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",&reg.edad);

break;

}


MANUAL DE C/C++

case 3:

{

fflush(stdout);

printf("Digite el nuevo sueldo: \n");

fflush(stdin);

scanf("%d",&reg.sueldo);

break;

}

default:

{printf("Digite una opcion valida!");

break;

}

fwrite(&reg,sizeof(struct sRegistro),1,archivoTemp)

printf("Registro modificado! \n");

}

else

{

fweite (&reg sizeof(struct sRegistro),1,archivoTemp);

}

fread(&reg,sizeof(sRegistro),1,f)

}


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)

{


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:


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");


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;

}


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/


MANUAL DE C/C++

http://www.cplusplus.com/reference/cstdio/fwrite/

https://es.wikibooks.org/wiki/Programaci%C3%B3n_en_C%2B%2B/Punteros

https://es.wikibooks.org/wiki/Programaci%C3%B3n_en_C%2B%2B/Punteros

https://www.programarya.com/Cursos/C++/Estructuras-De-Datos/Punteros

https://www.programarya.com/Cursos/C++/Estructuras-De-Datos/Punteros

http://ejercicioscpp.blogspot.com/2012/11/estructuras-de-control-en-c.html

http://ejercicioscpp.blogspot.com/2012/11/estructuras-de-control-en-c.html

http://www.monografias.com/trabajos16/entrada-y-salida/entrada-y-salida.shtml

http://www.monografias.com/trabajos16/entrada-y-salida/entrada-y-salida.shtml

https://www.programarya.com/Cursos/C++/Bibliotecas-O-Librerias

http://decsai.ugr.es/~jfv/ed1/c++/cdrom3/TIC-CD/web/tema21/palabras.htm

http://decsai.ugr.es/~jfv/ed1/c++/cdrom3/TIC-CD/web/tema21/palabras.htm

https://msdn.microsoft.com/es-es/library/mt589696.aspx

https://es.wikibooks.org/wiki/Fundamentos_de_programaci%C3%B3n/Algoritmos_y_programas

https://es.wikibooks.org/wiki/Fundamentos_de_programaci%C3%B3n/Algoritmos_y_programas

https://blanchardspace.wordpress.com/2013/05/06/introduccion-a-c-que-es/

https://blanchardspace.wordpress.com/2013/05/06/introduccion-a-c-que-es/

http://www.zator.com/Cpp/E1_2.htm

Manual C/C++

Education

Transcript of Manual C/C++