Manual C/C++

6-6-2016 Manual de
Programación en
C/C++
Prof.: Ing. Elsner Boanerge
González Ortega
Jimmy Prado
UNIVERSIDAD CENTROAMERICANA “UCA”

TABLA DE CONTENIDO
1 Variables y Constantes.............................................................................................................3
1.1 Variable .............................................................................................................................3
1.2 Constante..........................................................................................................................4
2 Tipos de Datos y Expresiones..................................................................................................5
2.1 Tipos de datos...................................................................................................................5
2.2 Expresiones.......................................................................................................................5
2.3 Operadores........................................................................................................................1
2.3.1 Operador de Asignación ............................................................................................1
2.3.2 Operadores Aritméticos.............................................................................................2
2.3.3 Operadores de incremento y decremento.................................................................2
2.3.4 Operadores Relacionales ..........................................................................................4
2.3.5 Operadores Lógicos...................................................................................................5
2.3.6 Operador Condicional................................................................................................6
3 Estructuras y Arreglos ..............................................................................................................7
3.1 Arreglo ...............................................................................................................................7
3.2 Estructura de datos...........................................................................................................8
4 Entrada y Salida .......................................................................................................................9
4.1 E/S Simples.......................................................................................................................9
4.2 Printf y Scanf...................................................................................................................10
4.3 Ficheros en c.....................................................................................................................1
4.3.1 Función Fopen: ..........................................................................................................1
4.3.2 Función fclose............................................................................................................2
4.3.3 Función Remove() .....................................................................................................3
4.3.4 Función rename.........................................................................................................4
5 Sentencias de Bifurcación........................................................................................................5
5.1 Sentencia switch...............................................................................................................7
6 Sentencias de Iteración ............................................................................................................9
6.1 Sentencias While.............................................................................................................10
6.2 Sentencia Do – While......................................................................................................11
7 Funciones y Parámetros.........................................................................................................12
7.1 Funciones Void................................................................................................................13
7.2 Parámetros......................................................................................................................14
7.3 Parámetros Estructurados ..............................................................................................15

8 Anexos......................................................................................................................................16

1 VARIABLES Y CONSTANTES
1.1 VARIABLE
Una variable se debe declarar para poder utilizarla.
Una declaración de variable asocia un tipo de datos a la variable.
Una declaración está formada por un tipo de dato seguido de uno o más nombres de
variables, finalizando con un punto y coma.
Por ejemplo:
Int unidades; //se declara una variable de tipo entero llamada unidades
Float importe, longitud; //se declaran dos variables de tipo float
Char opción; //se declara una variable de tipo char
En la propia declaración se puede hacer una asignación de valores iniciales:
Int num = 0;
Char guion = '-';
Float longitud = 6.25;

1.2 CONSTANTE
Declarar una constante supone asociar un tipo de datos y un valor a la constante.
Este valor no podrá ser modificado durante la ejecución del programa.
La declaración de constantes es similar a la de una variable, anteponiendo la palabra
reservada const.
Por ejemplo:
const double PI = 3.1416;
const int DIAS_SEMANA = 7;
const char letra_inicial = 'F';

2 TIPOS DE DATOS Y EXPRESIONES
2.1 TIPOS DE DATOS
BÁSICOS
Caracter
Entero
Punto flotante
Doble punto flotante
Lógico
(Sin valor)
C++
Char
Int
Float
Double
Boolean
Void
MODIFICADORES DE TIPO (EXTENDIDOS).
Signo
Sin signo
Largo
Corto
Signe (redundante)
Unsigne
Long
Short
2.2 EXPRESIONES
Una expresión es una combinación de operadores y operandos de cuya evaluación se
obtiene un valor. Los operandos pueden ser nombres que denoten objetos variables o
constantes, funciones, literales de cualquier tipo adecuado de acuerdo con los
operadores u otras expresiones más simples.
Las expresiones se evalúan de acuerdo con la precedencia de los operadores. Ante una
secuencia de operadores de igual precedencia, la evaluación se realiza según el orden
de escritura, de izquierda a derecha. El orden de evaluación puede modificarse usando
paréntesis.

2.3 OPERADORES
2.3.1 Operador de Asignación
El operador = asigna el valor de la expresión que se encuentra en la parte derecha a la
variable de la izquierda.
Por ejemplo:
código = 3467;
Fahrenheit = 123.456
a = b = c = 45; equivale a: a = (b = (c = 45));

