manual c/c++
TRANSCRIPT
6-6-2016
Manual de Programación en C/C++
Prof.: Ing. Elsner Boanerge González Ortega
Jimmy PradoUniVersidad centroamericana “UCA”
TABLA DE CONTENIDO
1 Variables y Constantes....................................................................................................................2
1.1 Variable......................................................................................................................................2
1.2 Constante...................................................................................................................................3
2 Tipos de Datos y Expresiones........................................................................................................4
2.1 Tipos de datos...........................................................................................................................4
2.2 Expresiones...............................................................................................................................4
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 unidadesFloat importe, longitud; //se declaran dos variables de tipo floatChar 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 flotanteDoble punto flotanteLógico(Sin valor)
C++
CharIntFloatDoubleBooleanVoid
MODIFICADORES DE TIPO (EXTENDIDOS).
SignoSin signoLargoCorto
Signe (redundante)UnsigneLongShort
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ón2expresió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.75b * b >= 5.0 * a * cnumero == 100inicial != ´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 onaturaleza (todos enteros, todos booleanos, etc.-), pero nunca unacombinació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 ENTRADA Y 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:
# inc lude <s td io .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 Ecogetch(): 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ód igos de fo rmato que se pueden u t i l i za r en p r in t f ( ) 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;case valor2: sentencias2; break;case valor3: sentencias3; break;case valor4: sentencias4; break;case valor5: sentencias5; break;case valor6: sentencias6; 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 esopcional.
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; case 2: cout << "\nUsted ha seleccionado la opcion 2"; break; case 3: cout << "\nUsted ha seleccionado la opcion 3"; 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érica2. 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)
{
cout << "Ingrese un numero ";
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{
cout << "Ingrese un numero ";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 iostreamvoid 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 referenciavoid ImprimeEmpleadoR( empleado &e ){
cout << "Nombre: " << e.nombre << endl;cout << "Edad: " << e.edad << endl;cout << "Sexo: " << e.sexo << endl;
}
// Parámetro empleado pasado como punterovoid 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("\n\t 1. Crear Fichero \n"); printf("\n\t 2. Insertar Datos \n"); printf("\n\t 3. Ver Datos \n"); printf("\n\t 4. Buscar empleado \n"); printf("\n\t 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",®istro.codigo); printf("\n Digite el nombre: "); fflush(stdin); gets(registro.nombre); printf("\n"); printf("\n Digite la edad: "); fflush(stdin); scanf("%d",®istro.edad); printf("\n"); printf("\n Digite el sueldo: "); fflush(stdin); scanf("%f",®istro.sueldo); printf("\n");
fwrite(®istro, sizeof(struct sRegistro),1,fichero); fclose(fichero); system("pause"); system("cls"); return; }
void verDatos(FILE *fichero) {
//int numero=1; fichero = fopen("violento","r"); if(fichero==NULL) { printf("\n archivo violento no existe!!!"); return; } fread(®istro, sizeof(struct sRegistro),1,fichero); printf("\n \t\t Numero \t Nombre \t Edad \t Sueldo \n"); while(!feof(fichero)) { printf("\n \t\t %d \t\t %s \t\t %d \t %.2f \n\n ", registro.codigo, registro.nombre, registro.edad, registro.sueldo); fread(®istro, sizeof(struct sRegistro),1,fichero); //numero++; } fclose(fichero); system("pause"); system("cls"); return; }
void buscarEmp(FILE *fichero) { fichero = fopen("violento","r"); 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(®l,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! \n\n"); 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
//CONSTANTESconst char FINCAD = char(0);const int MAXCAD = 20;
const char SP = ' ';
//variableschar contrasena;int i;int contador=0;
//TIPOStypedef char TCadena[MAXCAD+1]; // MAXCAD caracteres + FINCAD
//Estructurastruct Persona_R{ TCadena PASS;};
// CABECERA DE PROCEDIMIENTOS Y FUNCIONESvoid 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 Textovoid 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 PRINCIPALint 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 << "----------------------------\n\n" << endl; cout << "Introduzca Opcion: "; cin >> opcion_menu;
if (opcion_menu==4) { finalizar_programa(); }
if((opcion_menu<MIN)||(opcion_menu>MAX)) { try { system("cls"); cout<<"\n\n\t ============================\n" <<"\n\n\t | ESTA OPCION ES INCORRECTA |\n" <<"\n\n\t ============================\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 FUNCIONESvoid 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 Textovoid 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 NUEVO\n"<<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 DISPONIBLE\n"<<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 NUEVO\n"<<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); }}