2.3.2 Operadores Aritméticos
Los operadores aritméticos sirven para realizar procedimientos matemáticos básicos y
siguen las reglas algebraicas típicas de jerarquía o prioridad que especifican la
precedencia de dichas operaciones.
Considere la expresión: x + t * 2
De acuerdo con las reglas citadas, la multiplicación se realiza antes que la suma
2.3.3 Operadores de incremento y decremento
Operadores de incremento ++ y decremento – –, también llamados de incrementación y
decrementación, los cuales respectivamente suman o restan 1 a su argumento cada vez
que se aplican a una variable. Por ejemplo
 a++ es igual a a = a+1,
 int i = 10; int j; j = i++; // primero asigna 10 a j, después incrementa i en 1
Si ++ y -- son prefijos, la operación de incremento se efectúa antes que la de asignación;
si ++ y -- están de sufijos, la asignación se efectúa en primer lugar, seguida por la
incrementación o decrementación.

2.3.4 Operadores Relacionales
Los operadores como >= o == que comprueban una relación entre dos operandos se
llaman relacionales y se utilizan en expresiones de la forma:
expresión1 operador_relacional expresión2
expresión1 y expresión2 expresiones
operador_relacional un operador de la tabla
Los operadores relacionales se usan normalmente en sentencias de selección (if) o de
iteración (while, for) que sirven para comprobar una condición; mediante ellos se realizan
operaciones de igualdad, desigualdad y diferencias relativas.
Ejemplos
x < 5.75
b * b >= 5.0 * a * c
numero == 100
inicial != ´S´

2.3.5 Operadores Lógicos
Los operadores lógicos están relacionados con los relacionales ya que normalmente los
operadores que se usan son resultado de expresiones relacionales.
Los valores resultantes son cero o ristra vacía ("") y distinto de cero o ristra vacía para
falso o verdadero respectivamente.
Ejemplos:
((a*b) && (b*c))
!(x == 5)
(a > 5) && (Nombre == "Marinero")
(b> 3) || (Nombre == "Mari Sol")

2.3.6 Operador Condicional
El operador condicional ?: es ternario y devuelve un resultado que depende de la
condición comprobada, tiene asociatividad a la derecha y, al ser ternario, requiere tres
operandos; reemplaza a la sentencia if-else en algunas circunstancias y su formato es:
expresion_c ? expresion_v : expresion_f;
Ejemplo:
n1 > n2) ? n1:n2;

3 ESTRUCTURAS Y ARREGLOS
3.1 ARREGLO
Es una colección o conjunto de variables relacionadas entre sí, por el hecho de que todas
tienen el mismo nombre y son del mismo tipo.
Un arreglo es una variable capaz de guardar uno o más valores del mismo tipo. Un
arreglo consta de posiciones de memoria contiguas, para referirse a una posición en
particular o elemento dentro de un arreglo especificamos el nombre del arreglo y el
número de posición del elemento particular dentro del mismo.
- Unidimensionales (vectores)
Arreglos - Bidimensionales (matrices)
- Multidimensionales
Finita:
Todo arreglo tiene un límite, es decir, debe determinarse cuál será el número máximo de
elementos que podrán formar parte del arreglo.
Homogénea:
Todos los elementos de un arreglo son del mismo tipo o
naturaleza (todos enteros, todos booleanos, etc.-), pero nunca una
combinación de distintos tipos.
Ordenada:
Se debe determinar cuál es el primer elemento, el segundo, el tercero..... y el enésimo
elemento. Ejemplo: int x[3]={1,2,3}

3.2 ESTRUCTURA DE DATOS
Las estructuras nos permiten agrupar varios datos, que mantengan algún tipo de relación,
aunque sean de distinto tipo, permitiendo manipularlos todos juntos, usando un mismo
identificador, o cada uno por separado.
Las estructuras son llamadas también muy a menudo registros, o en inglés records.
Tienen muchos aspectos en común con los registros usados en bases de datos. Y
siguiendo la misma analogía, cada objeto de una estructura se denomina a menudo
campo, o field.
Sintaxis:
Struct [<identificador>] {
[<tipo> <nombre_objeto>[,<nombre_objeto>,...]];
} [<objeto_estructura>[,<objeto_estructura>,...];
En C++ la palabra struct es opcional en la declaración de objetos, al contrario de lo que
sucede en C, en el que es obligatorio usarla.
Ejemplo:
Struct Persona {
char Nombre[65];
char Direccion[65];
int AnyoNacimiento;
} Fulanito;

4 ENTRADAY SALIDA
4.1 E/S SIMPLES
Se refiere a las operaciones que se producen en el teclado y en la pantalla de la
computadora. En C no hay palabras claves para realizar las acciones de Entrada/Salida,
estas se hacen mediante el uso de las funciones de la biblioteca estándar (stdio.h).Para
utilizar las funciones de E / S debemos incluir en el programa el archivo de cabecera,
ejemplo: stdio.h, mediante la declaratoria:
#i nclude <stdi o.h>
Las Funciones de E/S más simples son getchar() que lee un carácter del teclado, espera
un retorno, es decir un enter y el eco aparece. Es decir la tecla presionada.
putchar(): Imprime un carácter en la pantalla, en la posición actual del cursor.
Algunas variaciones:
getche(): Aparece el Eco
getch(): No aparece el eco
estas instrucciones se encuentran en la biblioteca conio.h
ejemplo:

4.2 PRINTF Y SCANF
La función printf() (de “print” = imprimir y “f” = formato) sirve para escribir datos en el
dispositivo de salida estándar (generalmente la pantalla) con un formato determinado por
el programador. La forma general de utilizarla es la siguiente:
printf(cadena_de_formato, datos);
El prototipo de printf() se encuentra en el archivo de cabecera stdio.h
(de “std” =standard e “io” = input/output, es decir, entrada/salida; por lo tanto, “stdio” es
un acrónimo de “entrada/salida estándar”) la forma más simple de utilizar printf() es:
int a;
a = 5;
printf("%i", a);
Los códi gos de formato que se pueden uti li zar en pri ntf() son:
Código Formato Código Formato
%d un entero
%i un entero
%c un carácter
%s una cadena
%f un real
%ld un entero largo
%u decimal sin signo
%lf doble posición
%h entero corto
%o octal
%x hexadecimal
%e notación científica
%p puntero
%% imprime porcentaje

La función scanf() es, en muchos sentidos, la inversa de printf(). Puede leer desde el
dispositivo de entrada estándar (normalmente el teclado) datos de cualquier tipo delos
manejados por el compilador, convirtiéndolos al formato interno apropiado. Funciona de
manera análoga a printf(), por lo que su sintaxis es:
scanf(cadena_de_formato, datos);
El prototipo de scanf() se encuentra en el archivo de cabecera stdio.h (de “std” =standard
e “io” = input/output, es decir, entrada/salida). Ejemplo:
int a,
b;
float x;
scanf("%d", &a);scanf("%d%f", &b, &x);

4.3 FICHEROS EN C
C define la estructura de datos FILE en el fichero de cabecera stdio.h para el manejo de
ficheros. Nosotros siempre usaremos punteros a estas estructuras.
La definición de ésta estructura depende del compilador, pero en general mantienen un
campo con la posición actual de lectura/escritura, un buffer para mejorar las prestaciones
de acceso al fichero y algunos campos para uso interno.
4.3.1 Función Fopen:
Esta función sirve para abrir y crear ficheros en disco. El valor de retorno es un puntero
a una estructura FILE. Los parámetros de entrada son:
1. nombre: una cadena que contiene un nombre de fichero válido, esto depende del
sistema operativo que estemos usando. El nombre puede incluir el camino
completo.
2. modo: especifica en tipo de fichero que se abrirá o se creará y el tipo de datos que
puede contener, de texto o binarios:
 r: sólo lectura. El fichero debe existir.
 w: se abre para escritura, se crea un fichero nuevo o se sobreescribe
si ya existe.
 a: añadir, se abre para escritura, el cursor se situa al final del fichero.
Si el fichero no existe, se crea.
 r+: lectura y escritura. El fichero debe existir.
 w+: lectura y escritura, se crea un fichero nuevo o se sobreescribe
si ya existe.
 a+: añadir, lectura y escritura, el cursor se situa al final del fichero.
Si el fichero no existe, se crea.
 t: tipo texto, si no se especifica "t" ni "b", se asume por defecto que
es "t"
 b: tipo binario.
Sintaxis:
FILE *fopen(char *nombre, char *modo);
Ejemplo:
FILE *p;
p=fopen("ejemplo.txt","w");
fclose(p);

4.3.2 Función fclose
Es importante cerrar los ficheros abiertos antes de abandonar la aplicación. Esta función
sirve para eso. Cerrar un fichero almacena los datos que aún están en el buffer de
memoria, y actualiza algunos datos de la cabecera del fichero que mantiene el sistema
operativo. Además permite que otros programas puedan abrir el fichero para su uso. Muy
a menudo, los ficheros no pueden ser compartidos por varios programas.
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. El parámetro es un puntero a la
estructura FILE del fichero que queremos cerrar.
Sintaxis
int fclose(FILE *fichero);
Ejemplo:
fclose(p);

4.3.3 Función Remove()
La función remove ( ) elimina un archivo de la memoria. Por ejemplo , retirar ( "
miarchivo.txt ) ; miarchivo.txt borra de la memoria, La función remove ( ) requiere una
cadena de estilo C como un argumento Si se utiliza una variable de tipo apstring como
argumento , debe involucrar al .c_str . . ( ) para convertirlo en una variable de cadena
estándar de C ++.
Ejemplo

4.3.4 Función rename
La función de cambio de nombre () toma el nombre de un archivo como argumento , y el
nuevo nombre del archivo como un segundo argumento . Por ejemplo , cambiar el
nombre ( " myfile.dat " , " newfile.dat " ) ; cambia el nombre del archivo como myfile.dat
newfile.dat . La función de cambio de nombre ( ) también requiere argumentos de cadena
estilo C.
Ejemplo

5 SENTENCIAS DE BIFURCACIÓN
Las estructuras de programación o estructuras de control permiten tomar decisiones y
realizar un proceso repetidas veces. Son los denominados bifurcaciones y bucles. En la
mayoría de los lenguajes de programación, este tipo de estructuras son comunes en
cuanto a concepto, aunque su sintaxis varía de un lenguaje a otro.
Las bifurcaciones permiten ejecutar una de entre varias acciones en función del valor
de una expresión lógica o relacional. Se tratan de estructuras muy importantes ya que
son las encargadas de controlar el flujo de ejecución de un programa. Existen dos
bifurcaciones diferentes: if y switch.
Bifurcación if
Esta estructura permite ejecutar un conjunto de sentencias en función del valor que
tenga la expresión de comparación (se ejecuta si la expresión de comparación tiene
valor true). Tiene la forma siguiente:
if (expresiones) {
sentencias;
}
Las llaves {} sirven para agrupar en un bloque las sentencias que se han de ejecutar, y
no son necesarias si sólo hay una sentencia dentro del if.
Bifurcación if else
Análoga a la anterior, de la cual es una ampliación. Las sentencias incluidas en el else
se ejecutan en el caso de no cumplirse la expresión de comparación (false),
if (expresiones) {
sentencias1;
} else {
sentencias2;
}
Bifurcación if elseif else
Permite introducir más de una expresión de comparación. Si la primera condición no se
cumple, se compara la segunda y así sucesivamente. En el caso de que no se cumpla
ninguna de las comparaciones se ejecutan las sentencias correspondientes al else.

if (expresiones1) {
sentencias1;
} else if (expresiones2) {
sentencias2;
} else if (expresiones3) {
sentencias3;
} else {
sentencias4;
}
Ejemplo:
string password = "";
cout << "Ingrese la contrasenia: ";
cin >> password;
if(password == "myClave")
{
cout << "Contrasenia correcta. Bienvenido";
}
else
{
cout << "Contrasenia incorrecta.";
}

5.1 SENTENCIA SWITCH
Se trata de una alternativa a la bifurcación if elseif else cuando se compara la misma
expresión con distintos valores. Su forma general es la siguiente:
switch (expresion) {
case valor1: sentencias1; break;
default: sentencias7;
}
Las características más relevantes de switch son las siguientes:
1. Cada sentencia case se corresponde con un único valor de expresion. No se pueden
establecer rangos o condiciones sino que se debe comparar con valores concretos. El
ejemplo del Apartado 2.3.3.3 no se podría realizar utilizando switch.
2. Los valores no comprendidos en ninguna sentencia case se pueden gestionar en
default, que es
opcional.
3. En ausencia de break, cuando se ejecuta una sentencia case se ejecutan también
todas las case que van a continuación, hasta que se llega a un break o hasta que se
termina el switch.

Ejemplo:
cout << "Ingrese la Opción a ejecutar: ";
int opcion = 0;
cin >> opcion;
switch(opcion)
{
case 1: cout << "nUsted ha seleccionado la opcion 1";
break;
break;
break;
default: cout << "nUsted ha ingresado una opcion incorrecta";
}

6 SENTENCIAS DE ITERACIÓN
Las Sentencias de Iteración o Ciclos son estructuras de control que repiten la
ejecución de un grupo de instrucciones. Básicamente, una sentencia de iteración es
una estructura de control condicional, ya que dentro de la misma se repite la ejecución
de una o más instrucciones mientras que una a condición especifica se cumpla.
Muchas veces tenemos que repetir un número definido o indefinido de veces un grupo
de instrucciones por lo que en estos casos utilizamos este tipo de sentencias. en C++
los ciclos o bucles se construyen por medio de las sentencias for, while y do - while.
La sentencia for es útil para los casos en donde se conoce de antemano el número de
veces que una o más sentencias han de repetirse. Por otro lado, la sentencia while es
útil en aquellos casos en donde no se conoce de antemano el número de veces que
una o más sentencias se tienen que repetir.
for(contador; final; incremento)
{
Codigo a Repetir;
}
donde:
1. contador es una variable numérica
2. final es la condición que se evalúa para finalizar el ciclo (puede ser
independiente del contador)
3. incremento es el valor que se suma o resta al contador
Hay que tener en cuenta que el "for" evalúa la condición de finalización igual que el
while, es decir, mientras esta se cumpla continuaran las repeticiones. Ejemplo:
for(int i=1; i<=10; i++)
{
cout<<"Hola Mundo";
}

6.1 SENTENCIAS WHILE
Los ciclos while son también una estructura cíclica, que nos permite ejecutar una o
varias líneas de código de manera repetitiva sin necesidad de tener un valor inicial e
incluso a veces sin siquiera conocer cuándo se va a dar el valor final que esperamos,
los ciclos while, no dependen directamente de valores numéricos, sino de valores
booleanos, es decir su ejecución depende del valor de verdad de una condición dada,
verdadera o falso, nada más.
Sintaxis:
while(condicion)
{
código a Repetir
}
Ejemplo:
int numero;
cout << "Ingrese un numero ";
cin >> numero;
while(numero <= 100)
{
cin >> numero;
}

6.2 SENTENCIA DO – WHILE
La sentencia do es usada generalmente en cooperación con while para garantizar que
una o más instrucciones se ejecuten al menos una vez. Por ejemplo, en la siguiente
construcción no se ejecuta nada dentro del ciclo while, el hecho es que el contador
inicialmente vale cero y la condición para que se ejecute lo que está dentro del while
es "mientras el contador sea mayor que diez". Es evidente que a la primera evaluación
hecha por while la condición deja de cumplirse.
Ejemplo:
int numero;
do
{
cin >> numero;
}
while(numero <= 100);

7 FUNCIONES Y PARÁMETROS
Una función es un conjunto de líneas de código que realizan una tarea específica y
puede retornar un valor. Las funciones pueden tomar parámetros que modifiquen su
funcionamiento. Las funciones son utilizadas para descomponer grandes problemas en
tareas simples y para implementar operaciones que son comúnmente utilizadas
durante un programa y de esta manera reducir la cantidad de código. Cuando una
función es invocada se le pasa el control a la misma, una vez que esta finalizó con su
tarea el control es devuelto al punto desde el cual la función fue llamada.
Sintaxis:
<tipo> [clase::] <nombre> ( [Parámetros] )
{
cuerpo;
}
Ejemplo:
void suma ()
{
int a=2,b=3,n;
n=a+b;
printf("%d",n);
};

7.1 FUNCIONES VOID
Bajo ciertas circunstancias se deseará escribir funciones que no regresen valor alguno
(esto sería algo parecido a escribir procedures en Pascal) y para ello podemos declarar
a la función como void. La palabra reservada void es utilizada para declarar funciones
sin valor de retorno y también para indicar que una función específica no requiere de
parámetros. Por ejemplo, la función pausa() que se verá en seguida, no devolverá valor
alguno y la misma no requiere de parámetros.
Ejemplo:
// esta función requiere de la librería iostream
void pausa(void)
{
cout << "Por favor presione <Enter> HOLA...";
cin.get();
cin.ignore(255, 'n'); // rechazar caracteres introducidos antes de <Enter>
};

7.2 PARÁMETROS
Normalmente, las funciones operan sobre ciertos valores pasados a las mismas ya sea
como constantes literales o como variables, aunque se pueden definir funciones que
reciban parámetros. Existen dos formas en C++ de pasar parámetros a una función;
por referencia o por valor. El hecho es que si en una declaración de función se declaran
parámetros por referencia, a los mismos no se les podrá pasar valores literales ya que
las referencias apuntan a objetos (variables o funciones) residentes en la memoria; por
otro lado, si un parámetro es declarado para ser pasado por valor, el mismo puede
pasarse como una constante literal o como una variable. Los parámetros pasados por
referencia pueden ser alterados por la función que los reciba, mientras que los
parámetros pasados por valor o copia no pueden ser alterados por la función que los
recibe, es decir, la función puede manipular a su antojo al parámetro, pero ningún
cambio hecho sobre este se reflejará en el parámetro original.
Parámetros por valor
La función cuadrado() (ver arriba) es un clásico ejemplo que muestra el paso de
parámetros por valor, en ese sentido la función cuadrado() recibe una copia del
parámetro n. En la misma función se puede observar que se realiza un cálculo ( n*n ),
sin embargo el parámetro original no sufrirá cambio alguno, esto seguirá siendo cierto
aun cuando dentro de la función hubiera una instrucción parecida a n = n * n; o n*=n;.
Parámetros por referencia
Para mostrar un ejemplo del paso de parámetros por referencia, vamos a retomar el
caso de la función cuadrado, salvo que en esta ocasión cambiaremos ligeramente la
sintaxis para definir la misma.

7.3 PARÁMETROS ESTRUCTURADOS
Al igual que cualquier otro tipo los parámetros de tipo estructurado pueden pasarse por
valor o por referencia, sin embargo, podría ser que si una estructura es pasada por
valor el compilador mostrara una advertencia ( warning ) indicando que se pasado por
valor una estructura, puesto que el paso de estructuras por valor es permitido usted
puede ignorar la advertencia, pero lo mejor es pasar estructuras por referencia. Si una
estructura es pasada por valor y si esta es muy grande podría ser que se agotara la
memoria en el segmento de pila ( Stack Segment ), aparte de que la llamada a la
función sería más lenta.
Para ver un ejemplo, consideremos el caso del siguiente tipo estructurado:
struct empleado {
char nombre[32];
int edad;
char sexo;
};
Ahora, pensemos que deseamos escribir una función para imprimir variables del tipo
empleado. Así, la función puede escribirse de las tres maneras siguientes:
void ImprimeEmpleadoV( empleado e)
{
cout << "Nombre: " << e.nombre << endl;
cout << "Edad: " << e.edad << endl;
cout << "Sexo: " << e.sexo << endl;
}
// Parámetro empleado pasado por referencia
void ImprimeEmpleadoR( empleado &e )
{
cout << "Nombre: " << e.nombre << endl;
cout << "Edad: " << e.edad << endl;
cout << "Sexo: " << e.sexo << endl;
}
// Parámetro empleado pasado como puntero
void ImprimeEmpleadoP( empleado *e )
{
cout << "Nombre: " << e->nombre << endl;
cout << "Edad: " << e->edad << endl;
cout << "Sexo: " << e->sexo << endl;
}

8 ANEXOS
Ejercicios hechos en Laboratorio
#1 Ejercicio Violento
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include "violento.h"
using namespace std;
struct sRegistro registro;
void menu()
{
printf("n **** MENU PRINCIPAL ****n");
printf("n ------------------------n");
printf("nt 1. Crear Fichero n");
printf("nt 2. Insertar Datos n");
printf("nt 3. Ver Datos n");
printf("nt 4. Buscar empleado n");
printf("nt 5. Salir n");
}
void crearFichero(FILE *fichero)
{
fichero = fopen("violento","r");
if(!fichero)
{
fichero = fopen("fichero","w");
printf("n fichero creado con éxito!!!");
}
else
{
printf("n El fichero ya existe n");
}
fclose(fichero);
system("pause");
system("cls");
return;
}
void InsertarDatos(FILE *fichero)
{
fichero = fopen("violento","a+");

printf("n Digite el codigo: ");
fflush(stdin);
scanf("%d",&registro.codigo);
printf("n Digite el nombre: ");
fflush(stdin);
gets(registro.nombre);
printf("n");
printf("n Digite la edad: ");
fflush(stdin);
scanf("%d",&registro.edad);
printf("n");
printf("n Digite el sueldo: ");
fflush(stdin);
scanf("%f",&registro.sueldo);
printf("n");
fwrite(&registro, sizeof(struct sRegistro),1,fichero);
fclose(fichero);
system("pause");
system("cls");
return;
}
void verDatos(FILE *fichero)
{
//int numero=1;
if(fichero==NULL)
{
printf("n archivo violento no existe!!!");
return;
}
fread(&registro, sizeof(struct sRegistro),1,fichero);
printf("n tt Numero t Nombre t Edad t Sueldo n");
while(!feof(fichero))
{
printf("n tt %d tt %s tt %d t %.2f nn ", registro.codigo, registro.nombre,
registro.edad, registro.sueldo);
fread(&registro, sizeof(struct sRegistro),1,fichero);
//numero++;
}
fclose(fichero);
system("pause");
system("cls");
return;
}
void buscarEmp(FILE *fichero)
{

if(fichero==NULL)
{
printf("n archivo violento no existe!!!");
return;
}
struct sRegistro regl;
int codTemp =0;
printf("nDigite el codigo del empleado que desea buscar: ");
scanf("%d",&codTemp);
printf("n");
rewind(fichero);
while (!feof(fichero))
{
fread(&regl,sizeof(sRegistro),1,fichero);
if(regl,codTemp==regl.codigo)
{
printf("codEmpleado: %d n",regl.codigo);
printf("Empleado: %s n",regl.nombre);
printf("Edad: %d n",regl.edad);
printf("Sueldo: %.2f n",regl.sueldo);
printf("n");
break;
}
}
fclose(fichero);
system("pause");
system("cls");
return;
}
int main()
{
//Declaraciones
int salida =0;
FILE *fichero;
while(!salida)
{
int opc=0;
menu();
printf("nDigite su opcion: ");
scanf("%d", &opc);
switch(opc)
{
case 1: crearFichero(fichero);

break;
case 2: InsertarDatos(fichero);
break;
case 3: system("cls");
verDatos(fichero);
printf("n");
break;
case 4: buscarEmp(fichero);
break;
case 5: salida = 1;
break;
default:
printf("nEstimado user digite una opcion valida! nn");
system("pause");
system("cls");
}
}
return 0;
}
Datos.h
struct sRegistro
{
int codigo;
char nombre[25];
int edad;
float sueldo;
};
---------------------------------------------------------------------------------------------------------------------
#2 Ejercicio Violento 2
#include <cstdlib>
#include <iostream>
#include <fstream>
#include <windows.h>
#include <conio.h>
#include <string.h>
#include "stdio.h"
#define MAX 4
#define MIN 0
using namespace std;

//SISTEMA DE REGISTRO DE USUARIOS
//CONSTANTES
const char FINCAD = char(0);
const int MAXCAD = 20;
const char SP = ' ';
//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);
void verificar_contrasena(TCadena nombreFichero,Persona_R &password);
// PROGRAMA PRINCIPAL
int main()
{
Persona_R p;
Persona_R password;
char opcion;
int num;
bool fin, encontrado;
TCadena nombre_usuario_registrado;
int opcion_menu;
cout << "BIENVENIDOS A..." << endl;

cout << "----------------------------" << endl;
cout << "1. Ingresar como Usuario" << endl;
cout << "2. Registrarse" << endl;
cout << "3. Ingresar como Visitante" << endl;
cout << "4. Salir del Programa." << endl;
cout << "----------------------------nn" << endl;
cout << "Introduzca Opcion: ";
cin >> opcion_menu;
if (opcion_menu==4)
{
finalizar_programa();
}
if((opcion_menu<MIN)||(opcion_menu>MAX))
{
try
{
system("cls");
cout<<"nnt ============================n"
<<"nnt | ESTA OPCION ES INCORRECTA |n"
<<"nnt ============================n";
Sleep(1500); //SEGUNDO Y MEDIO QUE DURA
system("cls"); //LIMPIA TODO
main(); //Y VUELVE AL MENÚ
}// FIN TRY
catch(...)
{
cout << "n UN ERROR HA OCURRIDO " << endl;
}
}
switch(opcion_menu)
{
case 1:
{
cout << "nDigite su Nombre de Usuario: ";//INGRESAR COMO USUARIO
cin >> nombre_usuario_registrado;
verificar_existencia_fichero(nombre_usuario_registrado);
//confirmar_PASS(password);
verificar_contrasena(nombre_usuario_registrado,password);
Sleep(1000);borrar_pantalla();main();
break;
}
case 2:
{
cout << "nEscriba su Nuevo Nombre de Usuario: ";//REGISTRO
cin >> nombre_usuario_registrado;
verificar_existencia_de_usuario(nombre_usuario_registrado);

Ingresar_PASS(p);
insertarPersonaTXT(nombre_usuario_registrado,p);
Sleep(1000);borrar_pantalla();main();
break;
}
case 3:
{
cout << "nHOLA VISITANTE !!!... n"; // Ingresar como visitante
Sleep(1500); borrar_pantalla();main();
break;
}
}
return 0;
}
// IMPLEMENTACIÓN DE PROCEDIMIENTOS Y FUNCIONES
void finalizar_programa()
{
borrar_pantalla();
printf("El Programa CERRARA en Cualquier Momento"); Sleep(3000);
exit(0);
}
void pausa()
{
system("PAUSE");
}
void borrar_pantalla()
{
system("CLS");
}
void Ingresar_PASS(Persona_R &p)
{
cout << "Escriba su Nuevo PASS: " ;
cin >> p.PASS;
cout<<"nSE HA REGISTRADO CORRECTAMENTE"<<endl; Sleep(2500);
}
void confirmar_PASS(Persona_R &password)
{
cout << "Escriba su PASS: " ;
cin >> password.PASS;
}
// Algoritmos de Manejo de Ficheros de Texto
void insertarPersonaTXT(TCadena nombreFichero, Persona_R p)

{
ofstream out;
out.open(nombreFichero,ios::app);
// Abro el fichero para añadir
if (out.bad())
{
// El fichero no existe ... lo creo
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<<"nNombre de Usuario INCORRECTO.....INTENTELO DE
NUEVOn"<<endl; Sleep(2500); borrar_pantalla();main();
}
else
{
cout<<"nNombre de Usuario CORRECTO..!!!n"<<endl;Sleep(2500);
}
}
void verificar_existencia_de_usuario(TCadena nombreFichero)
{
ifstream archivo(nombreFichero);
if (!archivo)
{
cout<<"nNombre de Usuario DISPONIBLEn"<<endl;Sleep(2500);
}
else
{
cout<<"n Este Nombre de Usuario ya Existe.....INTENTELO DE NUEVO"<<endl;
Sleep(2500); borrar_pantalla();main();
}
}
void verificar_contrasena(TCadena nombreFichero,Persona_R &password)
{
string cadena;

string contrase;
cout << "Escriba su PASS: " ;
cin >> password.PASS;
ifstream fichero(nombreFichero,ios::in);
while(!fichero.eof())
{
fichero >> cadena;
//cadena = strstr (fichero,"simple");
}
if(cadena!=password.PASS)
{
cout<<"n PASS es INCORRECTO.....INTENTELO DE NUEVOn"<<endl;
Sleep(2000);
fichero.close();
}
if(cadena==password.PASS)
{
cout<<"n Su PASS es CORRECTA..!!! n"<<endl;
Sleep(2500);
cout<<"n BIENVENIDO..!!! n"<<endl;
Sleep(2500);
}
}

Manual C/C++

Más contenido relacionado

La actualidad más candente

Destacado

Similar a Manual C/C++

Más de Estudiantes ISI_UCA

Último

Manual C/C++