Permite:
|
|||
Ejemplo: Agenda telefónica
Solución:
Los algoritmos deben guardar los nombres y números telefónicos de tus contactos
a) Entrada: Grabar en una ficha de un archivo cada Nombre y Número telefónico.
b) Borrar una ficha del archivo permanente los datos.
c) Salida: Mostrar en pantalla los datos de la agenda
Graficando este proceso:
Inicio | v |---------<----------- | | ====Display==== | | Contacto: | ---------- | 1-Nuevo | Ejecutar | 2-Borrar | la opción | 3-Ver | elegida | Elige Opción| ---------- ================ | | | v | | | /\ | / \ | /Hay \ | opcion ---Si-->---------- \ / \ / \/ | No | v Fin
Ejemplo: Agenda telefónica
Solución:
Codifiquemos el algoritmo anterior en lenguaje C: Con este fin:
- Ejecuta paso a paso las indicaciones siguientes y aún NO te preocupes por entender esta codificación.
- Solo mira como luce un programa codificado en "C".
- Mas adelante te describiré detalladamente cada parte de estos algoritmos.
using System; using System.IO; namespace Agenda { public class Clase { char resp; string salida = ""; public Clase() { } private void menu() { Clase C = new Clase(); do { salida = "NO"; Console.Clear(); Console.WriteLine("==== AGENDA de WILO ======"); Console.WriteLine("* *"); Console.WriteLine("* 1) NUEVO contacto *"); Console.WriteLine("* 2) BORRAR contacto *"); Console.WriteLine("* 3) VER mis contactos *"); Console.WriteLine("* 4) Salir *"); Console.WriteLine("* *"); Console.WriteLine("==========================="); ConsoleKeyInfo info = Console.ReadKey(true); resp = info.KeyChar; switch (resp) { case '1': C.Agregar(); break; case '2': C.Eliminar(0); break; case '3': C.Eliminar(1); break; case '4': salida = "SI"; break; default: Console.WriteLine("\nOpción incorrecta"); break; } } while (salida != "SI"); } private void Agregar() { Console.Clear(); string lectura = ""; string nombre = ""; string tel = ""; Console.WriteLine("Nombre:"); nombre = Console.ReadLine(); Console.WriteLine("Teléfono:"); tel = Console.ReadLine(); StreamReader lector = new StreamReader("Agenda.txt"); StreamWriter escritor = new StreamWriter("AgendaBACK.txt"); while ((lectura = lector.ReadLine()) != null) { escritor.WriteLine(lectura); } lector.Close(); escritor.WriteLine(nombre); escritor.WriteLine(tel); escritor.Close(); File.Delete("Agenda.txt"); File.Copy("AgendaBACK.txt", "Agenda.txt"); File.Delete("AgendaBACK.txt"); } private void Eliminar(int num) { if (num == 0) { Console.Clear(); StreamReader lector = new StreamReader("Agenda.txt"); string lectura = ""; string busqueda = ""; while ((lectura = lector.ReadLine()) != null) { Console.WriteLine(lectura); lectura = lector.ReadLine(); Console.WriteLine(lectura); Console.WriteLine("************"); } lector.Close(); Console.WriteLine("Digita nombre del contacto a borrar"); busqueda = Console.ReadLine(); lector = new StreamReader("Agenda.txt"); StreamWriter escritorback = new StreamWriter("AgendaBACK.txt"); while ((lectura = lector.ReadLine()) != null) { if (lectura == busqueda) { lector.ReadLine(); } else { escritorback.WriteLine(lectura); } } escritorback.Close(); lector.Close(); File.Delete("Agenda.txt"); File.Copy("AgendaBACK.txt", "Agenda.txt"); File.Delete("AgendaBACK.txt"); } else { Console.Clear(); StreamReader lector = new StreamReader("Agenda.txt"); string lectura = ""; while ((lectura = lector.ReadLine()) != null) { Console.WriteLine(lectura); lectura = lector.ReadLine(); Console.WriteLine(lectura); Console.WriteLine("****************************"); } lector.Close(); Console.WriteLine("'Enter' para ir al menú principal"); Console.ReadLine(); } } static void Main() { if (!File.Exists("Agenda.txt")) { StreamWriter escritor = new StreamWriter("Agenda.txt"); escritor.Close(); } Clase C = new Clase(); C.menu(); } } }
1.- Ingresa a Microsoft Visual Studio.Net, luego Clickea
- - | Start | , | Programs | , | Microsoft Visual Studio .NET | Microsoft Visual Studio .NET.
2.- Dentro de Microsoft Visual Studio.NET: | menú File | New | y | Project |
- - Aparece la ventana de diálogo New Project.
- - Dentro de Project Types, selecciona la carpeta Visual C++ Projects.
- - Dentro de Templates Seleccionar Win32 Project para abrir el asistente.
- - En la caja de texto Name escribe el nombre del proyecto “MiAgenda” Presionar luego OK.
3.- Define la configuración de tu aplicación y selecciona Console application como tipo de aplicación.
- - Seleccionar Empty project (proyecto en blanco) como opción adicional.
4.- Click en Finish para cerrar el asistente.
2.1.- En el menú View, selecciona Solution Explorer.
2.2.- En Project, selecciona Add New Item. | En ventana Templates: C++File(.cpp) | En caja texto Name: escribe “agenda”.
2.3.- Copia con el mause la codificación anterior, luego pega en el editor y graba. ( Se guarda como agenda.cpp )
Esta agenda telefónica te permite:
1.- GRABAR tus contatos:
- Nombre
- Telefono
2.- BORRAR un contacto
3.- VER tus contactos
|
||
DATOS
:1.- DATO SIMPLE
2.- DATO ESTRUCTURADO
A.- ESTRUCTURAS DE SELECCION
a.- SELECCIÓN SIMPLE:
La estructura If Else opera asi:
| / \ --<- Condi ->-- If (Condi) | \ / | { ------ ------ Opc 1 Opc 1 Opc 2 } ------ ------ else | | { ---->--------<--- Opc 2 | } V Ejemplo: if (lectura == busqueda) { lector.ReadLine(); } else { escritorback.WriteLine(lectura); }
b.- SELECCIÓN MULTIPLE:
SELECCIÓN IF ELSE IF, selección es típica en C y permite efectuar varias comparaciones sucesivas
| / \ Cond1 -->- If (Cond1) \ / | { | ------ Opci 1 V Opci 1 } | ------ else If (Cond2) | | { / \ V Opci 2 Cond2 -->-| } \ / | | ------ V Opci 2 | ------ | V |---<---- Ejemplo: If ( equivalencia == yardas) Valor = largo / 3; else if ( equivalencia == pulgadas) Valor = largo * 12; else if ( equivalencia == metros) Valor = ( largo * 12 * 2.54 ) / 100; else prinf ( "termina la conversión.!!";
c.- SELECCIÓN MULTIPLE SWITCH:
Permite una entre múltiples opciones mediante una variable "Selector"
que puede tomar distintos valores Constante1, Constante2, hasta ConstanteN, o puede direccionar acción/es por defecto.
Con break hace que se ignore la parte restante de la instrucción switch.
si se omite break el programa continuaría en operando las acciones de default. Ejemplo:
switch (resp) { case '1': C.Agregar(); break; case '2': C.Eliminar(0); break; case '3': C.Eliminar(1); break; case '4': salida = "SI"; break; default: Console.WriteLine("\nOpción incorrecta"); break; }
B.- ESTRUCTURAS DE ITERACION
Repeticiones o iteraciones o ciclos donde uno o grupo de instrucciones se repiten mientras se cumpla la condición de continuidad.
Se usa bloques FOR, WHILE y DO WHILE y la cantidad de iteraciones se controla por:
- Validación de la expresión booleana planteada en una condición.
- Condiciones de error que alteran el bucle tal como "break" o "exit" y "continue".
for ( Contador = 1; Contador = 10; Contador = Contador + 1 )
printf("%d\n", 5," x ",Contador, " = ", 5 * Contador );
También, podemos lograr el mismo resultado con
for ( Contador = 1; Contador = 50; Contador ++ )
printf ( " %d \ n ", 5 , " x " , Contador, " = ", 5 * Contador )
- 2.a.- CICLO WHILE:
El número de bucles comienza en cero, luego puede no efectuarse ninguna acción operativo. Ejemplo:
| |----<--- V | | --------- while (Condi) | Operacion { | --------- Operacion | | } / \ | Condi ->-- \ / | V Ejemplo: while ((lectura = lector.ReadLine()) != null) { Console.WriteLine(lectura); lectura = lector.ReadLine(); Console.WriteLine(lectura); Console.WriteLine("*****************"); }
- 2.b.- CICLO DO WHILE:
El número de bucles comienza en uno; luego al menos se efectuará un ciclo operativo. Ejemplo:
| |----<--- V | --------- | do Operacion | { --------- | Operacion | | } / \ | while (Condi) Condi ->-- \ / | V Ejemplo: do { Opcion=VerMenu(); LeyDeOhm(Opcion); } while ( ( Opcion != 's' ) && ( Opcion != 'S' ) );
- Texto: char
OPERADORES
- Entero: int
- Flotante: float
- Doble precisión: double
- Enumarado: enum
- Sin valor: void
- Puntero:
Son instrucciones codificadas para generar acciones para producir efectos determinados. Dentro de ellos los más comununes son:
- Desplazamiento izquierdo: << Mueve los bits hacia la izquierda. Ejemplo Valor<<=1; cout << Valor
- Desplazamiento derecho: >> Mueve los bits hacia la derecha. Ejemplo Valor>>=1; prinf("%d",Valor)
- Incremento: Valor = Valor + 1 equivale a Valor++; o también ++Valor;
- Decremento: Valor = Valor - 1 equivale a Valor-; o también -Valor;
- Aritméticos: Suma(+); resta(-); multiplicación(*); división(/) y módulo(%) Este último es el resto de la división de los enteros.
- Asignación: Simple (=) ejemplo: Valor = Valor + Incremento;
- Compuesto: el ejemplo anterior se puede escribir como: Valor + = Incremento.
- Relacionales: Igual(==), distinto(¡=), mayor(>), menor(<), mayor o igual (>=), menor o igual (<=).
- Lógicos: And ( && ), OR ( || ), NOT ( ¡ )
BIBLIOTECA ESTANDAR
Evita la reiteración de escribir siempre las mismas rutinas. Definen:
- Iostream.h Rutinas básicas de flujo de entrada y salida
- Fstream.h Flujos que soportan entrada y salida de archivos.
- Graphics.h Prototipos para las funciones gráficas
- Stdio.h Rutinas básicas de flujo de entrada y salida
INGRESO Y SALIDA de datos
Opera los datos como flujos o secuencias o "stream" de bytes, usando tres tipos de funciones:
- 1- Entrada salida orientadas a Flujo:
Tanto los datos simples como los archivos de datos son procesados como un flujo de caracteres individuales,
Cuando el programa usa una función de flujo para abrir un archivo de E/S, este se asocia con la estructura de tipo FILE,
predefinida por la función "stdio.h" que posee la información básica del archivo.
- 2- Entrada salida orientadas a Consola y puerto:
Permiten escribir en una terminal, o una consola, o en un puerto de entrada o salida como la impresora.
En todos estos casos la información llega como un flujo de bytes.
- 3- Entrada salida orientadas a Bajo nivel:
Funciones que usan capacidades directas del sistema operativo, ninguna de estas usan memoria intermedia, ni formateo.
Acceden a archivos o dispositivos periféricos a nivel más básico que el usado por las funciones de flujo,
devuelven un valor entero, como identificador para referirse a tal archivo en acciones posteriores.
|
||
Dato estructurado constituido por un conjunto de datos individuales e iguales en tamaño llamados "elementos", los cuales son de naturaleza homogénea, tales como datos tipo caracteres, reales, punteros, estructuras y otros, ordenados en forma vectorial, por lo que poseen índices.
En C++ el índice del primer elemento es cero y el nombre es un "identificador constante" que representa la dirección del primer elemento. Los arrays multidimensionales, pueden llegar a tener 3 índices. Ejemplo:
///////////////////////////////////////////// // Manejo de matrices ///////////////////////////////////////////// #include < stdio.h> #include < conio.h> #include < iostream.h> void main() { int i,j,n,m; int matriz[30][30]; clrscr();//limpio la pantalla cout << " \n \ t \ t Wilo Carpio: C++ MATRICES NUMERICAS \ n \ n "; cout << " \t INDICA LOS DATOS DE LA MATRIZ: A(n,m) \ n"; cout << "Nro de Filas de la matriz: n = ";cin >> n; cout << "Nro de Columnas de la matriz: m = ";cin >> m; ///////////////////////////////////////////// // Carga del valor de cada elemento ///////////////////////////////////////////// cout << "\n\t DIGITA EL VALOR DE CADA ELEMENTO \n"; for(i=1;i<=n;i++) { cout << "Fila " << i << "\n"; for(j=1;j<=m;j++) { cout << "A( " << i << " , " << j << ") = ";cin >> matriz[i][j]; } } ///////////////////////////////////////////// // Mostrar por pantalla los datos cargados ///////////////////////////////////////////// cout << "\n\t ELEMENTOS DE LA MATRIZ CARGADA \n"; for(i=1;i<=n;i++) { for(j=1;j <= m;j++) { cout<<"A(" << i << "," << j << ")=" << matriz[i][j] << " | " ; } cout<<"\n"; } getch();//espera que presione una tecla }
Una función es un subprograma que puede tener o carecer de parámetros, pero que siempre devuelve un dato.
Para activar una función, se debe declarar la estructura de su prototipo.
//////////////////////////////////////////////////// // FUNCION VerMenu: Visualiza opciones operativas //////////////////////////////////////////////////// char VerMenu() { // Declaración de variables locales char Opcion='S'; // Menú de opciones cout << "\n\t ELIGE OPCION: V Calculo de Voltage \n"; cout << "\t\t\t C Calculo de Corriente \n"; cout << "\t\t\t R Calculo de Resistencia \n"; cout << "\t\t\t S Salir \n"; cin >> Opcion; return Opcion; } // Fin de la función VerMenu //////////////////////////////////////////////////// // FUNCION PARA SELECCIONAR EL CALCULO DE OHM //////////////////////////////////////////////////// void LeyDeOhm(char Opcion) { switch(Opcion) // Selector múltiple { case'V': cout << "\n TENSION = Corriente * Resistencia = " << CalculaTension() << " Volts \n"; break; case'C': cout << "\n CORRIENTE = Tension * Resistencia = " << CalculaCorriente() << " Amper \n"; break; case'R': cout << "\n RESISTENCIA = Tension / Corriente = " << CalculaResistencia() << " Ohm \n"; break; case'S': cout << "\n CHAU..!! SE FINI..!! \n"; break; default: cout << "\n Caca nene..!! /n"; } // Fin del selector switch } // Fin de la función LeyDeOhm
|
||
La "Clase", permite tener como miembros indistintamente:
- Datos y funciones,
- Partes públicas, privadas y protegidas,
- Formatos de "Datos Asociados" en forma de "Datos Miembro" y
- "Funciones Asociadas" en forma de "Funciones Miembro".
Abarca la utilización de:
- Clases
- Objetos
- Eventos
- Métodos
- Atributos
- Encapsulamiento
- Herencia
Estos aspectos simplifican la tarea heurística del diseño, análisis y desarrollo de software de componentes individuales y reutilizables.
QUE ES UNA CLASE:
Ente intangible de características y comportamiento propios, que permite corporizar elementos tangibles objetos, operables por instrucciones de un programa.
La clase como abstracción del objeto contiene información sobre las especificaciones de apariencia y comportamiento del objeto.
El objeto, con un mensaje, es requerido para un servicio, concretado sin que el usuario sepa cómo fué efectuado, pues, su acción es interna y la gestiona el suministrador del objeto.
Dado que la clase es una especie de molde para moldear los objetos de tu programa, será necesario que definas su estructura sintáctica:
class NombreDeLaClase { public: /////////////////////////////////////////////////////////// // Declaración de prototipos de funciones miembro públicas // que pueden ser usadas fuera de la clase //////////////////////////////////////////////////////////// NombreDeLaClase(); // Función Constructor TipoDatoDevuelto NombreDeLaFuncion (Tipo Parametro, ...);// Prototipo de función miembro ........... ; private: /////////////////////////////////////////////////////////// // Declaración de datos miembro privadas // que pueden ser usadas dentro de la clase //////////////////////////////////////////////////////////// TipoDeDato NombreDelDato; ........... ; }; // Fin Clase
Clase: FUNCIÓN MIEMBRO:
La clase es una estructura compleja integrada por datos y funciones o respectivamente de "Datos Miembro" y "Funciones Miembro",
los cuales pueden ser de alcance privado o público. Ejemplo:
///////////////////////////////////////////// // C++ MANEJO DE UNA CLASE // clascaca.cpp Wilo Carpio 2/05/94 ///////////////////////////////////////////// #include < iostream.h> #include < conio.h> void Tecla(); ///////////////////////////////////////////// // DEFINICIONES DE CLASES ///////////////////////////////////////////// class ClaseRotulo { public: ClaseRotulo(); // Constructor void VerRotulo(); ~ClaseRotulo(); // Destructor }; class MiCirculo { public: MiCirculo( int r ); void MostrarArea(); ~MiCirculo( ); private: float CalcularArea(int r); int Radio; int Color; };
///////////////////////////////////////////// // DEFINICIONES DE CONSTRUCTORES // Y DESTRUCTORES DE CLASES ///////////////////////////////////////////// ClaseRotulo::ClaseRotulo() { } ClaseRotulo::~ClaseRotulo() { } MiCirculo :: MiCirculo ( int r ) { Radio = r; }; MiCirculo :: ~MiCirculo ( ) { }; ///////////////////////////////////////////// // DEFINICIONES O ESTRUCTURACIONES DE // FUNCIONES ASOCIADAS A LAS CLASES ///////////////////////////////////////////// void ClaseRotulo::VerRotulo() { clrscr(); cout << "\n C++ clasemia.cpp Wilo Carpio\n\n"; cout << " EJEMPLO TIPO DE USO DE CLASES\n"; cout << "\n\n\t Area del c¡rculo"; cout << "\n\t================\n"; }; void MiCirculo :: MostrarArea () { cout << "\n Para radio = "<< Radio << " Area Circulo = 3.1416 x "<< Radio << " x " << Radio << " = " << CalcularArea(Radio); Tecla(); }; float MiCirculo :: CalcularArea (int Radio) { float supCirculo; supCirculo=(float)(3.1416*Radio*Radio); return supCirculo; }; void Tecla() { cout<<"\n\n\t Tecla para continuar..";getch(); };
Te propongo algunos modelos sencillos para operar clases declaradas precedentemente
///////////////////////////////////////////// // FUNCION PRINCIPAL ///////////////////////////////////////////// void main () { int MiRadio; ClaseRotulo Rotulo; // Crea objeto de clase ClaseRotulo Rotulo.VerRotulo(); // Visualiza el rotulo cout << "\n\t Radio = ";cin >> MiRadio; MiCirculo UnCirculo (MiRadio); UnCirculo . MostrarArea ( ); }
Clase: APLICACIÓN:
Si aún las clases te suenan a chino básico, creo que conviene que te simplifiques la vida y copies textualmente con el editor de C++ el código que te propongo, luego lo compiles y listo, ya estarás manejando las clases..!!
Luego solo restará que hagas un esfuerzo analítico para comprender la sintaxis y la semántica utilizada en este pequeño ejemplo, diseñado para probar la aplicabilidad de las clases.
///////////////////////////////////////////// // C++ MANEJO DE UNA CLASE // clascaca.cpp Wilo Carpio 2/05/94 ///////////////////////////////////////////// #include < iostream.h> #include < conio.h> void Tecla(); ///////////////////////////////////////////// // DEFINICIONES DE CLASES ///////////////////////////////////////////// class ClaseRotulo { public: ClaseRotulo(); // Constructor void VerRotulo(); ~ClaseRotulo(); // Destructor }; class MiCirculo { public: MiCirculo( int r ); void MostrarArea(); ~MiCirculo( ); private: float CalcularArea(int r); int Radio; int Color; }; ///////////////////////////////////////////// // DEFINICIONES DE CONSTRUCTORES // Y DESTRUCTORES DE CLASES ///////////////////////////////////////////// ClaseRotulo::ClaseRotulo() { } ClaseRotulo::~ClaseRotulo() { } MiCirculo :: MiCirculo ( int r ) { Radio = r; }; MiCirculo :: ~MiCirculo ( ) { }; ///////////////////////////////////////////// // DEFINICIONES O ESTRUCTURACIONES DE // FUNCIONES ASOCIADAS A LAS CLASES ///////////////////////////////////////////// void ClaseRotulo::VerRotulo() { clrscr(); cout << "\n C++ clasemia.cpp Wilo Carpio\n\n"; cout << " EJEMPLO TIPO DE USO DE CLASES\n"; cout << "\n\n\t Area del c¡rculo"; cout << "\n\t================\n"; }; void MiCirculo :: MostrarArea () { cout << "\n Para radio = " << Radio << " Area Circulo = 3.1416 x " << Radio << " x " << Radio << " = " << CalcularArea(Radio); Tecla(); }; float MiCirculo :: CalcularArea (int Radio) { float supCirculo; supCirculo=(float)(3.1416*Radio*Radio); return supCirculo; }; void Tecla() { cout << " \n\n\t Tecla para continuar..";getch(); }; ///////////////////////////////////////////// // FUNCION PRINCIPAL ///////////////////////////////////////////// void main () { int MiRadio; ClaseRotulo Rotulo; // Crea objeto de clase ClaseRotulo Rotulo.VerRotulo(); // Visualiza el rotulo cout << " \n\t Radio = ";cin >> MiRadio; MiCirculo UnCirculo (MiRadio); UnCirculo . MostrarArea ( ); }Así: La clase es un ente intangible dotado de características y comportamiento propios, que permite corporizar uno o más elementos tangibles llamados objetos, los cuales son entes reales y operables mediante instrucciones de un programa.
La clase, como abstracción del objeto contiene información sobre las especificaciones de apariencia y comportamiento del objeto.
La clase es como el plano del objeto; así, podemos decir que la clase es el plano de conexiones eléctricas internas del teclado,
mientras que el objeto es el propio teclado..!!
El objeto, mediante un mensaje adecuado, es requerido para realizar un servicio, el cual es concretado sin que el usuario se entere cómo fué efectuado, porque su acción es interna y la gestiona el suministrador del objeto.
Dado que la clase es una especie de molde para moldear los objetos de tu programa, será necesario que definas su estructura y para ello en C++ puedes usar la siguiente estructura:
class NombreDeLaClase { public: /////////////////////////////////////////////////////////// // Declaración de prototipos de funciones miembro públicas // que pueden ser usadas fuera de la clase //////////////////////////////////////////////////////////// NombreDeLaClase(); // Función Constructor TipoDatoDevuelto NombreDeLaFuncion (Tipo Parametro, ...); // Prototipo de función miembro ........... ; private: /////////////////////////////////////////////////////////// // Declaración de datos miembro privadas // que pueden ser usadas dentro de la clase //////////////////////////////////////////////////////////// TipoDeDato NombreDelDato; ........... ; }; // Fin Clase
Luego de esta declaración ya puedes ampliar tu concepto de clase, afirmando que se trata de una estructura compleja integrada por datos y funciones que reciben el nombre respectivamente de "Datos Miembro" y "Funciones Miembro", los cuales pueden ser de alcance privado o público. Ejemplo:
///////////////////////////////////////////// // C++ MANEJO DE UNA CLASE // clascaca.cpp Wilo Carpio 2/05/94 ///////////////////////////////////////////// #include#include void Tecla(); ///////////////////////////////////////////// // DEFINICIONES DE CLASES ///////////////////////////////////////////// class ClaseRotulo { public: ClaseRotulo(); // Constructor void VerRotulo(); ~ClaseRotulo(); // Destructor }; class MiCirculo { public: MiCirculo( int r ); void MostrarArea(); ~MiCirculo( ); private: float CalcularArea(int r); int Radio; int Color; };
Luego te propongo algunos modelos sencillos para definir las FUNCIONES MIEMBROS de las clases declaradas precedentemente.
Observa la estructura sintáctica del constructor y del destructor que poseen el mismo identificador que la clase.
Definicion de las Funciones Miembro
///////////////////////////////////////////// // DEFINICIONES DE CONSTRUCTORES // Y DESTRUCTORES DE CLASES ///////////////////////////////////////////// ClaseRotulo::ClaseRotulo() { } ClaseRotulo::~ClaseRotulo() { } MiCirculo :: MiCirculo ( int r ) { Radio = r; }; MiCirculo :: ~MiCirculo ( ) { }; ///////////////////////////////////////////// // DEFINICIONES O ESTRUCTURACIONES DE // FUNCIONES ASOCIADAS A LAS CLASES ///////////////////////////////////////////// void ClaseRotulo::VerRotulo() { clrscr(); cout << "\n C++ clasemia.cpp Wilo Carpio\n\n"; cout << " EJEMPLO TIPO DE USO DE CLASES\n"; cout << "\n\n\t Area del c¡rculo"; cout << "\n\t================\n"; }; void MiCirculo :: MostrarArea () { cout << "\n Para radio = "<< Radio << " Area Circulo = 3.1416 x "<< Radio << " x " << Radio << " = " << CalcularArea(Radio); Tecla(); }; float MiCirculo :: CalcularArea (int Radio) { float supCirculo; supCirculo=(float)(3.1416*Radio*Radio); return supCirculo; }; void Tecla() { cout<<"\n\n\t Tecla para continuar..";getch(); };
Ahora te propongo algunos modelos sencillos para operar clases declaradas precedentemente
///////////////////////////////////////////// // FUNCION PRINCIPAL ///////////////////////////////////////////// void main () { int MiRadio; };
PARECIDO DISTINTO..???:
Verás que este link es el mismo que el anterior pero planteado de otra manera, aunque ambos generan los mismos resultados.
Ocurre que la Programación Orientada a Objetos, te permite aprovechar la ventaja de encapsulamiento y herencia, que podrás apreciar en el siguiente ejemplo:
Para captar la diferencia es imprescindible que previamente compiles el programa del link anterior; luego recién, compila esta segunda propuesta, siguiendo las indicaciones que encontrarás en cada caso.
GENERACION DEL ARCHIVO CABECERA
Edita textualmente la estructura de los siguientes algoritmos sintácticos, que corresponden al archivo cabecera que utilizaremos en el segundo paso.
///////////////////////////////////////////// // C++ Wilo Carpio // DECLARACION DE LA CLASE // Las funciones miembro estan // definidas en claswilo.cpp ///////////////////////////////////////////// // Permite una sola inclusi¢n del archivo de encabezado #ifndef MICIRCULO1_H #define MICIRCULO1_H ///////////////////////////////////////////// // DEFINICION DEL TIPO DE DATOS // ABSTRACTO MiCirculo ///////////////////////////////////////////// class MiCirculo { public: MiCirculo( int r ); void MostrarArea(); ~MiCirculo( ); private: float CalcularArea(int r); int Radio; int Color; }; #endif }
Ojito..!!! dentro del mismo directorio donde te encuentras trabajando APLICACION DEL ARCHIVO CABECERA ANTERIOR
GRABA HASTA AQUI COMO: claswil2.h
Ahora prepárate para el segundo paso
En el editor de tu C++, solo compila los siguientes algoritmos y podrás verificar que es exáctamente el mismo programa del
link anterior.
Analiza cuidadosamente la manera cómo se produjo la separación del entorno de la clase, respecto de su aplicación.
Nota que la definición de las funciones miembro no han cambiado.
///////////////////////////////////////////// // C++ MANEJO DE UNA CLASE CON // SEPARACION DE ENTORNO // claswilo.cpp Wilo Carpio 2/05/94 // claswil2.h ///////////////////////////////////////////// #include#include #include"claswil2.h" // Archivo cabecera que contiene la clase MiCirculo void Tecla(); ///////////////////////////////////////////// // DEFINICIONES DE CLASES ///////////////////////////////////////////// class ClaseRotulo { public: ClaseRotulo(); // Constructor void VerRotulo(); ~ClaseRotulo(); // Destructor }; ///////////////////////////////////////////// // DEFINICIONES DE CONSTRUCTORES // Y DESTRUCTORES DE CLASES ///////////////////////////////////////////// ClaseRotulo::ClaseRotulo() { } ClaseRotulo::~ClaseRotulo() { } MiCirculo :: MiCirculo ( int r ) { Radio = r; }; MiCirculo :: ~MiCirculo ( ) { }; ///////////////////////////////////////////// // DEFINICIONES O ESTRUCTURACIONES DE // FUNCIONES ASOCIADAS A LAS CLASES ///////////////////////////////////////////// void ClaseRotulo::VerRotulo() { clrscr(); cout << "\n C++ claswil1.cpp Wilo Carpio\n\n"; cout << " EJEMPLO TIPO DE USO DE CLASES\n"; cout << "\n\n\t Area del c¡rculo"; cout << "\n\t================\n"; }; void MiCirculo :: MostrarArea () { cout << "\n Para radio = " << Radio << " Area Circulo = 3.1416 x " << Radio << " x " << Radio << " = " << CalcularArea(Radio); Tecla(); }; float MiCirculo :: CalcularArea (int Radio) { float supCirculo; supCirculo=(float)(3.1416*Radio*Radio); return supCirculo; }; void Tecla() { cout<<"\n\n\t Tecla para continuar..";getch(); }; ///////////////////////////////////////////// // FUNCION PRINCIPAL ///////////////////////////////////////////// void main () { int MiRadio; ClaseRotulo Rotulo; // Crea objeto de clase ClaseRotulo Rotulo.VerRotulo(); // Visualiza el rotulo cout<<"\n\t Radio = ";cin >> MiRadio; MiCirculo UnCirculo (MiRadio); UnCirculo . MostrarArea ( ); }
Si eres un estudiante, comprobarás que la tecnología procedural es historia pasada que era muy complicada, laboriosa y de menor calidad que la POO ... por ello no te quedes en el tiempo, aprende amanejar las clases..!!
C++.NET: Abarca tecnologías de bloques de estructuras tipo armazón o Framework como soporte de trabajo, de la infraestructura de la plataforma ".NET", sobre la cual convergen herramientas y servicios para desarrollar sistemas en lenguajes, C#.NET, J#.NET, Jscript, Visual Basic.NET, C++.NET y más.
Visual C++ proporciona bibliotecas que ayudan a escribir código para las aplicaciones,
incluyendo la biblioteca ATL (Active Template Library, un conjunto de clases de C++ basadas en plantillas para objetos COM),
Servidor Active Template Library (un conjunto de clases de C++ nativo para crear aplicaciones Web, servicios Web y otras aplicaciones
de servidor) y Microsoft Foundation Classes (un conjunto de clases compatibles con aplicaciones escritas para la API de Windows).
Extensiones administradas de C++:
Crear una nueva aplicación o componente, puedes utilizar tus conocimientos actuales de C++ para escribir código administrado con las extensiones administradas de C++. Cuando utilizas las extensiones administradas, obtienes los beneficios de la compatibilidad y de los servicios que proporciona Common Language Runtime (como la administración de memoria, integración entre lenguajes, seguridad de acceso a código y control automático de la vida de los objetos).
Ejemplo:
Start , Programs, Microsoft Visual Studio .NET y Clic en Microsoft Visual Studio .NET.
Aparece la ventana de diálogo New Project.
Dentro de Project Types, selecciona la carpeta Visual C++ Projects.
Dentro de Templates Selecciona Win32 Project para abrir el asistente.
En la caja de texto Name escribe el nombre del proyecto “bienvenida” Presionar luego OK.
/////////////////////////////////////////// // saludo1.cpp Wilo Carpio // proyecto en C++.NET de Visual studio.Net /////////////////////////////////////////// #include "stdafx.h" #using < mscorlib.dll> using namespace System; int _tmain() { printf("!BIENVENIDO A VISUAL STUDIO .NET (Wilo Carpio)!"); Console::ReadLine(); return 0; }
. !BIENVENIDO A VISUAL STUDIO .NET (Wilo Carpio)! .
|
Las primeras líneas del código ‘saludo1.cpp’ corresponde al comentario que se hace del programa.
El símbolo // le indica al compilador que ignore esas líneas.
/////////////////////////////////////////// // saludo1.cpp Wilo Carpio // proyecto en C++.NET de Visual studio.Net ///////////////////////////////////////////
Las líneas siguientes son instrucciones del preprocesador.
#include "stdafx.h" #using < mscorlib.dll> using namespace System;
La función _tmain( ) indica donde comienza la ejecución del programa y finaliza con return.
int _tmain() { printf("!BIENVENIDO A VISUAL STUDIO .NET (Wilo Carpio)!"); Console::ReadLine(); return 0; }
APLICACIONES DE CONSOLA
Los métodos de la clase "Console" que son del tipo "Shared" usados tanto como para mostrar información por el monitor o para capturar datos del usuario, no requieren de la creación de objetos a partir de la clase para invocar sus métodos; solo es necesario indicar la clase seguido de un punto y del metodo tal como:
using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace MiPrimeraVez { class Program { static void Main(string[] args) { } } }
using System; namespace MiPrimeraVez { ////// APLICACION DE CONSOLA CON C# /// Proyecto: MiPrimeraVez Wilo Carpio /// class Primera_aplicacion { ////// The main entry point for the application. /// [STAThread] static void Main(string[] args) { string x="n"; // TODO: Add code to start application here // System.Console.WriteLine("MI PRIMERA VEZ CON C# (Wilo Carpio)\n"); System.Console.WriteLine("MULTIPLICACION \n\n"); System.Console.WriteLine("Ingresa tu nombre"); string f=System.Console.ReadLine(); System.Console.WriteLine("\n Hola " + f+ ", para hacer una Multiplicacion digita el valor del: \n"); do { //System.Console.WriteLine("Hola {0}, vamos a hacer una multiplicaion",f); System.Console.WriteLine("Multiplicando: A = "); int a = Convert.ToInt32(System.Console.ReadLine()); System.Console.WriteLine("Multiplicador: B = "); int b = Convert.ToInt32(System.Console.ReadLine()); //int c = a*b; //System.Console.WriteLine("Producto:entre{0}, y el numero{1}, es {2} ",a ,b,c); System.Console.WriteLine("Producto: A x B = " + a*b); System.Console.WriteLine("\n \n Otro calculo ? (s/n)"); x=System.Console.ReadLine(); // System.Console.ReadLine(); } while (x=="s");} } }
Así compilamos este proyecto de C#, cuya ejecución mostrará en el monitor el siguiente contenido:
MI PRIMERA VEZ EN C# (Wilo Carpio) .
Multiplicaciones .
Ingresa tu nombre .
|
MI PRIMERA VEZ EN C# (Wilo Carpio) .
Multiplicaciones .
Ingresa tu nombre .
Multiplicando = .
|
Aplica el siguiente proceso:
/////////////////////////////////////////////////////////// // C# PROGRAMA CONSOLA MODELO BASE 2006 Wilo Carpio // Manejo de estructuras simples 230806 // Control de datos sin archivo // Clases y Vectores /////////////////////////////////////////////////////////// using System; using System.Runtime.InteropServices; namespace ModeloBase2006 { public class ClaseWilo { [STAThread] ////////////////////////////////////////////////// // FUNCION PRINCIPAL ////////////////////////////////////////////////// static void Main(string[] args) { MiClaseMenu ClaseMenu = new MiClaseMenu(); string ClienteNombre; string[] NombreyPrecioDelProducto = new String[50]; string[] NombreDelProducto = new String[50]; double[] PrecioDelProducto = new double[50]; string[] NominaDeClientes = new String[50]; string[,] Articulo = new string[20, 20]; int TotalComprasRealizadas = 0, OpcionPrincipal, ClienteNumero = 0; double MontoEnCaja = 0; Console.BackgroundColor = ConsoleColor.Yellow; Console.Clear(); ClaseMenu.MarcoDobleConTitulo("\t SOFTWARE LOCO");
do { OpcionPrincipal = ClaseMenu.OpcionMenuPrincipal(); switch (OpcionPrincipal) { ////////////////////////////////////////////////// // OPCION DE VENTAS ////////////////////////////////////////////////// case 1: int Indice = -1; double SubTotalCaja = 0; do { MenuVentas: Console.Clear(); MatrizProductos(Articulo); switch (VerMatriz(Articulo, "\n\t\t PRODUCTOS DISPONIBLES")) { case 1: Indice++; NombreDelProducto[Indice] = Articulo[1, 1]; PrecioDelProducto[Indice] = Convert.ToDouble(Articulo[1, 2]); NombreyPrecioDelProducto[Indice] = "\t" + Articulo[1, 1] + "\t $" + Articulo[1, 2]; break; case 2: Indice++; NombreDelProducto[Indice] = Articulo[2, 1]; PrecioDelProducto[Indice] = Convert.ToDouble(Articulo[2, 2]); NombreyPrecioDelProducto[Indice] = "\t" + Articulo[2, 1] + "\t $" + Articulo[2, 2]; break; case 3: Indice++; NombreDelProducto[Indice] = Articulo[3, 1]; PrecioDelProducto[Indice] = Convert.ToDouble(Articulo[3, 2]); NombreyPrecioDelProducto[Indice] = "\t" + Articulo[3, 1] + "\t $" + Articulo[3, 2]; break; case 4: Indice++; NombreDelProducto[Indice] = Articulo[4, 1]; PrecioDelProducto[Indice] = Convert.ToDouble(Articulo[4, 2]); NombreyPrecioDelProducto[Indice] = "\t" + Articulo[4, 1] + "\t $" + Articulo[4, 2]; break; default: Aguarda("METISTE MAL EL DEDO."); goto MenuVentas; } TotalComprasRealizadas = TotalComprasRealizadas + 1; SubTotalCaja = SubTotalCaja + PrecioDelProducto[Indice]; } while (OtraVez("Queres comprar otro producto")); MontoEnCaja = MontoEnCaja + SubTotalCaja; ClienteNumero = ClienteNumero + 1; ClienteNombre = LeerNombreCliente(); NominaDeClientes[ClienteNumero] = "\t" + ClienteNombre + "\t $" + SubTotalCaja / 100; ImprimeTicket(ClienteNombre, NombreyPrecioDelProducto, Indice, SubTotalCaja); break; ////////////////////////////////////////////////// // OPCION REPORTE TOTAL ////////////////////////////////////////////////// case 2: VerReporteDelDia(NominaDeClientes, ClienteNumero, MontoEnCaja); break; ////////////////////////////////////////////////// // OPCION ARTICULOS COMPRADOS ////////////////////////////////////////////////// case 3: VerProductosComprados(NombreDelProducto, TotalComprasRealizadas); break; ////////////////////////////////////////////////// // OPCION ACERCA DE ////////////////////////////////////////////////// case 4: Console.Clear(); ClaseMenu.MarcoDobleConTitulo("\twww.wilocarpio.com"); Aguarda(" Visual Studio 2005 \n" + " Autor: Wilo Carpio "); break; ////////////////////////////////////////////////// // SALIR DEL PROGRAMA ////////////////////////////////////////////////// case 5: Aguarda("CERRARAS EL PROGRAMA.."); break; default: Aguarda(OpcionPrincipal + " METISTE MAL EL DEDO"); break; } } while (OpcionPrincipal != 5); } ////////////////////////////////////////////////// // MIEMBROS DE LA CLASE ////////////////////////////////////////////////// static void TrazarRayaSimple(int TotalRayitas) { int i; Console.ForegroundColor = ConsoleColor.Red; for (i = 1; i <= TotalRayitas; i++) Console.Write("─"); Console.ForegroundColor = ConsoleColor.DarkBlue; } static bool OtraVez(string Pregunta) { bool Respuesta = false; string Opcion; Console.Write("\n\t" + Pregunta + "? (s/n)"); Opcion = Console.ReadLine(); if ((Opcion == "s") || (Opcion == "S")) Respuesta = true; return Respuesta; } static void Aguarda(string Mensaje) { Console.Write("\n "); Console.BackgroundColor = ConsoleColor.Red; Console.ForegroundColor = ConsoleColor.Yellow; Console.Write(" " + Mensaje + "..!!\n"); Console.BackgroundColor = ConsoleColor.Yellow; Console.Write(" "); Console.BackgroundColor = ConsoleColor.Red; Console.ForegroundColor = ConsoleColor.White; Console.Write(" ENTER para seguir "); Console.BackgroundColor = ConsoleColor.Yellow; Console.ForegroundColor = ConsoleColor.DarkBlue; Console.ReadLine(); } static string LeerNombreCliente() { string nomCliente; TrazarRayaSimple(78); Console.Write("\n Nombre del cliente: "); nomCliente = Console.ReadLine(); return nomCliente; }
static void MatrizProductos(string[,] Articulo) { Articulo[1, 1] = "Sistema Ventas y Facturación Win 1.0"; Articulo[1, 2] = "300.00"; Articulo[2, 1] = "Soft de Administración de Personal"; Articulo[2, 2] = "200.00"; Articulo[3, 1] = "Sistema Liquidación de Impuestos"; Articulo[3, 2] = "250.00"; Articulo[4, 1] = "Soft de Control de Compras y Stock"; Articulo[4, 2] = "300.00"; } static void RotuloAzul(string TextoDelRotulo) { Console.ForegroundColor = ConsoleColor.White; Console.Write(" "); Console.BackgroundColor = ConsoleColor.Blue; Console.Write(TextoDelRotulo + "\n"); Console.BackgroundColor = ConsoleColor.Yellow; Console.ForegroundColor = ConsoleColor.DarkBlue; } static int VerMatriz(string[,] MatrizDeDatos, string Titulo) { MiClaseMenu ClaseMenu = new MiClaseMenu(); int i; ClaseMenu.MarcoDobleConTitulo(Titulo); RotuloAzul(" Art Precio Denominacion "); for (i = 1; i <= 4; i++) Console.WriteLine("\t {0}{1}{2}{3}{4}", i, "\t", MatrizDeDatos[i, 2], "\t", MatrizDeDatos[i, 1]); TrazarRayaSimple(78); Console.Write("\n\t ¿Qué producto deseas comprar?: "); int Opcion = Convert.ToInt32(System.Console.ReadLine()); return Opcion; } static void ImprimeTicket(string NombreCliente, string[] NombreyPrecioDelProducto, int iMax, double subTotal) { MiClaseMenu ClaseMenu = new MiClaseMenu(); ClaseMenu.MarcoDobleConTitulo("\n TICKET - " + " Sr/Sra: " + NombreCliente + "\t" + DateTime.Now); TrazarRayaSimple(78); Console.WriteLine(""); RotuloAzul(" Art Denominacion Precio "); for (int j = 0; j <= iMax; j++) Console.WriteLine("\t" + (j + 1) + NombreyPrecioDelProducto[j]); Console.WriteLine("\n\t\t\t\t\t TOTAL : $" + subTotal / 100); TrazarRayaSimple(78); Aguarda("Gracias por tu compra"); } static void VerReporteDelDia(string[] Cliente, int TotalClientes, double MontoEnCaja) { MiClaseMenu ClaseMenu = new MiClaseMenu(); ClaseMenu.MarcoDobleConTitulo("\n\n REPORTE DÍA " + DateTime.Now); TrazarRayaSimple(78); Console.WriteLine("\n Nomina de Clientes: " + TotalClientes); RotuloAzul(" Cliente Compra $ "); for (int NroCliente = 0; NroCliente <= TotalClientes; NroCliente++) Console.WriteLine("\t" + Cliente[NroCliente]); Console.WriteLine("\n Recaudación : $" + MontoEnCaja / 100 + "\n"); TrazarRayaSimple(78); Aguarda("No hay mas ventas"); } static void VerProductosComprados(string[] ProductoComprado, int TotalCompras) { MiClaseMenu ClaseMenu = new MiClaseMenu(); ClaseMenu.MarcoDobleConTitulo("\n\n NOMINA PRODUCTOS VENDIDOS DÍA " + DateTime.Now); TrazarRayaSimple(78); RotuloAzul(" Articulo comprado Compra $ "); for (int NroCompra = 0; NroCompra <= TotalCompras; NroCompra++) Console.WriteLine("\t" + ProductoComprado[NroCompra]); TrazarRayaSimple(78); Aguarda("Esto es todo lo vendido"); } }
/////////////////////////////////////////////////////////////// // OTRA CLASE /////////////////////////////////////////////////////////////// public class MiClaseMenu { public void MarcoDobleConTitulo(string Mensaje) { int i; Console.BackgroundColor = ConsoleColor.Yellow; Console.Clear(); Console.Write("\n"); Console.ForegroundColor = ConsoleColor.Yellow; Console.Write(" "); Console.BackgroundColor = ConsoleColor.DarkYellow; Console.Write("╔"); for (i = 1; i <= 34; i++) Console.Write("═"); Console.WriteLine("╗"); Console.BackgroundColor = ConsoleColor.Yellow; Console.Write(" "); Console.BackgroundColor = ConsoleColor.DarkYellow; Console.Write("║"); Console.ForegroundColor = ConsoleColor.White; Console.Write(" C#: MODELO BASICO SIMPLE 2006 "); Console.ForegroundColor = ConsoleColor.Yellow; Console.Write("║"); Console.WriteLine(); Console.BackgroundColor = ConsoleColor.Yellow; Console.Write(" "); Console.BackgroundColor = ConsoleColor.DarkYellow; Console.Write("║"); Console.ForegroundColor = ConsoleColor.Yellow; Console.Write(" WILUCHA 1.0 "); Console.ForegroundColor = ConsoleColor.Yellow; Console.Write("║"); Console.WriteLine(); Console.BackgroundColor = ConsoleColor.Yellow; Console.Write(" "); Console.BackgroundColor = ConsoleColor.DarkYellow; Console.Write("╚"); for (i = 1; i <= 34; i++) Console.Write("═"); Console.Write("╝"); Console.BackgroundColor = ConsoleColor.Yellow; Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine("\t\t\t\t\t\t" + Mensaje); Console.ForegroundColor = ConsoleColor.White; }
public int OpcionMenuPrincipal() { MarcoDobleConTitulo(""); int i; Console.BackgroundColor = ConsoleColor.Yellow; Console.Write(" "); Console.ForegroundColor = ConsoleColor.Yellow; Console.BackgroundColor = ConsoleColor.DarkGreen; Console.Write("╔"); for (i = 1; i <= 34; i++) Console.Write("═"); Console.WriteLine("╗"); Console.BackgroundColor = ConsoleColor.DarkGreen; Console.BackgroundColor = ConsoleColor.Yellow; Console.Write(" "); Console.BackgroundColor = ConsoleColor.DarkGreen; Console.Write("║"); Console.ForegroundColor = ConsoleColor.Red; Console.Write(" M E N U "); Console.ForegroundColor = ConsoleColor.Yellow; Console.Write("║"); Console.WriteLine(); Console.BackgroundColor = ConsoleColor.Yellow; Console.Write(" "); Console.BackgroundColor = ConsoleColor.DarkGreen; Console.Write("╠"); for (i = 1; i <= 34; i++) Console.Write("═"); Console.WriteLine("╣"); Console.BackgroundColor = ConsoleColor.Yellow; Console.Write(" "); Console.BackgroundColor = ConsoleColor.DarkGreen; Console.Write("║"); Console.ForegroundColor = ConsoleColor.Yellow; Console.Write(" 1 → OPERACION DE VENTAS "); Separacion(); Console.Write(" 2 → REPORTE TOTAL VENTAS "); Separacion(); Console.Write(" 3 → VER ARTICULOS VENDIDOS "); Separacion(); Console.Write(" 4 → Acerca de.. "); Separacion(); Console.Write(" "); Separacion(); Console.Write(" 5 → SALIR "); Console.ForegroundColor = ConsoleColor.Yellow; Console.Write("║"); Console.WriteLine(); Console.BackgroundColor = ConsoleColor.Yellow; Console.Write(" "); Console.BackgroundColor = ConsoleColor.DarkGreen; Console.Write("╚"); for (i = 1; i <= 34; i++) Console.Write("═"); Console.Write("╝"); Console.BackgroundColor = ConsoleColor.Yellow; Console.ForegroundColor = ConsoleColor.Red; Console.Write("\n\n\t Digita opción (Luego ENTER): "); int OpcionElegida = Convert.ToInt32(Console.ReadLine()); return OpcionElegida; } public void Separacion() { Console.ForegroundColor = ConsoleColor.Yellow; Console.Write("║"); Console.WriteLine(); Console.BackgroundColor = ConsoleColor.Yellow; Console.BackgroundColor = ConsoleColor.Yellow; Console.Write(" "); Console.BackgroundColor = ConsoleColor.DarkGreen; Console.Write("║"); Console.ForegroundColor = ConsoleColor.Yellow; } } /////////////////////////////////////////////////////////////// // Fin del programa /////////////////////////////////////////////////////////////// }
EJEMPLO 2 DE MATRICES
using System; namespace Matriz { class Class1 { [STAThread] static void Main() { int I,J,n,m,May,Men,IMayor,JMayor,Ran,IMenor,JMenor,SF,SC; int[]V; V = new int [100]; int[,] A = new int[10,10]; Console.WriteLine("================================================="); Console.WriteLine("\t MATRICES C# Wilo Carpio 2006"); Console.WriteLine("================================================="); Console.WriteLine("\n CARGA LA MATRIZ"); Console.WriteLine(" Digita la cantidad de:"); Console.Write("\n Filas = "); n=Int32.Parse(Console.ReadLine()); Console.Write(" Columnas = "); m=Int32.Parse(Console.ReadLine()); //////////////////////////////// // Carga de la matriz //////////////////////////////// for(I=1; I<=n; I++) { Console.WriteLine("\n Fila["+I+"]"); for(J=1; J<=m;J++) { Console.Write(" A("+I+","+J+")= "); A[I,J]=Int32.Parse(Console.ReadLine()); } } //////////////////////////////// // Mostrar la matriz //////////////////////////////// Console.WriteLine("\n MATRIZ CARGADA:"); for(I=1; I<=n; I++) { for(J=1; J<=m;J++) { Console.Write(A[I,J]); Console.Write(" "); } Console.WriteLine("\n"); } //////////////////////////////// // Calculos de la matriz //////////////////////////////// May=A[1,1]; Men=A[1,1]; for(I=1;I<=n;I++) { for(J=1;J<=m;J++) { if(A[I,J]>May) { May=A[I,J]; IMayor=I; JMayor=J; } if(A[I,J]< Men) { Men=A[I,J]; IMenor=I; JMenor=J; } } } Ran=May-Men; Console.WriteLine("Rango = "+Ran); Console.WriteLine("SUMA de los elementos de las filas"); for(I=1;I<=n;I++) { SF=0; for(J=1;J<=m;J++) { SF=A[I,J]+SF; } Console.WriteLine("Fila" +I+ "="+SF); } Console.WriteLine("SUMA de los elementos de las Columnas"); for(J=1;J<=n;J++) { SC=0; for(I=1;I<=m;I++) { SC=A[I,J]+SC; } Console.WriteLine("Columna"+J+"="+SC); } Console.ReadLine(); } } }
EJEMPLO: VECTORES
using System; namespace MiVector { class Class1 { [STAThread] static void Main(string[] args) { int[]Vector; Vector = new int [100]; int Valor,TotalElementos, Aux, Posmin, j; int Indice=1; int Suma, Mayor, Esta; Suma=0; Console.WriteLine(" OPERACIONES CON VECTORES \n"); Console.WriteLine("Cuantos elementos tiene tu vector?:"); TotalElementos = Convert.ToInt32(Console.ReadLine()); while(Indice <= TotalElementos) { Console.WriteLine("Digita el valor: Vector["+Indice+"]= "); Valor = Convert.ToInt32(Console.ReadLine()); Vector[Indice]=Valor; Suma = Suma + Vector[Indice]; Indice=Indice+1; } Console.WriteLine("\n ELEMENTOS DEL VECTOR"); Mayor=Vector[1]; Esta=0; for(Indice=1; Indice <= TotalElementos; Indice++) { Console.WriteLine("Vector["+Indice+"]="+Vector[Indice]); if (Vector[Indice] > Mayor) { Mayor=Vector[Indice]; Esta=Indice; } } Console.WriteLine("La suma de los elementos es:"+Suma); Console.WriteLine("El mayor es Vector["+(Esta)+"]="+(Mayor)); Console.WriteLine("Vector ordenado:"); for(Indice=1; Indice<=TotalElementos;Indice++) { Posmin=Indice; for(j=Indice;j<=TotalElementos;j++) if (Vector[j]< Vector[Posmin]) Posmin=j; Aux=Vector[Indice]; Vector[Indice]=Vector[Posmin]; Vector[Posmin]=Aux; } for(Indice=1;Indice<=TotalElementos;Indice++) Console.WriteLine("Vector ["+Indice+"] =" +Vector[Indice]); Console.ReadLine(); } } }
Las variables dinámicas llamadas punteros, constituyen la herramienta más potente de los lenguajes C, C++, C++Builder y Visual C++. Permiten operar las estructuras de datos dinámicas tipo listas, pilas, colas, árboles y grafos.
Iniciaremos el manejo de las estructuras de datos como entidades dinámicas, pues verás que mientras se ejecuta el programa que lo comanda, ellas cambian de tamaño de manera de ajustarse a las necesidades de memoria requeridas en cada momento.
Lo anterior significa la optimización de la administración de la memoria operativa de la máquina, porque la estructura dinámica se ajusta automáticamente a la cantidad de datos a procesar.
Los apuntadores llamados también punteros son variables dinámicas cuyo contenido es la dirección del casillero de la pila de memoria donde se almacena un valor. Como cualquier variable, los punteros deben ser préviamente declarados inicializados aplicando la siguiente sintaxis
int *MiPuntero; // Declaro un puntero que apunta a una variable numérica entera
int *QuePuntero;
int *MiPuntero, QuePuntero; // esta equivale a las dos anteriores
char *TuPuntero
float *SuPuntero
Por declaración
Por instrucción de asignación: El cero es el único valor entero que se puede asignar directamente y equivale a inicializarse con NULL para indicar que no apunta a ningún casillero de la pila de memoria
& OPERADOR DE DIRECCION:
Es unario y devuelve la dirección de su operando.
Ejemplo: MiPuntero = &UnValor; //asigna a MiPuntero la dirección de la variable UnValor
* OPERADOR DE INDERECCION:
o de desrefenciación: Devuelve el alias o sinónimo del objeto hacia el que
apunta el puntero.
Ejemplo: cout << * MiPuntero; // visualiza el valor de la variable MiPuntero
*MiPuntero = 69; // Asigna el valor 69 a la variable MiPuntero
cin >> *MiPuntero; // Espera que por teclado se asigne un valor a la variable MiPuntero
Los operadores & y * son de efecto inverso entre ellos cuando se aplican a una variable puntero, por ello los siguientes ejemplos producen el mismo efecto:
& * MiPuntero;
* & Mi Puntero;
En el siguiente ejemplo podras apreciar las declaraciones y algunos algoritmos para que inicies tus práctica.
Te recomiendo que veas cómo se usan los operadores de dirección & y el operador de indirección *
///////////////////////////////////// // Wilo Carpio 5/4/95 // MANEJO DE PUNTEROS C++ ///////////////////////////////////// #include iostream.h> int main() { //////////////////////////// // Declaración del puntero //////////////////////////// int *aPuntero; // Asi declaro una variable puntero int MiVariable; // Asi declaro una variable numérica entera MiVariable = 7; // Asi asigno un valor a la variable aPuntero = &MiVariable; // Asi asigno la dirección de la variable MiVariable ////////////////////////////////////////////// // Visualización de la dirección de memoria ////////////////////////////////////////////// cout<<"La dirección de MiVariable es "<<& MiVariable ////////////////////////////////////////////// // Visualización del contenido de la dirección // de memoria que es apuntada por el puntero ////////////////////////////////////////////// <<"\n el valor de aPuntero es " << aPuntero; /////////////////////////////////////////////////// // Visualización mostrando el efecto inverso que // producen los operadores // & de dirección // * de indirección /////////////////////////////////////////////////// cout << " \n Mostrando que * y & son operadores inversos entre si " << " \n & * aPuntero = " << & * aPuntero << " \n * & aPuntero = " << * & aPuntero << end1; return (0); }
////////////////////////////////// // Wilo Carpio 5/5/95 // Llamado de función por valor ////////////////////////////////// #include iostream.h > int SuperfieCuadrado(int); // Prototipo int main() { int Lado = 10; cout<<"La longitud del lado = " << Lado; Superficie = SuperfieCuadrado(Lado) cout<<"\n La superfie del cuadrado es " << Superficie << end1; return 0; } ///////////////////////////// // Función Superficie ///////////////////////////// int SuperfieCuadrado(int UnLado); { return UnLado * UnLado; // Opera sobre la variable local UnLado }
La enema si no cura, entretiene..!!
/////////////////////////////////////// // Wilo Carpio 5/5/95 // Llamado de función por referencia /////////////////////////////////////// #include iostream.h > void SuperfieCuadrado(int*); // Prototipo int main() { int Lado = 10; cout<<"La longitud del lado = " << Lado; SuperfieCuadrado(&Lado); cout<<"\n La superfie del cuadrado es " << Lado << end1; return 0; } ///////////////////////////// // Función Superficie ///////////////////////////// int SuperfieCuadrado(int *MiPuntero); { *MiPuntero = *MiPuntero * *MiPuntero; // Opera sobre el número del main }
PUNTEROS:
Para declarar un tipo puntero se indica el tipo de valor que se almacenarán en la posicion designada por el puntero, porque los diferentes tipos de
datos requieren diferentes cantidades de memoria para almacenar sus constantes, una variable puntero puede contener una dirección
de una posición de memoria adecuada sólo para un tipo dado.
Así, se dice que cada puntero apunta a una variable particular, es decir, a otra posición de memoria.
Dado que el puntero es una variable que registra la dirección de otra variable almacenada en una celda de memoria, es preciso diferenciar entre las dos entidades implicadas en el apuntamiento:
Se puede declarar un puntero a una variable carácter, a un arreglo de enteros, a un registro o a cualquier otro tipo de dato e incluso a otro puntero.
C++, Usa el asterisco (*) que sigue a los nodos, para indicar que "apunta a"; es decir el tipo de dato es una variable puntero que puede contener una dirección a un tipo de dato llamado nodo. Ej. MiNodo *nuevo;
La lista enlazada es una secuencia de nodos enlazados o conectados con el siguiente formando una estructura de datos dinámica. Tales nodos suelen ser normalmente registros y que no tienen un tamaño fijo.
La ventaja de una lista enlazada sobre un arreglo es que la lista enlazada puede crecer y decrecer en tamaño y que fácil insertar o suprimir un nodo en el centro de una lista enlazada. Por ello la lista enlazada es uno de los más utilizados en gestión de proyectos de software.
La lista enlazada es una estructura muy versátil, cuyos algoritmos para inserción y eliminación de datos constan de dos pasos:
ESTRUCTURA de LISTAS:
Una lista se usa para almacenar información del mismo tipo, de modo que puede contener un número indeterminado de elementos, los cuales mantienen un orden explícito, pues contiene en sí mismo la dirección del siguiente elemento.En cada nodo podemos considerar que hay dos campos, campo de información (INFO) y campo de enlace (ENLACE) o dirección del elemento siguiente.
El campo de dirección, a partir del cual se accede a un nodo de la lista, se llama puntero. A una lista enlazada se accede desde un puntero externo que contiene la dirección (referencia) del primer nodo de la lista. El campo de dirección o enlace del último elemento de la lista no debe de apuntar a ningún elemento, no debe de tener ninguna dirección, por lo que contiene un valor especial denominado nulo (en Pascal o Delphi : nil, en C , C++ y Builder C: NULL).
A la lista de cero elementos se la llama lista vacía y es aquella que no tiene nodos, tiene el puntero externo de acceso a la lista apuntando a nulo.
Las inserciones se pueden realizar por cualquier punto de la lista. Así pueden realizarse inserciones por el comienzo de la lista, por el final de la lista, a partir o antes
de un nodo determinado. Las eliminaciones también se pueden realizar en cualquier punto de la lista, aunque generalmente se hacen dando el campo de información que se
desea eliminar.
MANEJANDO LISTAS:
Utilizan variables puntero que permiten crear variables dinámicas, que almacenan el campo de información y el campo de enlace al siguiente nodo de la lista.
Cada vez que sea necesario crear un nuevo nodo, la memoria ocupada por éste se devuelve a la pila de memoria libre. El proceso es dinámico, la lista crece o decrece según las necesidades.
Cuando se quiere acceder a un nodo hay que recorrer la lista, a través de los enlaces hasta alcanzar su dirección y tener en cuenta que cada nodo ocupa la memoria adicional del campo de enlace.
El tipo de variable puntero es aquella cuyo contenido va a ser la dirección de memoria de un dato. Las variables puntero, al igual que las variables enteras o reales, son variables estáticas, ya que se crean o reserva memoria para ellas en tiempo de compilación.
Especificación Formal de la Lista Simple:
Matemáticamente, una lista es una secuencia de cero o más elementos de un determinado tipo, ordenados de forma lineal.
(a1, a2, a3, ..., an) donde n >= 0 si n = 0 la lista es vacía.
Listas Simples: Tienen dos campos:
- Uno de información
- Uno de enlace que apunta al siguiente nodo.
Además de los típicos datos int, float, char y long, C++ nos permite declarar nuestros propios tipos de datos personalizados, aplicando para ello la correspondiente declaración de estructuras, tal como puedes apreciar en el siguiente ejemplo:
////////////////////////////////////////////////////////////// // VARIABLE DINAMICA WILO CARPIO // LISTA SIMPLE 12/5/1998 // Funciona OK: C++Borland // Visual C++: // File/New/Projects/win32ConsoleAplicatión: // Asignar nombre del proyecto y el Path // File/New/Files/C++SourceFile: Asignar Nombre al programa ////////////////////////////////////////////////////////////// #include < iostream.h > #include < stdlib.h > ///////////////////////////////////// // PROTOTIPOS DE LAS FUNCIONES //////////////////////////////////// int MenuOpciones(); char CerrarPrograma(); void LaListaEstaVacia(); //////////////////////////////////////////////////// // ESTRUCTURA DEL NODO A USAR //////////////////////////////////////////////////// typedef struct PunteroDeNodo { int Legajo; //-----------------------Campo llave float Edad; char Nombre[15]; struct PunteroDeNodo *ProximoNodo; //---Campo enlace }MiNodo; //////////////////////////////////// // VARIABLES GLOBALES //////////////////////////////////// int MiOpcion; char Si_No, Salir; MiNodo *NodoDeLaLista, *NodoAnterior, *NuevoNodoaInsertar, *NodoAuxiliar, *PunteroDelNodo;
Insertando nuevos nodos:
Listas Simples:
- La inserción de nuevos se realiza al final de la lista.
- El último nodo ingresado apunta siempre a NULL o nil.
/////////////////////////////////////////////////////// // INSERTANDO UN NODO CUANDO LA LISTA NO ESTA VACIA /////////////////////////////////////////////////////// void InsertarNodoAuxiliar(MiNodo *NodoPuntero) { int EsUltimoNodo; //--------------------------------------------- // Si el legajo actual es menor que el anterior, // el nuevo nodo se inserta antes //--------------------------------------------- if (NuevoNodoaInsertar->Legajo < NodoAnterior->Legajo ) { NuevoNodoaInsertar->ProximoNodo = NodoDeLaLista; NodoAnterior = NuevoNodoaInsertar; NodoDeLaLista = NuevoNodoaInsertar; } else //--------caso Contrario---------------- { NodoAuxiliar = NodoAnterior; // Se copia nodo anterior NodoAuxiliar EsUltimoNodo = false; //----------------------------------------------- // Ciclo buscando el último nodo de NodoAuxiliar // para direccionar el NodoPuntero //----------------------------------------------- do { PunteroDelNodo = NodoAuxiliar; NodoAuxiliar = NodoAuxiliar->ProximoNodo; if (NodoAuxiliar == NULL) EsUltimoNodo = true; else if (NodoAuxiliar->Legajo > NuevoNodoaInsertar->Legajo) EsUltimoNodo = true; } while (!EsUltimoNodo); //-----------------------------------------Fin de ciclo PunteroDelNodo->ProximoNodo = NodoPuntero; NodoPuntero->ProximoNodo = NodoAuxiliar; } return; }
///////////////////////////////////////////////////////////////////// // ALTA DEL NUEVO NODO //////////////////////////////////////////////////////////////////// MiNodo *InsertarUnNodo(MiNodo *NodoDeLaLista) { float EdadAux; // Declarando variable numérica real MiNodo *NodoPuntero; // variable dinámica NodoPuntero = new MiNodo; // Asignación dinámica de memoria //-------------------------------------------------------- cout << "\t\n ALTA DE NODO Legajo: "; cin >> NodoPuntero->Legajo; cout << "\t\n Nombre: "; cin >> NodoPuntero->Nombre; cout << "\t\n Edad : "; cin >> EdadAux; NodoPuntero->Edad = EdadAux; // Asignando valor al Campo Llave NodoPuntero->ProximoNodo = NULL; // Asignando valor al Campo Enlace NuevoNodoaInsertar = NodoPuntero; // Copiar contenido en NuevoNodoaInsertar //-------------------------------------------------------- if (NodoDeLaLista == NULL) //-- Si la lista esta vacia { NodoDeLaLista= NuevoNodoaInsertar; // Copiar NuevoNodoaInsertar a la lista NodoAnterior = NuevoNodoaInsertar; // Copiar NuevoNodoaInsertar a NodoAnterior } else //------------------------ Si la lista NO está vacia InsertarNodoAuxiliar(NuevoNodoaInsertar); return(NodoAnterior); }
/////////////////////////////////////////////// // VER DATOS DE LOS NODOS /////////////////////////////////////////////// MiNodo *VerDatosDeLosNodos(MiNodo *NodoDeLaLista) { MiNodo *ElMayor; int NroNodos; float LaEdad,SumaEdad; LaEdad=0; SumaEdad=0; NroNodos=0; if (NodoDeLaLista == NULL) LaListaEstaVacia(); else { cout << "\t\n CONTENIDO DE LOS NODOS \n\n"; cout << "Nodo Ubicacion LEGAJO NOMBRE EDAD \n"; cout << "--------------------------------------------\n"; while (NodoDeLaLista != NULL) { SumaEdad=SumaEdad + NodoDeLaLista->Edad; if (NodoDeLaLista->Edad > LaEdad) { LaEdad = NodoDeLaLista->Edad; ElMayor= NodoDeLaLista; } //-------------------------Listado de nodos cout << ++NroNodos << " " << &NodoDeLaLista->Legajo << " " << NodoDeLaLista->Legajo << " " << NodoDeLaLista->Nombre << " " << NodoDeLaLista->Edad << "\n"; NodoDeLaLista = NodoDeLaLista->ProximoNodo; } cout << "--------------------------------------------\n"; cout << "En " << NroNodos << " nodos, la edad promedio es " << SumaEdad/NroNodos << " y el mayor es " << ElMayor->Nombre << ", tiene " << ElMayor->Edad << " anios \n\n"; } return (0); }
/////////////////////////////////////////////////////// // BUSQUEDA DE UN NODO ////////////////////////////////////////////////////// MiNodo *BuscarUnNodo(MiNodo *NodoDeLaLista,int LegajoElegido) { int SiEsta = false; PunteroDelNodo = NodoDeLaLista; while ((PunteroDelNodo != NULL) && !SiEsta) { if (LegajoElegido == PunteroDelNodo->ProximoNodo->Legajo) { SiEsta = true; } else { PunteroDelNodo = PunteroDelNodo->ProximoNodo; } } return(PunteroDelNodo); } /////////////////////////////////////////////////////// // BAJA DE UN NODOS ////////////////////////////////////////////////////// MiNodo *BorrarUnNodo(MiNodo *NodoDeLaLista) { int LegajoElegido; cout << "\t\t\n BAJA DE UN NODO \n\n"; cout << "\t\n Legajo del Nodo a eliminar: ";cin >> LegajoElegido; NodoAnterior = NodoDeLaLista; PunteroDelNodo = NodoDeLaLista; NodoAuxiliar = NodoDeLaLista; if (NodoDeLaLista == NULL) { LaListaEstaVacia(); } else { if (LegajoElegido == NodoAuxiliar->Legajo) { NodoAuxiliar = NodoAuxiliar->ProximoNodo; free(PunteroDelNodo); PunteroDelNodo = NodoAuxiliar; NodoDeLaLista = NodoAuxiliar; NodoAnterior = NodoAuxiliar; } else { PunteroDelNodo = BuscarUnNodo(NodoDeLaLista,LegajoElegido); NodoAuxiliar = PunteroDelNodo->ProximoNodo; PunteroDelNodo->ProximoNodo = NodoAuxiliar->ProximoNodo; delete NodoAuxiliar; } } return (NodoAnterior); } MiNodo *liberar(MiNodo *NodoDeLaLista) { PunteroDelNodo = NodoDeLaLista; while (PunteroDelNodo != NULL) { NodoAuxiliar = PunteroDelNodo->ProximoNodo; free(PunteroDelNodo); PunteroDelNodo = NodoAuxiliar; NodoDeLaLista = PunteroDelNodo; } if (NodoDeLaLista == NULL) LaListaEstaVacia(); return (NodoDeLaLista); } /////////////////////////////////////// // FUNCION PRINCIPAL /////////////////////////////////////// void main(void) { NodoDeLaLista=NULL; do { MiOpcion=MenuOpciones(); switch(MiOpcion) { case 1: Si_No ='s'; do { NodoDeLaLista = InsertarUnNodo(NodoDeLaLista); cout << "\t\t\t\t Ingresas otro nodo.? (s/n) "; cin>>Si_No; } while (!((Si_No !='s')&&(Si_No !='S'))); break; case 2: VerDatosDeLosNodos(NodoDeLaLista); break; case 3: NodoDeLaLista = BorrarUnNodo(NodoDeLaLista); break; case 4: Salir = CerrarPrograma(); break; } } while (!(Salir =='S')); NodoDeLaLista = liberar(NodoDeLaLista); } /////////////////////////////////////// // FUNCION MENU DE OPCIONES /////////////////////////////////////// int MenuOpciones() { int MiOpcion; MiOpcion=1; cout << "================================================================\n\n"; cout << " LISTAS ENLAZADAS Wilo Carpio 12/5/2000 \n\n"; cout << " 1 - ALTAS 3 - BORRAR NODO \n\n"; cout << " 2 - VER DATOS 4 - SALIR Elige una Opcion: "; cin >> MiOpcion; cout << "-----------------------------------------------------------------\n"; return MiOpcion; } /////////////////////////////////////// // SALIR DEL PROGRAMA /////////////////////////////////////// char CerrarPrograma() { char Salir; cout << "OJO.!! ESTE PROGRAMA NO TIENE ARCHIVO DE DATOS, POR ELLO SI SALES \n\n"; cout << " PERDERAS LA INFORMACION GUARDADA EN LOS NODOS...!!! \n\n"; cout << "-----------------------------------------------------------------\n"; cout << "Deseas Cerrar el Programa ? ( S / N ) ";cin>>Salir; return toupper(Salir); } /////////////////////////////////////// // FUNCION LISTA VACIA /////////////////////////////////////// void LaListaEstaVacia() { cout << "\t\t\n LA LISTA VACIA...NO HAY NODOS..!! \n\n"; }
En estas estructuras de datos abstractos, los usuarios hacen altas o ponen cosas en ellas, una a la vez mediante una operación de encolamiento, y las retiran o dan de baja, un elemento a la vez por medio de una operación de desencolamiento.
Aunque en teoría la cola puede ser infinitamente grande, en la práctica, ella es finita y sus elementos se devuelven de la cola en orden de FIFO (Firts In Firts Out: primero en entrar, primero en salir): el primer elemento que entra en la cola es el primero en ser retirado de ella.
Del mismo modo que las pilas, también las colas son listas. Con una cola, no obstante, la inserción se hace por un extremo, mientras que la eliminación se realiza por el otro extremo.
Las operaciones básicas sobre una cola son encolar, que inserta un elemento al final de la lista, y dar de baja o desencolar, para eliminar el elemento del inicio de la lista o frente.
COLAS COMO ARREGLOS: Para las colas pueden aplicarse los procesos de los arreglos, usando la estructura de datos COLA[ ], y la posición Frente y Final, que representan los extremos de la cola, y Tamaño que es el numero de elementos de la cola.
FUNCION PRINCIPAL
void main() { textbackground(BLUE); textcolor(WHITE); NodoDeLaCola *MiColita;// puntero a la MiColita int MiOpcion=0,LaOpcion; MiColita = NULL; do { textcolor(YELLOW); textbackground(BLUE);clrscr(); cout <<"\n\t\t°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°"; cout <<"\n\t\t C++ Wilo Carpio 25/6/98"; cout <<"\n\t\t ESTRUCTURAS DINAMICAS DE DATOS "; cout <<"\n\t\t "; cout <<"\n\t\t MANEJO COLAS SIN ARCHIVO "; cout <<"\n\t\t "; cout <<"\n\t\t MENU PRINCIPAL "; cout <<"\n\t\t\t 1- Altas"; cout <<"\n\t\t\t 2- Consulta"; cout <<"\n\t\t\t 3- Baja Logica"; cout <<"\n\t\t\t 4- Baja Fisica"; cout <<"\n\t\t\t 5- Ver 1er nodo"; cout <<"\n\t\t\t 6- Modificar"; cout <<"\n\t\t\t 7- Imprimir"; cout <<"\n\t\t\t 8- SALIR"; cout <<"\n\t\t°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°"; cout <<"\n\n\t\t\t\t Elige una opci¢n -> ";cin >>MiOpcion; clrscr(); switch(MiOpcion) { case 1: MiColita=AltaEnMiColita(MiColita); break; case 2: MostrarTodosLosNodos(MiColita); break; case 3: MiColita=BajaLogicaDelNodo(MiColita); break; case 4: MiColita=BajaFisicaEnMiColita(MiColita); break; case 5: ConsultaPrimerDato(MiColita); break; case 6: MiColita=ModificarDatoDelNodo(MiColita); break; case 7: ImprimirMiColita(MiColita); break; } } while(MiOpcion != 8); MiColita=LiberarMemoria(MiColita); //libera memoria cuando sale del programa }
ESTRUCTURA DE LA COLA
//°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°° // C++ MANEJO DE COLA SIN ARCHIVO Wilo Carpio // Colawilo.cpp //°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°° #include//cout, cin #include //print, scanf,fopen,fclose #include //getch, gotoxy,clrscr,textbackground,textcolor #include //strcpy #include //free y malloc typedef struct MiColita { int UnLegajo; // Campo llave del NodoDeLaCola char UnNombre[30]; // Campo de informacion int MiFlag; struct MiColita *NodoSiguiente; // Puntero del NodoDeLaCola }NodoDeLaCola; void Rotulo(); void Tecla(); void ColitaLimpia(); void Rotulo() { clrscr(); cout <<"\n\t\t°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°"; cout <<"\n\t\t C++ Wilo Carpio 25/6/98"; cout <<"\n\t\t ESTRUCTURAS DINAMICAS DE DATOS "; cout <<"\n\t\t COLAS SIN ARCHIVO "; cout <<"\n\t\t°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°"; cout <<"\n\t\t "; } void ColitaLimpia() { cout<<"\n\t\t Mi colita esta limpita.. sin nodos..!!"; getch(); } void Tecla() { cout<<"\n\n\t\t Tecla para seguir..\n"; getch(); } NodoDeLaCola *LiberarMemoria(NodoDeLaCola *MiColita) { NodoDeLaCola *NodoAuxiliar,*NodoElegido; NodoAuxiliar=MiColita; while(NodoAuxiliar->NodoSiguiente!=NULL) //Mientras MiColita contenga datos { NodoElegido=NodoAuxiliar->NodoSiguiente; //Asigna a un NodoAuxiliar el NodoDeLaCola NodoSiguiente al que va a borrar free(NodoAuxiliar); // Elimina el NodoDeLaCola NodoAuxiliar=NodoElegido; // Asigna al auxiliar el valor del NodoDeLaCola siguiente al que tenia antes de ser liberado MiColita=NodoAuxiliar; // Como se elimino 1ø nodo, cabecera toma valor de NodoAuxiliar, ya } free(MiColita); return(MiColita); //devuelve la cabecera que es NULL }
ALTAS
NodoDeLaCola *AltaEnMiColita(NodoDeLaCola *MiColita) { NodoDeLaCola *NodoAuxiliar,*nuevo; // Nodos auxliliares nuevo=(NodoDeLaCola*)malloc(sizeof(NodoDeLaCola)); // Se pide memoria para cada NodoDeLaCola cargado Rotulo(); cout <<"\n\t\t ALTA EN COLAS SIN ARCHIVO \n"; cout <<"\n\t\t Digita los siguientes datos \n"; cout <<"\n\t\t\t 1- Legajo : ";cin >>nuevo->UnLegajo; cout <<"\n\t\t\t 2- Nombre : ";cin >>nuevo->UnNombre; nuevo->MiFlag=1; nuevo->NodoSiguiente =NULL; if(MiColita == NULL) // MiColita estara vacia por lo que el NodoDeLaCola MiColita = nuevo; // cabecera se inserta y el que se devolvera else { NodoAuxiliar=MiColita; //NodoAuxiliar para recorrer MiColita y perder la cabecera while(NodoAuxiliar->NodoSiguiente!=NULL) //Recorre toda MiColita hasta llegar al final NodoAuxiliar=NodoAuxiliar->NodoSiguiente; NodoAuxiliar->NodoSiguiente=nuevo; // para insertar el NodoDeLaCola } return(MiColita); //Devuelve el 1§ NodoDeLaCola que se ingreso }
CONTENIDO DE LOS NODOS
void MostrarPrimerNodo(NodoDeLaCola *NodoAuxiliar) { Rotulo(); cout <<"\n\t\t PRIMER NODO DE LA COLA \n"; cout <<"\n\t LEGAJO NOMBRE \n"; cout <<"\n\t"<< NodoAuxiliar->UnLegajo<<" "<UnNombre; Tecla(); } void MostrarTodosLosNodos(NodoDeLaCola *MiColita) { int y=9,n=0, x=7; NodoDeLaCola *NodoAuxiliar; NodoAuxiliar = MiColita; if( MiColita== NULL) { //Si MiColita no contenga datos ColitaLimpia(); } else { Rotulo(); cout <<"\n\t\t FICHAS DE LA COLA \n"; cout <<"\n\t LEGAJO NOMBRE \n"; while(NodoAuxiliar != NULL)//Mientras la MiColita contenga elementos { if(NodoAuxiliar->MiFlag == 1)//Verifica datos sin BajaLogica { cout <<"\n\t"<< NodoAuxiliar->UnLegajo<<" "< UnNombre; n=n+1; y++; if(n==15)//Muestra hasta 15 datos por vez { getch(); clrscr(); Rotulo(); cout <<"\n\t\t LOS NODOS DE LA COLA \n"; cout <<"\n\t LEGAJO NOMBRE \n"; n=0; //inicializa el numero de datos que mostrara y=9; //inicializa la coordenada desde donde mostrara el 1§ dato } } NodoAuxiliar = NodoAuxiliar->NodoSiguiente; } getch(); } } void ConsultaPrimerDato(NodoDeLaCola *MiColita) { NodoDeLaCola *NodoAuxiliar; NodoAuxiliar=MiColita; if(NodoAuxiliar != NULL) { if( NodoAuxiliar->MiFlag == 0) //Si no se le dio de bajo logica { clrscr(); gotoxy(15,10);printf(" DATO con BAJA LOGICA !!"); getch(); //En caso de ser asi lo pone en aviso } else MostrarPrimerNodo(NodoAuxiliar); //Muestra el 1§ dato de la MiColita } else { ColitaLimpia(); } }
MODIFICACIONES DEL CONTENIDO DEL NODO
NodoDeLaCola *ModificarDatoDelNodo(NodoDeLaCola *MiColita) { int n,LosNodosDeMiColita=0,MiOpcion,s=0; NodoDeLaCola *NodoAuxiliar; NodoAuxiliar=MiColita; if(NodoAuxiliar != NULL) { if (NodoAuxiliar->MiFlag == 0) { clrscr(); gotoxy(15,10);printf(" Dato con BAJA LOGICA !!"); s=1; getch(); } else { LosNodosDeMiColita=1; Rotulo(); cout <<"\n\t\t MODIFICAR FICHAS DE LA COLA \n"; cout <<"N§ de Legajo: ";cin>>NodoAuxiliar->UnLegajo; cout <<"Nombre: ";cin>>NodoAuxiliar->UnNombre; Tecla(); do { //Menu de opciones para las ModificarDatoDelNodo Rotulo(); cout <<"\n\t MENU DE MODIFICAR 1er NODO DE LA COLA \n"; cout <<"\n\t\t 1. Nombre \n"; cout <<"\n\t\t 2. Salir \n"; cout <<"\n\t\t Digita tu opcion.. \n"; do { cin>>MiOpcion; } while (MiOpcion<1 || MiOpcion>2); switch(MiOpcion) { case 1: //Depende de la Opcion de modificacion de cada campo Rotulo(); cout <<"\n\t MODIFICA el 1er NODO DE LA COLA \n"; cout <<"\n\t Nuevo Nombre: ";cin>>NodoAuxiliar->UnNombre; Tecla(); break; } } while(MiOpcion != 2); } } if((LosNodosDeMiColita==0) && (s!=1)) //Si MiColita esta limpita { ColitaLimpia(); } return(MiColita); }
ELIMINACION DE NODOS:
puede hacerse por:NodoDeLaCola *BajaFisicaEnMiColita(NodoDeLaCola *MiColita) { NodoDeLaCola *NodoAuxiliar,*NodoElegido; NodoAuxiliar=MiColita; if(NodoAuxiliar != NULL) // Si el dato a eliminar no es nulo { NodoElegido=NodoAuxiliar->NodoSiguiente; free(NodoAuxiliar); NodoAuxiliar=NodoElegido; MiColita=NodoAuxiliar; } return(MiColita); //devuelve el segundo dato que se habia ingresado que } //ahora sera el primero NodoDeLaCola *BajaLogicaDelNodo(NodoDeLaCola * MiColita) { char OpcionElegida; NodoDeLaCola *NodoAuxiliar; if(MiColita != NULL) { Rotulo(); cout <<"\n\t\t BAJA LOGICA DE LA COLA \n"; //Antes de borrar confirma la accion gotoxy(13,7);printf("N§ de Legajo:%d\n",MiColita->UnLegajo); gotoxy(13,9);printf("Nombre:%s\n",MiColita->UnNombre); gotoxy(20,16);printf("¨Seguro que borras estos datos.?(s/n)"); gotoxy(60,16);scanf("%c",&OpcionElegida); gotoxy(13,7);printf("N§ de Legajo:%d\n",MiColita->UnLegajo); gotoxy(13,9);printf("Nombre:%s\n",MiColita->UnNombre); gotoxy(20,16);printf("¨Seguro que borras estos datos?"); gotoxy(60,16);scanf("%c",&OpcionElegida); if (OpcionElegida == 's')// Si la baja se cambia a 0 la bandera MiColita->MiFlag=0; } else { ColitaLimpia(); } return(MiColita); }
IMPRIMIENDO LOS NODOS
void ImprimirMiColita(NodoDeLaCola *TuColita) { NodoDeLaCola *NodoAuxiliar=TuColita; if( TuColita == NULL) { ColitaLimpia() ; } else { while(NodoAuxiliar != NULL) { if(NodoAuxiliar->MiFlag == 1) { fprintf(stdprn,"LEGAJO :%d\n",NodoAuxiliar->UnLegajo); //standart printer fprintf(stdprn,"NOMBRE :%s\n",NodoAuxiliar->UnNombre); //Funcion que permite } NodoAuxiliar=NodoAuxiliar->NodoSiguiente; } } }
La pila es una versión restringida de una lista enlazada, ya que los nuevos nodos solo pueden agregarse a una pila y eliminarse de una pila desde la parte superior de ésta. El miembro de enlace del último nodo de la pila está establecido a nulo (cero) para indicar el fondo de la pila.
En el mundo de los programas informáticos las pilas tienen aplicaciones como por ejemplo, cuando se realiza una llamada de función, la función llamada debe saber la manera de regresar a su invocador, y por esto la dirección de devolución se pone en una pila. También los compiladores utilizan a las pilas en el proceso de evaluación de expresiones y en la generación de código de lenguaje de maquina.
Cuando sucede una serie de llamadas de función, los valores de devolución sucesivos se ponen en la pila en un orden último en entrar, primero en salir, para que cada función pueda regresar a su invocador. Las pilas soportan las llamadas de función recursivas en la misma forma que lo hacen con las llamadas no recursivas convencionales.
Las pilas contienen el espacio que se crea para las variables automáticas en cada llamada a una función. Cuando la función regresa a su invocador, el espacio para las variables automáticas de la función se saca de la pila, y de ésta manera el programa ya no conoce dichas variables.
Como una pila es una lista, podemos plantear dos técnicas de proceso.
REGALO COMPLETO y CON MOÑO
////////////////////////////////////////////////////////////// // VARIABLE DINAMICA WILO CARPIO // PILA CON ARCHIVO 12/5/1998 // Funciona OK: C++Borland // Visual C++: // File/New/Projects/win32ConsoleAplicatión: // Asignar nombre del proyecto y el Path // File/New/Files/C++SourceFile: Asignar Nombre al programa ////////////////////////////////////////////////////////////// #include < iostream.h> #include < malloc.h> #include < string.h> #include < stdio.h> ////////////////////////////////////////////// // Declaración de estructura del nodo ////////////////////////////////////////////// struct nodo { int codigo; char nombre[30]; char domicilio[30]; char telefono[30]; nodo*SiguienteNodo; }; ////////////////////////////////////////////// // Declaración de la ficha del archivo ////////////////////////////////////////////// struct registro { int codigo; char nombre[30]; char domicilio[30]; char telefono[30]; }; ////////////////////////////////////////////// // Declaración del puntero ////////////////////////////////////////////// typedef struct nodo*puntero; puntero cabecera; ///////////////////////////////// // PROTOTIPOS DE LAS FUNCIONES // ///////////////////////////////// int Codigo_Buscado(int); ////////////////////////////////////////////// // Declaracion de variables globales ////////////////////////////////////////////// int Opcion,OpcionGrabar,Flag,EstaGrabado,CodigoFicha; char Si_No;
Se realizan altas (Meter) insertando al frente de la lista y la baja (Sacar) eliminando el elemento que está al frente de la lista. Una operación cima solo examina el elemento del frente de la lista, devolviendo su valor. A veces la operación sacar y cima se combinan en una. Podríamos usar llamadas a las rutinas sobre listas enlazadas.
Primero implantamos la pila con cabecera. Después se examina una pila vacía en la misma manera que una lista vacía.
La creación de una pila vacía requiere crear una cabecera con un apuntador siguiente a NULL. El meter se implanta como inserción al frente de la lista enlazada, donde el frente de la lista se conoce como cima de la pila. La cima se efectúa examinando el elemento de la primera posición de la lista. Por ultimo, implantaremos sacar eliminando el frente de la lista.
Todas las operaciones tardan un tiempo constante, por que en ninguna de las rutinas tiene referencia al tamaño de la pila ( excepto en la comprobación de si esta vacía ); tampoco se encuentra un ciclo que dependa del tamaño.
////////////////////////////////////////////// // Carga de la pila ////////////////////////////////////////////// void cargar_pila(void) { puntero MiNodo,NodoAuxiliar; do { //tamaño de memoria// MiNodo=(puntero)malloc(sizeof(struct nodo));//pido memoria cout << "Codigo: "; cin >> CodigoFicha; if(Codigo_Buscado(CodigoFicha)==1) { cout < < "\t\n **************CODIGO EXISTENTE**************\n"; } else { MiNodo ->codigo=CodigoFicha; cout < < "Nombre: "; cin>>MiNodo->nombre; cout < < "Domicilio:"; cin>>MiNodo->domicilio; cout < < "Telefono: "; cin>>MiNodo->telefono; MiNodo->SiguienteNodo=NULL; if (cabecera == NULL) cabecera=MiNodo; else { NodoAuxiliar=cabecera; while (NodoAuxiliar->SiguienteNodo!=NULL) NodoAuxiliar=NodoAuxiliar->SiguienteNodo; NodoAuxiliar->SiguienteNodo=MiNodo; } } cout << "Deseas ingresar otro nodo(S/N)";cin >>Si_No; while(Si_No!='s' && Si_No!='n') { cout < < "Deseas ingresar otro nodo(S/N)";cin > > Si_No; } }while(Si_No=='s'); Flag=1; return; } //////////////////////////////////////////// // BUSQUEDA DEL CODIGO EN NODO EN LA COLA // /////////////////////////////////////////// int Codigo_Buscado(int codbus) { int YaEsta;puntero NodoAuxiliar,temp; YaEsta=0; NodoAuxiliar=cabecera; while(NodoAuxiliar!=NULL) { temp=NodoAuxiliar; if(NodoAuxiliar->codigo==codbus) YaEsta=1; NodoAuxiliar=NodoAuxiliar->SiguienteNodo; } return YaEsta; }
////////////////////////////////////////////// // Recorrido de la pila ////////////////////////////////////////////// void recorrer_pila(void) { puntero NodoAuxiliar,aux1; NodoAuxiliar=cabecera; if(cabecera!=NULL) { cout <<"**** DATOS QUE CONTIENE LA PILA ****\n"; cout <<"=================================================================\n"; cout <<" CODIOGO NOMBRE DOMICILIO TELEFONO \n"; while(NodoAuxiliar->SiguienteNodo!=NULL) { NodoAuxiliar=NodoAuxiliar->SiguienteNodo; } while (NodoAuxiliar!=cabecera) { aux1=cabecera; while (aux1->SiguienteNodo!=NodoAuxiliar) aux1=aux1->SiguienteNodo; cout<<"\t"< < NodoAuxiliar->codigo<<"\t" "\t"< < NodoAuxiliar->nombre<<"\t" "\t"< < NodoAuxiliar->domicilio<<"\t" "\t"< < NodoAuxiliar->telefono<<"\n"; NodoAuxiliar=aux1; } cout<<"\t"< < NodoAuxiliar->codigo<<"\t" "\t"< < NodoAuxiliar->nombre<<"\t" "\t"< < NodoAuxiliar->domicilio<<"\t" "\t"< < NodoAuxiliar->telefono<<"\n"; cout<<"=================================================================\n"; } else cout<<" **** LA PILA ESTA VACIA **** \n"; } ////////////////////////////////////////////// // Baja de la pila ////////////////////////////////////////////// void baja_pila(void) { puntero NodoAuxiliar,ant; NodoAuxiliar=cabecera; if (cabecera!=NULL) { if(cabecera->SiguienteNodo==NULL) { cabecera=NULL; free(NodoAuxiliar); cout<<" **** NODO ELIMINADO **** \n"; Flag=1; } else { while(NodoAuxiliar->SiguienteNodo!=NULL) { ant=NodoAuxiliar; NodoAuxiliar=NodoAuxiliar->SiguienteNodo; } free(NodoAuxiliar); ant->SiguienteNodo=NULL; cout<<" **** NODO ELIMINADO **** \n"; Flag=1; } } else cout<<"**** LA PILA ESTA VACIA ****\n"; }
////////////////////////////////////////////// // Modificación del nodo ////////////////////////////////////////////// void modifi_pila(void) { int bandera=0;char tecla; int coding; puntero NodoAuxiliar; cout<<"DIGITA EL CODIGO DEL NODO A MODIFICAR: "; cin>>coding; NodoAuxiliar=cabecera; while(NodoAuxiliar!=NULL && bandera==0) { if (NodoAuxiliar->codigo==coding) bandera=1; else NodoAuxiliar=NodoAuxiliar->SiguienteNodo; } if(bandera==1) { cout<<" EL NODO CONTIENE ESTOS DATOS \n"; cout<<"==================================\n"; cout<<"CODIGO: "<codigo<<"\n"; cout<<"Nombre: "< nombre<<"\n"; cout<<"Domicilio: "< domicilio<<"\n"; cout<<"Telefono: "< telefono<<"\n"; cout<<"==================================\n"; cout<<"Esta seguro que desea modificar estos datos(S/N)"; cout<<"\n"; while(tecla!='s' && tecla!='n') cin>>tecla; if(tecla==115) { cout<<"CODIGO: ";cin>>NodoAuxiliar->codigo; cout<<"Nombre: ";cin>>NodoAuxiliar->nombre; cout<<"Domicilio: ";cin>>NodoAuxiliar->domicilio; cout<<"Telefono: ";cin>>NodoAuxiliar->telefono; } Flag=1; } else { cout<<" ERROR--EL CODIGO NO EXISTE \n"; } } ////////////////////////////////////////////// // Carga de la pila en el archivo ////////////////////////////////////////////// void pila_archivo(void) { FILE*archivo; registro MiFicha; puntero NodoAuxiliar; puntero aux1; archivo=fopen("pila.dat","w"); NodoAuxiliar=cabecera; if (cabecera!= NULL) { while(NodoAuxiliar->SiguienteNodo!=NULL) { NodoAuxiliar=NodoAuxiliar->SiguienteNodo; } while(NodoAuxiliar!=cabecera) { aux1=cabecera; while(aux1->SiguienteNodo!=NodoAuxiliar) aux1=aux1->SiguienteNodo; MiFicha.codigo=NodoAuxiliar->codigo; strcpy(MiFicha.nombre,NodoAuxiliar->nombre); strcpy(MiFicha.domicilio,NodoAuxiliar->domicilio); strcpy(MiFicha.telefono,NodoAuxiliar->telefono); fwrite(&MiFicha,sizeof(struct registro),1,archivo); NodoAuxiliar=aux1; } MiFicha.codigo=NodoAuxiliar->codigo; strcpy(MiFicha.nombre,NodoAuxiliar->nombre); strcpy(MiFicha.domicilio,NodoAuxiliar->domicilio); strcpy(MiFicha.telefono,NodoAuxiliar->telefono); fwrite(&MiFicha,sizeof(struct registro),1,archivo); fclose(archivo); cout<<" ******************************** \n "; cout<<"******** LA PILA SE GRABO EN EL ARCHIVO *****\n"; cout<<" ******************************** \n "; Flag=0; } else { cout<<"*** NO HAY NODOS EN LA PILA ***\n"; } }
////////////////////////////////////////////// // Recorrido del archivo ////////////////////////////////////////////// void recorrer_archivo(void) { FILE*archivo; registro MiFicha; archivo=fopen("pila.dat","r"); if(archivo!=NULL) { fread(&MiFicha,sizeof(struct registro),1,archivo); cout<<"\n"; cout<<"*** DATOS QUE CONTIENE EL ARCHIVO ***\n"; cout<<"==================================================================\n"; cout<<" CODIGO NOMBRE DOMICILIO TELEFONO \n"; while(!feof(archivo)) { cout<<"\t"< < MiFicha.codigo<<"\t" "\t"< < MiFicha.nombre<<"\t" "\t"< < MiFicha.domicilio<<"\t" "\t"< < MiFicha.telefono<<"\n"; fread(&MiFicha,sizeof(struct registro),1,archivo); } fclose(archivo); cout<<"==================================================================\n"; } else { cout < < " *** EL ARCHIVO ESTA VACIO *** \n"; } }
////////////////////////////////////////////////// // Transferencia de datos del archivo a la pila ////////////////////////////////////////////////// void archivo_pila(void) { puntero MiNodo,NodoAuxiliar; FILE*archivo; registro MiFicha; archivo=fopen("pila.dat","r"); if(archivo!=NULL) { fread(&MiFicha,sizeof(struct registro),1,archivo); while(!feof(archivo)) { MiNodo=(puntero)malloc(sizeof(struct nodo)); MiNodo->codigo=MiFicha.codigo; strcpy(MiNodo->nombre, MiFicha.nombre); strcpy(MiNodo->domicilio,MiFicha.domicilio); strcpy(MiNodo->telefono, MiFicha.telefono); MiNodo->SiguienteNodo=NULL; if(cabecera==NULL) cabecera=MiNodo; else { NodoAuxiliar=cabecera; while(NodoAuxiliar->SiguienteNodo!=NULL) NodoAuxiliar=NodoAuxiliar->SiguienteNodo; NodoAuxiliar->SiguienteNodo=MiNodo; } fread(&MiFicha,sizeof(struct registro),1,archivo); } fclose(archivo); } }
////////////////////////////////////////////// // Menu principal ////////////////////////////////////////////// void main (void) { Opcion = 0;OpcionGrabar=0;Flag=0; cabecera = NULL; archivo_pila(); do { cout<<"\n"; cout<<"******** MENU DEL SISTEMA ********\n"; cout<<"* 1. ALTA DE PILA *\n"; cout<<"* 2. BAJA DE UN NODO *\n"; cout<<"* 3. MODIFICAR DATOS DE UN NODO *\n"; cout<<"* 4. RECORRIDO DE PILA *\n"; cout<<"* 5. GRABAR LA PILA EN ARCHIVO *\n"; cout<<"* 6. RECORRER ARCHIVO *\n"; cout<<"* 7. SALIR DEL SISTEMA *\n"; cout<<"** Ingrese opcion: "; cin>>Opcion; cout<<"\n"; switch (Opcion) { case 1: cargar_pila(); break; case 2: baja_pila(); break; case 3: modifi_pila(); break; case 4: recorrer_pila(); break; case 5: pila_archivo(); break; case 6: recorrer_archivo(); break; } } while (Opcion != 7); if ( Flag!=0) { do { EstaGrabado=0; cout<<"\n"; cout<<"**** MENU FINAL DEL SISTEMA ****\n"; cout<<"* 8. GRABAR LA PILA EN ARCHIVO *\n"; cout<<"* 9. SALIR DEL SISTEMA *\n"; cout<<"********************************\n\n"; cout<<"******************************************************\n"; cout<<"* !!YA GRABO LOS NODOS DE LA PILA EN EL ARCHIVO ?? *\n"; cout<<"******************************************************\n\n"; cout<<" OJITO.. SI NO GRABAS LOS DATOS DE TU COLA. \n"; cout<<" ...SE PERDERAN AL SALIR DEL SISTEMA..!! \n"; cout<<" INGRESA UNA OPCION (Tecla 8 o 9): "; cin>>OpcionGrabar; switch (OpcionGrabar){ case 8: pila_archivo(); EstaGrabado=1; break; } }while(OpcionGrabar !=9 && EstaGrabado!=1); } cout<<" \n\n"; cout<<" ******** FIN DEL PROGRAMA *******\n"; cout<<" ******** CHAU GRACIAS *******\n\n"; }
Sonrie.. yo existo.!!!
LIO FAMILIAR: Aquellos nodos que tienen el mismo padre se llaman "Hermanos" y los hijos de estos son "Nietos" del "Padre". Está claro no.???
Los árboles tienen
ARBOL DE EXPRESION:
(a + b * c ) + (( d * e + f ) * g )
En este ejemplo, a + (d * c) se evalúa en el subárbol izquierdo y ((d * e) + f ) se evalúa en el subárbol derecho.
Este esquema "Izquierda, Nodo, Derecha" se denomina de "Recorrido simétrico"
RECURSIVIDAD: DECLARAR NODOS DEL ÁRBOL:
- Base: Definen los elementos del conjuntos que servirán para crear el resto del conjunto.
- Reglas de recurrencia: Permiten crear un elemento a partir de elementos ya creados.
Usa y analiza la sintaxis y la semántica del siguiente ejemplo para que aprendas a operar tus árboles
///////////////////////////////////////////////////////////////// // ESTRUCTURA DINAMICA DE DATOS Wilo Carpio // ARBOL EN C++ 6 01/06/2000 // MiPino // Pino2000.cpp ///////////////////////////////////////////////////////////////// #include#include #include #include #include #include ////////////////////////////////////////////////// // ESTRUCTURA DEL NODO DEL ARBOL ////////////////////////////////////////////////// typedef struct MiBelloPino { int CodigoLibro; char TituloLibro[10], AutorLibro[10], Editorial[10]; struct MiBelloPino *RamaIzquierda,*RamaDerecha; } nodo; ////////////////////////////////////////////////// // PROTOTIPOS DE LAS FUNCIONES ////////////////////////////////////////////////// int MenuOpciones(); char CerrarPrograma(); void CargarNuevoNodo(); void PupaUnNodo(); void HacerPupaElNodo (nodo *MiBelloPino); void CambiarDatoDeNodo(); void VerLosNodos(nodo *VerDatoDeNodo); int YaExisteEseNodo(int); void MiArbolEstaVacio(); nodo* DuplicarNodo(nodo *MiBelloPino, nodo *Puntero,int Codigo); nodo* InsertarNodoEnPino(nodo *MiBelloPino,nodo *Puntero); void NoEstaEnElArbol(int); void RegistroLosCamposDelNodo(int); ///////////////////////////////////////////////////// // DECLARACION DE VARIABLES GLOBALES ///////////////////////////////////////////////////// int Opcion; nodo *NodoRaiz; nodo *NodoAuxiliar; nodo *NodoTemporario; nodo *NodoNuevo; nodo *NodoDeReemplazo; int Codigo; char Titulo[10],Autor[10],Editorial[10]; int NodoExistente; int Flap; char Si_No; //////////////////////////////////////////////////////// // PROGRAMA PRINCIPAL // ================== //////////////////////////////////////////////////////// void main(void) { NodoRaiz=NULL; while(toupper(Si_No) !='S') { switch(MenuOpciones()) { case 1: CargarNuevoNodo(); break; case 2: PupaUnNodo(); break; case 3: CambiarDatoDeNodo();break; case 4: cout<<" LOS LIBROS DE WILO SON \n"; cout<<"\n Memoria Codigo Titulo Autor Editorial \n"; VerLosNodos(NodoRaiz); break; case 5: Si_No=CerrarPrograma();break; } } }
ALTA DEL NUEVO NODO:
/////////////////////////////////////////////////////// // ALTA DEL NUEVO NODO /////////////////////////////////////////////////////// void CargarNuevoNodo() {Si_No='s'; do { cout<<" Digita datos del libro "; NodoNuevo = new (nodo); cout<<" CODIGO : "; cin>>Codigo; if (YaExisteEseNodo(Codigo) ==1) { cout<<"\n ....YA CARGASTE ESE CODIGO chee..!!! \n\n"; } else { RegistroLosCamposDelNodo(Codigo); if (NodoRaiz == NULL) NodoRaiz= NodoNuevo; else { NodoAuxiliar=NodoRaiz; while (NodoAuxiliar != NULL) { NodoTemporario=NodoAuxiliar; if (NodoAuxiliar->CodigoLibro > NodoNuevo->CodigoLibro) NodoAuxiliar= NodoAuxiliar->RamaIzquierda ; else NodoAuxiliar= NodoAuxiliar->RamaDerecha; } if (NodoTemporario->CodigoLibro > NodoNuevo->CodigoLibro) NodoTemporario->RamaIzquierda=NodoNuevo; else NodoTemporario->RamaDerecha=NodoNuevo; } } cout<<" Cargas otro nodo ? (s/n) ";cin>>Si_No; } while(!((Si_No!='s')&&(Si_No!='S'))); } /////////////////////////////////////////////////////////////// // DIGITANDO LOS DATOS DEL NODO EN EL ARBOL /////////////////////////////////////////////////////////////// void RegistroLosCamposDelNodo(int) { NodoNuevo->CodigoLibro=Codigo; cout<<"\t\t\t TITULO : ";cin>>Titulo; strcpy(NodoNuevo->TituloLibro,Titulo); cout<<"\t\t\t AUTOR : ";cin>>Autor; strcpy(NodoNuevo->AutorLibro,Autor); cout<<"\t\t\t EDITORIAL: ";cin>>Editorial;strcpy(NodoNuevo->Editorial,Editorial); NodoNuevo->RamaIzquierda =NULL; NodoNuevo->RamaDerecha =NULL; } /////////////////////////////////////////////////////////////// // INSERTANDO UN NUEVO NODO /////////////////////////////////////////////////////////////// nodo* InsertarNodoEnPino(nodo *MiBelloPino, nodo *Puntero) { NodoNuevo=new(nodo); NodoNuevo->CodigoLibro=MiBelloPino->CodigoLibro; strcpy(NodoNuevo->TituloLibro,MiBelloPino->TituloLibro); strcpy(NodoNuevo->AutorLibro,MiBelloPino->AutorLibro); strcpy(NodoNuevo->Editorial,MiBelloPino->Editorial); NodoNuevo->RamaIzquierda=NULL; NodoNuevo->RamaDerecha=NULL; if (Puntero==NULL) Puntero=NodoNuevo; else { NodoAuxiliar=Puntero; while(NodoAuxiliar!=NULL) { NodoTemporario=NodoAuxiliar; if (NodoAuxiliar->CodigoLibro >NodoNuevo->CodigoLibro) NodoAuxiliar=NodoAuxiliar->RamaIzquierda; else NodoAuxiliar=NodoAuxiliar->RamaDerecha; } if (NodoTemporario->CodigoLibro > NodoNuevo->CodigoLibro) NodoTemporario->RamaIzquierda=NodoNuevo; else NodoTemporario->RamaDerecha=NodoNuevo; } return (Puntero); } /////////////////////////////////////////////////////////////// // COPIANDO EL CONTENIDO DEL NODO /////////////////////////////////////////////////////////////// nodo* DuplicarNodo (nodo *MiBelloPino, nodo *Puntero, int Codigo) { if (MiBelloPino != NULL) { if(Codigo != MiBelloPino->CodigoLibro) Puntero=InsertarNodoEnPino(MiBelloPino, Puntero); Puntero=DuplicarNodo(MiBelloPino->RamaIzquierda, Puntero ,Codigo); Puntero=DuplicarNodo(MiBelloPino->RamaDerecha, Puntero ,Codigo); } return (Puntero); }
RECORRIDO DE NODOS:
/////////////////////////////////////////////////////////////// // RECORRIDO DE LOS NODOS PARA VER DATOS /////////////////////////////////////////////////////////////// void VerLosNodos( nodo*VerDatoDeNodo) { if (NodoRaiz==NULL) { MiArbolEstaVacio();} else { if (VerDatoDeNodo!=NULL) { VerLosNodos(VerDatoDeNodo->RamaIzquierda); cout<<&VerDatoDeNodo->CodigoLibro<<"\t" <CodigoLibro<<"\t" < TituloLibro<<"\t\t" < AutorLibro<<"\t\t" < Editorial<<" \n"; VerLosNodos(VerDatoDeNodo->RamaDerecha); } } } /////////////////////////////////////////////////////////////// // BUSQUEDA DEL NODO EN EL ARBOL /////////////////////////////////////////////////////////////// int YaExisteEseNodo (int CodigoBuscado) { int valor; valor=0; NodoAuxiliar=NodoRaiz; while (NodoAuxiliar!=NULL) { NodoTemporario=NodoAuxiliar; if (NodoAuxiliar->CodigoLibro == CodigoBuscado) valor=1; if (NodoAuxiliar->CodigoLibro > CodigoBuscado) NodoAuxiliar=NodoAuxiliar->RamaIzquierda; else NodoAuxiliar=NodoAuxiliar->RamaDerecha; } return valor; }
BORRANDO UN NODO:
La baja puede ser lógica o física/////////////////////////////////////////////////////////////// // BORRANDO UN NODO DEL ARBOL /////////////////////////////////////////////////////////////// void HacerPupaElNodo (nodo *MiBelloPino) { if (MiBelloPino!=NULL) { HacerPupaElNodo(MiBelloPino->RamaIzquierda); HacerPupaElNodo(MiBelloPino->RamaDerecha); delete(MiBelloPino); MiBelloPino=NULL; } } /////////////////////////////////////////////////////////////// // BAJA DE UN NODO DEL ARBOL /////////////////////////////////////////////////////////////// void PupaUnNodo() { if (NodoRaiz==NULL) { MiArbolEstaVacio();} else { cout<<"\n ESTAS POR HACER PUPA UN LIBRO.. Digita el Codigo: ";cin>>Codigo; NodoExistente=YaExisteEseNodo(Codigo); if (NodoExistente==0) { NoEstaEnElArbol(Codigo); } else { Flap=0; NodoAuxiliar=NodoRaiz; while ((NodoAuxiliar!=NULL)&& (Flap==0)) { NodoTemporario=NodoAuxiliar; if (NodoAuxiliar->CodigoLibro > Codigo) NodoAuxiliar=NodoAuxiliar->RamaIzquierda; else if (NodoAuxiliar->CodigoLibro < Codigo) NodoAuxiliar=NodoAuxiliar->RamaDerecha; else { cout<<"\n ESTE ES LIBRO QUE HARAS PUPA \n"; cout<<"\n Memoria Codigo Titulo Autor Editorial \n"; cout<<&NodoAuxiliar->CodigoLibro<<"\t" << NodoAuxiliar->CodigoLibro<<"\t" << NodoAuxiliar->TituloLibro<<"\t\t" << NodoAuxiliar->AutorLibro <<"\t\t" << NodoAuxiliar->Editorial <<" \n"; cout<<" Queres borrar este Nodo ? (S/N) "; cin>>Si_No; Flap=1; } } } if (toupper(Si_No)=='S') { NodoDeReemplazo=NULL; NodoDeReemplazo=DuplicarNodo(NodoRaiz,NodoDeReemplazo,Codigo); HacerPupaElNodo(NodoRaiz); NodoRaiz=NodoDeReemplazo; } } }
MODIFICAR DATOS
://///////////////////////////////////////////////////////////// // MODIFICAR LOS DATOS DEL NODO /////////////////////////////////////////////////////////////// void CambiarDatoDeNodo() { if (NodoRaiz==NULL) { MiArbolEstaVacio();} else { cout<<"\n MODIFICAR DATOS DEL NODO.. Digita el Codigo: ";cin>>Codigo; NodoExistente=YaExisteEseNodo(Codigo); if (NodoExistente==0) { NoEstaEnElArbol(Codigo); } else { Flap=0; NodoAuxiliar=NodoRaiz; while ( (NodoAuxiliar!=NULL)&&(Flap==0) ) { NodoTemporario=NodoAuxiliar; if (NodoAuxiliar->CodigoLibro > Codigo) NodoAuxiliar=NodoAuxiliar->RamaIzquierda; else if (NodoAuxiliar->CodigoLibro < Codigo) NodoAuxiliar=NodoAuxiliar->RamaDerecha; else { cout<<"\n ESTE ES LIBRO QUE MODIFICARAS \n"; cout<<"\n Memoria Codigo Titulo Autor Editorial \n"; cout<<&NodoAuxiliar->CodigoLibro<<"\t" << NodoAuxiliar->CodigoLibro<<"\t" << NodoAuxiliar->TituloLibro<<"\t\t" << NodoAuxiliar->AutorLibro <<"\t\t" << NodoAuxiliar->Editorial <<" \n"; cout<<" Confirmas la opcion ? (S/N) "; cin>>Si_No; Flap=1; } } if (toupper(Si_No)=='S') { cout<<"Titulo del Libro: "; cin>>Titulo; strcpy(NodoAuxiliar->TituloLibro,Titulo); cout<<"Autor del Libro : "; cin>>Autor; strcpy(NodoAuxiliar->AutorLibro,Autor); cout<<"Editorial : "; cin>>Editorial; strcpy(NodoAuxiliar->Editorial,Editorial); } } } }
ALGORITMOS TIPICOS:
/////////////////////////////////////// // SALIR DEL PROGRAMA /////////////////////////////////////// char CerrarPrograma() { char Salir; cout<<"OJO.!! ESTE PROGRAMA NO TIENE ARCHIVO DE DATOS, POR ELLO SI SALES \n\n"; cout<<" PERDERAS LA INFORMACION GUARDADA EN LOS NODOS...!!! \n\n"; cout<<"-----------------------------------------------------------------\n"; cout<<"Deseas Cerrar el Programa ? ( S / N ) ";cin>>Salir; return toupper(Salir); } /////////////////////////////////////// // FUNCION MENU DE OPCIONES /////////////////////////////////////// int MenuOpciones() { int MiOpcion; MiOpcion=1; cout<<"=========================================================================\n\n"; cout<<" LA BIBLIOTECA PERSONAL DE WILO ARBOL en C++ Junio_2000 \n\n"; cout<<" 1 - ALTAS 3 - MODIFICAR 5 - SALIR \n\n"; cout<<" 2 - BAJAS 4 - VER NODOS Elige tu Opcion: "; cin>>MiOpcion; cout<<"-------------------------------------------------------------------------\n"; return MiOpcion; } /////////////////////////////////////// // FUNCION LISTA VACIA /////////////////////////////////////// void MiArbolEstaVacio() { cout<<"\t\t\n ESTE PINO ESTA VACIO...NO HAY NODOS..!! \n\n"; } /////////////////////////////////////// // EL NODO NO EXISTE /////////////////////////////////////// void NoEstaEnElArbol(int) { cout<<"\n......CHE..!!! NO EXISTE EL CODIGO " << Codigo << " \n\n "; }
////////////////////////////////////////////////// // // LEY DE OHM LeyOhm.cpp 09/06/96 // // Wilo Carpio C++ // /////////////////////////////////////////////////// #include < iostream.h > /////////////////////////////////// // PROTOTIPOS DE LAS FUNCIONES /////////////////////////////////// char VerMenu(); void LeyDeOhm(char Opcion); float CalculaTension(); float CalculaCorriente(); float CalculaResistencia(); /////////////////////////////////// // FUNCION PRINCIPAL /////////////////////////////////// void main() { // Definicion de variables globales char Opcion='S'; // Mensaje de título por pantalla cout << "\n\t APLICACION DE LA LEY DE OHM Tension = Corriente * Resistencia \n"; cout << "\t =========================== LeyOhm.cpp Wilo Carpio \n"; // Bucle While para activar el menú de opciones do { Opcion=VerMenu(); LeyDeOhm(Opcion); } while((Opcion!='s')&&(Opcion!='S')); } // Fin de la funcion principal //////////////////////////////////////////////////// // FUNCION VerMenu: Visualiza opciones operativas //////////////////////////////////////////////////// char VerMenu() { // Declaración de variables locales char Opcion='S'; // Menú de opciones cout << "\n\t ELIGE OPCION: V Calculo de Voltage \n"; cout << "\t\t\t C Calculo de Corriente \n"; cout << "\t\t\t R Calculo de Resistencia \n"; cout << "\t\t\t S Salir \n"; cin >> Opcion; return Opcion; } // Fin de la función VerMenu
//////////////////////////////////////////////////// // FUNCION PARA SELECCIONAR EL CALCULO DE OHM //////////////////////////////////////////////////// void LeyDeOhm(char Opcion) { switch(Opcion) // Selector múltiple { case'V': cout << "\n TENSION = Corriente * Resistencia = " << CalculaTension() << " Volts \n"; break; case'C': cout << "\n CORRIENTE = Tension * Resistencia = " << CalculaCorriente() << " Amper \n"; break; case'R': cout << "\n RESISTENCIA = Tension / Corriente = " << CalculaResistencia() << " Ohm \n"; break; case'S': cout << "\n CHAU..!! SE FINI..!! \n"; break; default: cout << "\n Caca nene..!! /n"; } // Fin del selector switch } // Fin de la función LeyDeOhm
PARADIGMA
Si no quieres ser un recuerdo,
... se un reloco..!!
Grafiti
//////////////////////////////////////////////////// // FUNCION CAlCULO DEL VOLTAJE //////////////////////////////////////////////////// float CalculaTension() { // Declaración de variables locales float Corriente=0.0; float Resistencia=0.0; // Datos por teclado: Corriente y Resistencia cout << "\n\t Ingresa el valor de la Corriente I = "; cin >> Corriente; cout << "\n\t Ahora el valor de la Resistencia R = "; cin >> Resistencia; // Verica que corriente menor que cero, luego calcula voltaje if (Resistencia<0) { cout << "\n\t OJO.!! Resistencia negativa.!!! "<<"\n"; return 0.0; } else return Corriente*Resistencia; } // Fin de la función CalculaTension //////////////////////////////////////////////////// // FUNCION CAlCULO DE LA CORRIENTE //////////////////////////////////////////////////// float CalculaCorriente() { // Declaración de variables locales float Voltaje=0.0; float Resistencia=0.0; // Datos por teclado: Voltaje y Resistencia cout << "\n\t Ingresa el valor de la Tension V = "; cin >> Voltaje; cout << "\n\t Ahora el valor de la Resistencia R = "; cin >> Resistencia; // Verica que corriente menor que cero, luego calcula voltaje if (Resistencia<0) { cout << "\n\t OJO.!! Resistencia negativa.!!! " << "\n"; return 0.0; } else return Voltaje*Resistencia; } // Fin de la función CalculaCorriente //////////////////////////////////////////////////// // FUNCION CAlCULO DE LA RESISTENCIA //////////////////////////////////////////////////// float CalculaResistencia() { // Declaración de variables locales float Voltaje=0.0; float Corriente=0.0; // Datos por teclado: Corriente y Resistencia cout << "\n\t Ingresa el valor de la Tension V = "; cin>>Voltaje; cout << "\n\t Ahora el valor de la Corriente I = "; cin>>Corriente; // Verica que corriente sea cero, luego calcula voltaje if (Corriente==0) { cout << "\n\t OJO.!! Resistencia negativa.!!! "<<"\n"; return 0.0; } else return Voltaje/Corriente; } // Fin de la función CalculaResistencia
using System; namespace Pisis { static void Main(string[] args) { ////////////////////////////////////////////// // PARTE OPERATIVA ////////////////////////////////////////////// Console.WriteLine("\n H O R O S C O P O Wilo Carpio {0} \n", DateTime.Now); ////////////////////////////////////////////// // DECLARACION DE DE VARIABLES ////////////////////////////////////////////// string Amigo; string signo="Aries"; string x="n"; int DiaNacimiento,MesNacimiento,AnoNacimiento; ////////////////////////////////////////////// // FECHAS ACTUALES ////////////////////////////////////////////// int AnoActual = DateTime.Now.Year; int MesActual = DateTime.Now.Month; int DiaActual = DateTime.Now.Day; ////////////////////////////////////////////// // BUCLE PRINCIPAL ////////////////////////////////////////////// do { Console.Write("\n Decime tu nombre: "); Amigo=Console.ReadLine(); Console.WriteLine("\n"+Amigo+" vos naciste el:"); Console.Write("Dia: "); DiaNacimiento=Convert.ToInt16(Console.ReadLine()); Console.Write("Mes: "); MesNacimiento=Convert.ToInt16(Console.ReadLine()); Console.Write("Año: "); AnoNacimiento=Convert.ToInt16(Console.ReadLine());
////////////////////////////////////////////// // Determinación del signo ////////////////////////////////////////////// if ((MesNacimiento==3 && DiaNacimiento>=21)||(MesNacimiento==4 && DiaNacimiento<=20)) { signo="Aries"; } else { if ((MesNacimiento==4 && DiaNacimiento>=21)||(MesNacimiento==5 && DiaNacimiento<=20)) { signo="Tauro"; } else { if ((MesNacimiento==5 && DiaNacimiento>=21)||(MesNacimiento==6 && DiaNacimiento<=20)) { signo="Geminis"; } else { if ((MesNacimiento==6 && DiaNacimiento>=21)||(MesNacimiento==7 && DiaNacimiento<=20)) { signo="Cancer"; } else { if ((MesNacimiento==7 && DiaNacimiento>=21)||(MesNacimiento==8 && DiaNacimiento<=20)) { signo="Leo"; } else { if ((MesNacimiento==8 && DiaNacimiento>=21)||(MesNacimiento==9 && DiaNacimiento<=20)) { signo="Virgo"; } else { if ((MesNacimiento==9 && DiaNacimiento>=21)||(MesNacimiento==10 && DiaNacimiento<=20)) { signo="Libra"; } else { if ((MesNacimiento==10 && DiaNacimiento>=21)||(MesNacimiento==11 && DiaNacimiento<=20)) { signo="Escorpio"; } else { if ((MesNacimiento==11 && DiaNacimiento>=21)||(MesNacimiento==12 && DiaNacimiento<=20)) { signo="Sagitario"; } else { if ((MesNacimiento==12 && DiaNacimiento>=21)||(MesNacimiento==1 && DiaNacimiento<=20)) { signo="Capricornio"; } else { if ((MesNacimiento==1 && DiaNacimiento>=21)||(MesNacimiento==2 && DiaNacimiento<=20)) { signo="Acuario"; } else { if ((MesNacimiento==2 && DiaNacimiento>=21)||(MesNacimiento==3 && DiaNacimiento<=20)) { signo="Piscis"; } } } } } } } } } } } }
////////////////////////////////////////////// // Determinación de la edad ////////////////////////////////////////////// int Edad=AnoActual-AnoNacimiento; if(MesNacimiento>MesActual) { Edad=Edad-1; } else { if (MesNacimiento==MesActual) { if (DiaNacimiento>DiaActual) { Edad=Edad-1; } else { if(DiaNacimiento==DiaActual) { Console.WriteLine("Feliz Cumple"); } } } } ////////////////////////////////////////////// // Salida de resultados al monitor ////////////////////////////////////////////// Console.WriteLine("\n"+Amigo+" sos de Signo: "+signo+" y tenes "+Edad+" años \n\n"); Console.WriteLine(Amigo + " queres hacer otro calculo ? (s/n)"); x=Console.ReadLine(); } while (x=="s"); } } }
/////////////////////////////////////////////////////////// // C# PROGRAMA CONSOLA MODELO BASE 2006 Wilo Carpio // Manejo de estructuras simples 240706 // Control de datos sin archivo Hs.11.10 // Clases y Vectores /////////////////////////////////////////////////////////// using System; using System.Runtime.InteropServices; namespace SuperSoft { public class MiClase { [STAThread] ////////////////////////////////////////////////// // FUNCION PRINCIPAL ////////////////////////////////////////////////// static void Main(string[] args) { Pantalla("\t SOFTWARE LOCO"); Aguarda("\t\t\t\t\t\t ENTER para seguir"); MiClase MiMonitor = new MiClase(); string ClienteNombre; string[] ProductoPedido = new String[10]; string[] NominaDeClientes = new String[15]; string[,] Articulo = new string[15, 15]; int OpcionPrincipal, ClienteNumero = 0; double PrecioDeProducto, MontoEnCaja = 0;
do { OpcionPrincipal = OpcionMenuPrincipa(); switch (OpcionPrincipal) { ////////////////////////////////////////////////// // OPCION DE VENTAS ////////////////////////////////////////////////// case 1: int Indice = -1; double SubTotalCaja = 0; do { MenuVentas: MiMonitor.Limpiar(); MiClase.MatrizProductos(Articulo); switch (MiClase.VerMatriz(Articulo, "\n PRODUCTOS DISPONIBLES")) { case 1: Indice++; ProductoPedido[Indice] = "\t" + Articulo[1, 1] + "\t $" + Articulo[1, 2]; PrecioDeProducto = Convert.ToDouble(Articulo[1, 2]); break; case 2: Indice++; ProductoPedido[Indice] = "\t" + Articulo[2, 1] + "\t $" + Articulo[2, 2]; PrecioDeProducto = Convert.ToDouble(Articulo[2, 2]); break; case 3: Indice++; ProductoPedido[Indice] = "\t" + Articulo[3, 1] + "\t $" + Articulo[3, 2]; PrecioDeProducto = Convert.ToDouble(Articulo[3, 2]); break; case 4: Indice++; ProductoPedido[Indice] = "\t" + Articulo[4, 1] + "\t $" + Articulo[4, 2]; PrecioDeProducto = Convert.ToDouble(Articulo[4, 2]); break; default: Aguarda("METISTE MAL EL DEDO..!! Enter para volver"); goto MenuVentas; } SubTotalCaja = SubTotalCaja + PrecioDeProducto; } while (OtraVez("Queres comprar otro producto"));
MontoEnCaja = MontoEnCaja + SubTotalCaja; ClienteNumero = ClienteNumero + 1; ClienteNombre = LeerNombreCliente(); NominaDeClientes[ClienteNumero] = "\t" + ClienteNombre + "\t $" + SubTotalCaja / 100; ImprimeTicket(ClienteNombre, ProductoPedido, Indice, SubTotalCaja); break; ////////////////////////////////////////////////// // OPCION REPORTE TOTAL ////////////////////////////////////////////////// case 2: VerReporteDelDia(NominaDeClientes, ClienteNumero, MontoEnCaja); break; ////////////////////////////////////////////////// // OPCION ACERCA DE ////////////////////////////////////////////////// case 3: MiMonitor.Limpiar(); Pantalla("\twww.wilocarpio.com"); Aguarda("\t\t\t\t\t\t ENTER para seguir"); break; ////////////////////////////////////////////////// // SALIR DEL PROGRAMA ////////////////////////////////////////////////// case 4: Aguarda("CERRARAS EL PROGRAMA..!! Enter para seguir"); break; default: Aguarda(OpcionPrincipal + " Opción nula..!! METISTE MAL EL DEDO Enter para Volver"); break; } } while (OpcionPrincipal != 4); }
////////////////////////////////////////////////// // METODOS DEL PROGRAMA ////////////////////////////////////////////////// private const int EntradaManual = -11; private const byte EMPTY = 32; [StructLayout(LayoutKind.Sequential)] struct CoordenadaXY { public short x; public short y; } [StructLayout(LayoutKind.Sequential)] struct MiRectita { public short Left; public short Top; public short Right; public short Bottom; } [StructLayout(LayoutKind.Sequential)] struct MiMonitor { public CoordenadaXY dwSize; public CoordenadaXY dwCursorPosition; public int wAttributes; public MiRectita srWindow; public CoordenadaXY dwMaximumWindowSize; } [DllImport("kernel32.dll", EntryPoint = "GetStdHandle", SetLastError = true, CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)] private static extern int GetStdHandle(int nStdHandle); [DllImport("kernel32.dll", EntryPoint = "FillConsoleOutputCharacter", SetLastError = true, CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)] private static extern int FillConsoleOutputCharacter(int hConsoleOutput, byte cCharacter, int nLength, CoordenadaXY dwWriteCoordenadaXY, ref int lpNumberOfCharsWritten); [DllImport("kernel32.dll", EntryPoint = "GetConsoleScreenBufferInfo", SetLastError = true, CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)] private static extern int GetConsoleScreenBufferInfo(int hConsoleOutput, ref MiMonitor lpConsoleScreenBufferInfo); [DllImport("kernel32.dll", EntryPoint = "SetConsoleCursorPosition", SetLastError = true, CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)] private static extern int SetConsoleCursorPosition(int hConsoleOutput, CoordenadaXY dwCursorPosition); private int hConsoleHandle; public MiClase() { hConsoleHandle = GetStdHandle(EntradaManual); } public void Limpiar() { int EscribeCaracter = 0; MiMonitor strConsoleInfo = new MiMonitor(); CoordenadaXY Home; Home.x = Home.y = 0; GetConsoleScreenBufferInfo(hConsoleHandle, ref strConsoleInfo); FillConsoleOutputCharacter(hConsoleHandle, EMPTY, strConsoleInfo.dwSize.x * strConsoleInfo.dwSize.y, Home, ref EscribeCaracter); SetConsoleCursorPosition(hConsoleHandle, Home); }
static int OpcionMenuPrincipa() { MiClase MiMonitor = new MiClase(); MiMonitor.Limpiar(); Pantalla("\tMENU PRINCIPAL\n"); Console.WriteLine(" 1 → VENTAS"); Console.WriteLine("\n 2 → TOTAL VENTAS"); Console.WriteLine("\n 3 → ACERCA DE"); TrazarRayaSimple(78); Console.WriteLine("\n 4 → SALIR"); Console.Write("\n Digita opción (Luego ENTER): "); int OpcionElegida = Convert.ToInt32(Console.ReadLine()); return OpcionElegida; } static void TrazarRayaSimple(int TotalRayitas) { int i; for (i = 1; i <= TotalRayitas; i++) Console.Write("─"); } static bool OtraVez(string Pregunta) { bool Respuesta = false; string Opcion; Console.Write("\n\t" + Pregunta + "? (s/n)"); Opcion = Console.ReadLine(); if ((Opcion == "s") || (Opcion == "S")) Respuesta = true; return Respuesta; }
static void Aguarda(string Mensaje) { Console.Write("\n\t" + Mensaje); Console.ReadLine(); } static string LeerNombreCliente() { string nomCliente; TrazarRayaSimple(78); Console.Write("\n Nombre del cliente: "); nomCliente = Console.ReadLine(); return nomCliente; } static void Pantalla(string Mensaje) { int i; Console.Write("\n ╔"); for (i = 1; i <= 34; i++) Console.Write("═"); Console.WriteLine("╗"); Console.WriteLine(" ║ C#: Modelo Base 2006 ║"); Console.Write(" ╠"); for (i = 1; i <= 34; i++) Console.Write("═"); Console.WriteLine("╣"); Console.WriteLine(" ║ WILUCHA 1.0 ║"); Console.Write(" ╚"); for (i = 1; i <= 34; i++) Console.Write("═"); Console.Write("╝"); Console.WriteLine("\t\t\t\t\t\t" + Mensaje); }
static void MatrizProductos(string[,] Articulo) { Articulo[1, 1] = "Ventas y Facturación Win 1.0"; Articulo[1, 2] = "300.00"; Articulo[2, 1] = "Administración de Personal"; Articulo[2, 2] = "200.00"; Articulo[3, 1] = "Liquidación de Impuestos"; Articulo[3, 2] = "250.00"; Articulo[4, 1] = "Control de Compras y Stock"; Articulo[4, 2] = "300.00"; } static int VerMatriz(string[,] MatrizDeDatos, string Titulo) { int i; Pantalla(Titulo); Console.WriteLine("\n\t Art Precio Denominacion"); for (i = 1; i <= 4; i++) Console.WriteLine("\t {0}{1}{2}{3}{4}", i, "\t", MatrizDeDatos[i, 2], "\t", MatrizDeDatos[i, 1]); Console.Write("\n\n¿Qué producto deseas comprar?: "); int Opcion = Convert.ToInt32(System.Console.ReadLine()); return Opcion; } static void ImprimeTicket(string NombreCliente, string[] ProductoPedido, int iMax, double subTotal) { MiClase MiMonitor = new MiClase(); MiMonitor.Limpiar(); Pantalla("\n TICKET - " + DateTime.Now); Console.WriteLine(" Cliente Sr/Sra: " + NombreCliente); TrazarRayaSimple(78); Console.WriteLine(""); Console.WriteLine("\tPRODUCTO PRECIO "); for (int j = 0; j <= iMax; j++) Console.WriteLine(j + 1 + ProductoPedido[j]); Console.WriteLine("\n TOTAL : $" + subTotal / 100); TrazarRayaSimple(78); Aguarda("Gracias por tu compra ENTER para volver"); } static void VerReporteDelDia(string[] Cliente, int TotalClientes, double MontoEnCaja) { MiClase MiMonitor = new MiClase(); MiMonitor.Limpiar(); Console.WriteLine("\n\n REPORTE DÍA " + DateTime.Now); TrazarRayaSimple(78); Console.WriteLine("\n Nomina de Clientes: " + TotalClientes); for (int NroCliente = 0; NroCliente <= TotalClientes; NroCliente++) Console.WriteLine("\t" + Cliente[NroCliente]); Console.WriteLine("\n Recaudación : $" + MontoEnCaja / 100 + "\n"); TrazarRayaSimple(78); Aguarda("\n ENTER para volver al menú principal"); } } }
El siguiente ejemplo muestra los pasos para crear una aplicación de explorador web, que se puede personalizar con accesos directos a los sitios Web favoritos.
El formulario Windows Forms que se ve en la vista Diseñador es una representación visual de la ventana que se abrirá al abrir la aplicación. En la vista Diseñador, puede arrastrar diversos controles desde el Cuadro de herramientas hasta el formulario.
Estos controles no están realmente "activos"; son sólo imágenes que se pueden mover sin problemas por el formulario hasta ocupar un lugar preciso.
Una vez colocado un control en el formulario, Visual C# funciona en segundo plano para crear el código que hará que el control real ocupe la posición correcta cuando se ejecute el programa.
Este código fuente se encuentra en un archivo que, generalmente, permanece anidado fuera de la vista. Puede ver este archivo, denominado Form1.designer.cs, en el Explorador de soluciones si expande Form1.cs.
Ahora verá que el texto situado en la parte superior del formulario Windows Forms (en el área denominada barra de título) ha cambiado.
Para cambiar rápidamente el nombre de un control, haga clic con el botón secundario del mouse en el control y haga clic en Propiedades. Puede escribir el nuevo nombre para el control en la propiedad Name.
Estos elementos de menú forman los controles de navegación básicos del sitio Web.
Cuando mueva los controles en un formulario Windows Forms, verá aparecer líneas azules. Estas líneas son guías que ayudan a alinear los controles en dirección vertical y horizontal. También puede alinear controles seleccionando más de uno a la vez. Para ello, haga clic y arrastre un cuadro de selección alrededor de los controles, o mantenga presionada la tecla MAYÚS mientras hace clic en ellos.
Después de tener varios controles seleccionados, puede modificar la alineación y el tamaño utilizando los iconos de alineación y cambio de tamaño. Estos iconos aparecen en la Barra de herramientas de diseño, en la parte superior de la ventana Diseño.
Para crear la lista de sitios, seleccione el control ComboBox y vea sus propiedades. Seleccione la propiedad Items; verá la palabra (Colección) y un botón puntos suspensivos (...). Haga clic en este botón para modificar el contenido del control ComboBox.
Agregue tantas direcciones URL del sitio Web como desee, presionando RETORNO después de cada una. Asegúrese de incluir http:// delante de cada una de las direcciones de sitio web.
El control WebBrowser realiza todo el trabajo difícil de representación de páginas Web. El acceso a este control en la aplicación se realiza a través de una instancia de la clase WebBrowser. Observe form1.Designer.cs y verá que se ha agregado una instancia de esta clase al código de la aplicación, junto con instancias de clases que representan los demás elementos que se han agregado utilizando el diseñador.
Estas son las instancias que utilizará cuando agregue controladores de eventos para los controles y llame a los métodos de los citados controles.
El programa debe tener los controladores de eventos para el botón y para cada opción de menú. Un controlador de eventos es un método que se ejecuta cuando el usuario interactúa con el control. Visual C# Express crea automáticamente controladores de eventos vacíos.
Haga doble clic en el botón y verá aparecer el Editor de código para el proyecto. También verá que se ha creado el controlador para el evento Click, que es el mensaje que aparece cuando el usuario hace clic en un botón. Agregue código al método del controlador de eventos de modo similar al siguiente código.
private void goButton_Click(object sender, System.EventArgs e) { webBrowser1.Navigate(new Uri(comboBox1.SelectedItem.ToString())); }
private void homeToolStripMenuItem_Click(object sender, System.EventArgs e) { webBrowser1.GoHome(); } private void goForwardToolStripMenuItem_Click(object sender, System.EventArgs e) { webBrowser1.GoForward(); } private void goBackToolStripMenuItem_Click(object sender, System.EventArgs e) { webBrowser1.GoBack(); }
A partir de este código, puede ver que los nombres predeterminados dados a las opciones de menú pueden resultar muy confusos. Por esta razón, es una buena idea cambiar el nombre de cada control de menú al crearlo mediante el editor de Propiedades. El nombre del controlador reflejará entonces el nombre de la opción de menú.
Cuando un usuario final inicie el programa, Windows notificará este hecho al formulario de la aplicación enviando un evento Load. Cuando el formulario reciba ese evento, llamará al método Form1_Load. Los métodos a los que se llama en respuesta a eventos se denominan controladores de eventos.
El sistema llamará al evento en el momento adecuado; ahora tiene que colocar el código en el controlador de eventos que desee que se ejecute cuando se produzca el evento.
En la vista Código, agregue dos líneas al método Form1_Load, como se muestra a en el siguiente código. Esto hará que el control WebBrowser muestre la página principal predeterminada del equipo y establezca el valor inicial del control ComboBox.
private void Form1_Load(object sender, EventArgs e) { comboBox1.SelectedIndex = 0; webBrowser1.GoHome(); }
Con block de notas: escribir el siguiente código, guardarlo como .cs Ejemplo: MiFormu.cs
//////////////////////////////////////////////////////////////////////////// // C Sharp Wilo Carpio 27 Mayo 2007 // // GENERAR UN FORMULARIO POR CODIGO // ////////////////////////////////////////////////////////////////////////// using System; using System.Drawing; using System.Collections; using System.Windows.Forms; public class MainForm: Form { ////////////////////////////////////////////////// // Formulario principal ////////////////////////////////////////////////// public static void Main() { MainForm MiFormulario= new MainForm(); MiFormulario.Size = new System.Drawing.Size(600, 400); MiFormulario.Location=new Point(50,30); MiFormulario.Text= "Wilo Carpio"; Application.Run(MiFormulario); }
////////////////////////////////////////////////// // Objetos del formulario ////////////////////////////////////////////////// public MainForm() { // FOTO AUTOR PictureBox AutorFoto = new PictureBox(); AutorFoto.Location=new Point(10,10); AutorFoto.Size = new System.Drawing.Size(100, 100); Controls.Add(AutorFoto); // BOTON CERRAR PANEL AUTOR Button CerrarPanel = new Button(); CerrarPanel.Location = new Point(70, 220); CerrarPanel.Text = "Cerrar"; Controls.Add(CerrarPanel); // BOTON MOSTAR PAGE Button MiBotonPage = new Button(); MiBotonPage.Location=new Point(5,5); MiBotonPage.Text="Mi Page"; MiBotonPage.Click += new EventHandler(MiBotonPageClicked); Controls.Add(MiBotonPage); // BOTON CERRAR PROGRAMA Button BotonCerrar = new Button(); BotonCerrar.Location=new Point(5,30); BotonCerrar.Text="Salir"; BotonCerrar.Click += new EventHandler(BotonCerrarClicked); Controls.Add(BotonCerrar); // PANEL AUTOR Panel PanelAutor = new Panel(); PanelAutor.BackColor = System.Drawing.SystemColors.InactiveCaption; PanelAutor.Location=new Point(150,20); PanelAutor.Size = new System.Drawing.Size(200, 250); PanelAutor.Visible = false; PanelAutor.Controls.Add(AutorFoto); PanelAutor.Controls.Add(CerrarPanel); Controls.Add(PanelAutor); }
////////////////////////////////////////////////// // Eventos ////////////////////////////////////////////////// public void MiBotonPageClicked(object sender, EventArgs Arguments) { PanelAutor.Visible = true; Text = "Bienvenido a www.wilocarpio.com"; MessageBox.Show("www.wilocarpio.com"); } public void BotonCerrarClicked(object sender, EventArgs Arguments) { Text= "Adios amigo..!!"; MessageBox.Show("Estas por cerrar este formulario"); Close(); } public void BotonCerrarPanelClicked(object sender, EventArgs Argumens) { PanelAutor.Visible = false; } }
Microsoft Visual Studio\ Visual Studio Tools\ Simbolo del Sistema
Se abre una ventana tipo DOS:
C:\Archivos de programa\ Microsoft Visual Studio 8\VC>
C:\Archivos de programa\ Microsoft Visual Studio 8\VC>csc MiFormu.cs
BONUS TRACK !!!
//////////////////////////////////////////////////////////////////////////// // C# PROGRAMA WINDOW MODELO BASE CON ARCHIVO 2006 Wilo Carpio // 21 Mayo 2007 // // GENERAR UN FORMULARIO POR CODIGO // // 1. Con block de notas escribir el siguiente código, guardarlo como .cs // Ejemplo: MiFormu.cs // 2. Para compilar ir a "Simbolo del Sistema" Clickear en: // Microsoft Visual Studio\ Visual Studio Tools\ Simbolo del Sistema // Se abre una ventana tipo DOS: // C:\Archivos de programa\ Microsoft Visual Studio 8\VC> // 3. Completar: // C:\Archivos de programa\ Microsoft Visual Studio 8\VC>csc/t:winexe MiFormu.cs // 4. Si no hay errores, se genera un ejecutable Ej. MiFormu.exe // 5. Clickea sobre el ejecutable "MiFormu.exe" y veras el resultado. // ////////////////////////////////////////////////////////////////////////// using System; using System.Runtime.InteropServices; using System.IO; using System.Drawing; using System.Drawing.Printing; using System.Collections; using System.Windows.Forms; namespace Programa { public class MiFormulario:Form { //MAIN static void Main() { //CREAMOS MiFormulario MiFormulario MiFormulario = new MiFormulario(); MiFormulario.Size = new System.Drawing.Size(300, 200); MiFormulario.StartPosition = FormStartPosition.CenterScreen; MiFormulario.FormBorderStyle = FormBorderStyle.FixedSingle; MiFormulario.Text = "Wilo Carpio"; //LLAMAMOS A MiFormulario Application.EnableVisualStyles(); Application.Run(MiFormulario); } //DISEÑO //MiFormulario: PRESENTACION public MiFormulario() { //PANEL Panel UnPanel = new Panel(); UnPanel.Size = new System.Drawing.Size(200, 100); UnPanel.BorderStyle = BorderStyle.Fixed3D; UnPanel.Location = new Point(45, 12); Controls.Add(UnPanel); //LETRERO 1 Label Rotulo1 = new Label(); Rotulo1.Text = "C# Base Modelo 2006"; Rotulo1.Size = new Size(150, 15); Rotulo1.Font = new Font(Rotulo1.Font, FontStyle.Bold); Rotulo1.Location = new Point(45, 15); UnPanel.Controls.Add(Rotulo1); //LETRERO 2 Label Rotulo2 = new Label(); Rotulo2.Text = "Wilucha 1.0"; Rotulo2.Size = new Size(150, 15); Rotulo2.Location = new Point(65, 40); UnPanel.Controls.Add(Rotulo2); //LETRERO 3 Label Rotulo3 = new Label(); Rotulo3.Text = "SOFTWARE LOCO"; Rotulo3.Size = new Size(150, 15); Rotulo3.Font = new Font(Rotulo3.Font, FontStyle.Italic); Rotulo3.Location = new Point(50, 65); UnPanel.Controls.Add(Rotulo3); //BOTON EntrarBoton Button EntrarBoton = new Button(); EntrarBoton.Location = new Point(60, 130); EntrarBoton.Text = "Entrar"; EntrarBoton.Click += new EventHandler(BotonEntrarBotonClick); Controls.Add(EntrarBoton); //BOTON SalirBoton Button SalirBoton = new Button(); SalirBoton.Location = new Point(160, 130); SalirBoton.Text = "Salir"; SalirBoton.Click += new EventHandler(BotonSalirBotonClick); Controls.Add(SalirBoton); } //EVENTOS: //BOTON EntrarBoton public void BotonEntrarBotonClick(object sender, EventArgs Arguments) { this.Hide(); FormularioMenu FormularioMenu = new FormularioMenu(); FormularioMenu.Size = new System.Drawing.Size(600, 370); FormularioMenu.StartPosition = FormStartPosition.CenterScreen; FormularioMenu.FormBorderStyle = FormBorderStyle.FixedSingle; FormularioMenu.Text = "Menú Principal"; FormularioMenu.Show(); } //BOTON SalirBoton public void BotonSalirBotonClick(object sender, EventArgs Arguments) { Text = "Adios amigo..!"; MessageBox.Show("Estas por cerrar el programa","SalirBoton",MessageBoxButtons.OK,MessageBoxIcon.Stop); Application.Exit(); } } public class FormularioMenu : Form { //DISEÑO //FORMA 2: MENU PRINCIPAL public FormularioMenu() { //PANEL Panel UnPanel = new Panel(); UnPanel.Size = new System.Drawing.Size(570, 50); UnPanel.BorderStyle = BorderStyle.Fixed3D; UnPanel.Location = new Point(10, 10); Controls.Add(UnPanel); //PANEL 2 Panel OtroPanel = new Panel(); OtroPanel.Size = new System.Drawing.Size(570, 220); OtroPanel.BorderStyle = BorderStyle.Fixed3D; OtroPanel.Location = new Point(10, 70); Controls.Add(OtroPanel); //LETRERO 1 Label Rotulo1 = new Label(); Rotulo1.Text = "C# Base Modelo 2006"; Rotulo1.Size = new Size(150, 15); Rotulo1.Font = new Font(Rotulo1.Font, FontStyle.Bold); Rotulo1.Location = new Point(45, 15); UnPanel.Controls.Add(Rotulo1); //LETRERO 2 Label Rotulo2 = new Label(); Rotulo2.Text = "Wilucha 1.0"; Rotulo2.Size = new Size(150, 15); Rotulo2.Font = new Font(Rotulo1.Font, FontStyle.Bold); Rotulo2.Location = new Point(250, 15); UnPanel.Controls.Add(Rotulo2); //LETRERO 3 Label Rotulo3 = new Label(); Rotulo3.Text = "SOFTWARE LOCO"; Rotulo3.Size = new Size(150, 15); Rotulo3.Font = new Font(Rotulo3.Font, FontStyle.Bold); Rotulo3.Location = new Point(400, 15); UnPanel.Controls.Add(Rotulo3); //BOTON VENTAS Button Ventas = new Button(); Ventas.Location = new Point(10, 10); Ventas.Text = "Vender Producto"; Ventas.Size = new Size(550, 20); Ventas.Click += new EventHandler(BotonVentasClick); OtroPanel.Controls.Add(Ventas); //BOTON VER NOMINA DE CLIENTES Button Ver = new Button(); Ver.Location = new Point(10, 50); Ver.Text = "Ver Nómina de Clientes"; Ver.Size = new Size(550, 20); Ver.Click += new EventHandler(BotonVerClick); OtroPanel.Controls.Add(Ver); //BOTON VER Lista DE PRODUCTOS Button BotonVerLista = new Button(); BotonVerLista.Location = new Point(10, 90); BotonVerLista.Text = "Ver Lista de Productos"; BotonVerLista.Size = new Size(550, 20); BotonVerLista.Click += new EventHandler(BotonBotonVerListaClick); OtroPanel.Controls.Add(BotonVerLista); //BOTON ACERCA DE Button Acerca = new Button(); Acerca.Location = new Point(10, 170); Acerca.Text = "Acerca de..."; Acerca.Size = new Size(550, 20); Acerca.Click += new EventHandler(BotonAcercaClick); OtroPanel.Controls.Add(Acerca); //BOTON BotonAlta Button BotonAlta = new Button(); BotonAlta.Location = new Point(10, 130); BotonAlta.Text = "Alta Producto"; BotonAlta.Size = new Size(550, 20); BotonAlta.Click += new EventHandler(BotonBotonAltaClick); OtroPanel.Controls.Add(BotonAlta); //BOTON SalirBoton Button SalirBoton = new Button(); SalirBoton.Location = new Point(260, 300); SalirBoton.Text = "Salir"; SalirBoton.Click += new EventHandler(BotonSalirBotonClick); Controls.Add(SalirBoton); } //EVENTOS //BOTON SalirBoton public void BotonSalirBotonClick(object sender, EventArgs Arguments) { Text = "Adios amigo..!"; MessageBox.Show("Estas por cerrar el programa", "Salir", MessageBoxButtons.OK, MessageBoxIcon.Stop); Application.Exit(); File.Delete("C:\\temp3.txt"); } //BOTON BotonAlta public void BotonBotonAltaClick(object sender, EventArgs Arguments) { PanelAltas PanelAltas = new PanelAltas(); PanelAltas.Size = new System.Drawing.Size(400, 200); PanelAltas.StartPosition = FormStartPosition.CenterScreen; PanelAltas.FormBorderStyle = FormBorderStyle.FixedSingle; PanelAltas.Text = "Alta"; Close(); PanelAltas.Show(); } //BOTON ACERCA DE public void BotonAcercaClick(object sender, EventArgs Arguments) { PanelAcercaDe PanelAcercaDe = new PanelAcercaDe(); PanelAcercaDe.Size = new Size(200, 200); PanelAcercaDe.StartPosition = FormStartPosition.CenterScreen; PanelAcercaDe.FormBorderStyle = FormBorderStyle.FixedSingle; PanelAcercaDe.Text = "Acerca de..."; Close(); PanelAcercaDe.Show(); } //BOTON VER BotonVerLista DE PRODUCTOS public void BotonBotonVerListaClick(object sender, EventArgs Arguments) { PanelListar PanelListar = new PanelListar(); PanelListar.Size = new Size(370, 470); PanelListar.StartPosition = FormStartPosition.CenterScreen; PanelListar.FormBorderStyle = FormBorderStyle.FixedSingle; PanelListar.Text = "Lista de Productos"; Close(); PanelListar.Show(); } //BOTON VER NOMINA DE CLIENTES public void BotonVerClick(object sender, EventArgs Arguments) { PanelListarClientes PanelListarClientes = new PanelListarClientes(); PanelListarClientes.Size = new Size(370, 470); PanelListarClientes.StartPosition = FormStartPosition.CenterScreen; PanelListarClientes.FormBorderStyle = FormBorderStyle.FixedSingle; PanelListarClientes.Text = "Nómina de Clientes"; Close(); PanelListarClientes.Show(); } //BOTON VENTAS public void BotonVentasClick(object sender, EventArgs Arguments) { File.Delete("C:\\temp.txt"); File.Delete("C:\\temp2.txt"); PanelVentas PanelVentas = new PanelVentas(); PanelVentas.Size = new Size(370, 470); PanelVentas.StartPosition = FormStartPosition.CenterScreen; PanelVentas.FormBorderStyle = FormBorderStyle.FixedSingle; PanelVentas.Text = "Ventas"; Close(); PanelVentas.Show(); } } public class PanelAltas : Form { //VARIABLES public string[,] UnaMatriz = new string[15,2]; public int i = 0; StreamWriter ArchDeEscritura,ArchDeEscritura2; StreamReader ArchDeLectura,ArchDeLectura2; private System.Windows.Forms.TextBox textbox1; private System.Windows.Forms.TextBox textbox2; //DISEÑO //FORMA 3: BotonAlta PRODUCTO public PanelAltas() { //LABEL NOMBRE Label Rotulo1 = new Label(); Rotulo1.Text = "Nombre del Producto"; Rotulo1.Size = new Size(120, 15); Rotulo1.Location = new Point(20, 20); Controls.Add(Rotulo1); //TEXTBOX NOMBRE this.textbox1 = new System.Windows.Forms.TextBox(); textbox1.Size = new Size(200, 20); textbox1.Location = new Point(150, 20); Controls.Add(textbox1); //LABEL PRECIO Label Rotulo2 = new Label(); Rotulo2.Text = "Precio del Producto"; Rotulo2.Size = new Size(120, 15); Rotulo2.Location = new Point(20, 60); Controls.Add(Rotulo2); //TEXTBOX PRECIO this.textbox2 = new System.Windows.Forms.TextBox(); textbox2.Location = new Point(150, 60); textbox2.Size = new Size(200, 20); Controls.Add(textbox2); //BOTON ACEPTAR Button Aceptar = new Button(); Aceptar.Location = new Point(20, 100); Aceptar.Text = "Aceptar"; Aceptar.Click += new EventHandler(BotonAceptarClick); Controls.Add(Aceptar); //BOTON VOLVER Button Volver = new Button(); Volver.Location = new Point(120, 100); Volver.Text = "Volver"; Volver.Click += new EventHandler(BotonVolverClick); Controls.Add(Volver); } //EVENTOS //BOTON VOLVER public void BotonVolverClick(object sender, EventArgs Arguments) { Close(); FormularioMenu FormularioMenu = new FormularioMenu(); FormularioMenu.Size = new System.Drawing.Size(600, 370); FormularioMenu.StartPosition = FormStartPosition.CenterScreen; FormularioMenu.FormBorderStyle = FormBorderStyle.FixedSingle; FormularioMenu.Text = "Menú Principal"; FormularioMenu.Show(); } //BOTON ACEPTAR public void BotonAceptarClick(object sender, EventArgs Arguments) { if (textbox1.Text != "" && textbox2.Text != "") { if (!File.Exists("C:\\Productos.txt")) { StreamWriter ArchDeEscritura = new StreamWriter("C:\\Productos.txt"); ArchDeEscritura.WriteLine(textbox1.Text); StreamWriter ArchDeEscritura2 = new StreamWriter("C:\\Precios.txt"); ArchDeEscritura2.WriteLine(textbox2.Text); ArchDeEscritura.Close(); ArchDeEscritura2.Close(); MessageBox.Show("El Producto fue introducido", "Alta Producto", MessageBoxButtons.OK, MessageBoxIcon.Exclamation); } else { try { ListBox l = new ListBox(); ListBox l2 = new ListBox(); int cont = 0; ArchDeLectura = new StreamReader("C:\\Productos.txt"); ArchDeLectura2 = new StreamReader("C:\\Precios.txt"); string linea; string linea2; linea = ArchDeLectura.ReadLine(); linea2 = ArchDeLectura2.ReadLine(); while (linea != null) { l.Items.Add(linea); l2.Items.Add(linea2); cont = cont + 1; linea = ArchDeLectura.ReadLine(); linea2 = ArchDeLectura2.ReadLine(); } l.Items.Add(textbox1.Text); l2.Items.Add(textbox2.Text); cont = cont + 1; ArchDeLectura.Close(); ArchDeLectura2.Close(); ArchDeEscritura = new StreamWriter("C:\\Productos.txt"); ArchDeEscritura2 = new StreamWriter("C:\\Precios.txt"); for (int i = 0; i < cont; i++) { ArchDeEscritura.WriteLine(l.Items[i]); ArchDeEscritura2.WriteLine(l2.Items[i]); } ArchDeEscritura.Close(); ArchDeEscritura2.Close(); textbox1.Clear(); textbox2.Clear(); MessageBox.Show("El Producto fue introducido", "Alta Producto", MessageBoxButtons.OK, MessageBoxIcon.Exclamation); } catch { MessageBox.Show("El Producto no pudo ser introducido", "Alta Producto", MessageBoxButtons.OK, MessageBoxIcon.Error); } } } else { MessageBox.Show("Complete los dos campos", "Alta Producto", MessageBoxButtons.OK, MessageBoxIcon.Exclamation); } } } public class PanelAcercaDe : Form { //DISEÑO //FORMA 4: ACERCA DE public PanelAcercaDe() { //PANEL Panel UnPanel = new Panel(); UnPanel.Size = new System.Drawing.Size(175, 100); UnPanel.BorderStyle = BorderStyle.Fixed3D; UnPanel.Location = new Point(10, 12); Controls.Add(UnPanel); //LETRERO 1 Label Rotulo1 = new Label(); Rotulo1.Text = "C# Base Modelo 2006"; Rotulo1.Size = new Size(150, 15); Rotulo1.Font = new Font(Rotulo1.Font, FontStyle.Bold); Rotulo1.Location = new Point(35, 15); UnPanel.Controls.Add(Rotulo1); //LETRERO 2 Label Rotulo2 = new Label(); Rotulo2.Text = "Wilucha 1.0"; Rotulo2.Size = new Size(150, 15); Rotulo2.Font = new Font(Rotulo2.Font, FontStyle.Bold); Rotulo2.Location = new Point(35, 35); UnPanel.Controls.Add(Rotulo2); //LETRERO 3 Label Rotulo3 = new Label(); Rotulo3.Text = "SOFTWARE LOCO"; Rotulo3.Size = new Size(150, 15); Rotulo3.Font = new Font(Rotulo3.Font, FontStyle.Bold); Rotulo3.Location = new Point(35, 55); UnPanel.Controls.Add(Rotulo3); //LETRERO 4 Label lab4 = new Label(); lab4.Text = "www.wilocarpio.com"; lab4.Size = new Size(150, 15); lab4.Font = new Font(lab4.Font, FontStyle.Bold); lab4.Location = new Point(35, 75); UnPanel.Controls.Add(lab4); //BOTON VOLVER Button Volver = new Button(); Volver.Location = new Point(60,125); Volver.Text = "Volver"; Volver.Click += new EventHandler(BotonVolverClick); Controls.Add(Volver); } //EVENTOS //BOTON VOLVER public void BotonVolverClick(object sender, EventArgs Arguments) { Close(); FormularioMenu FormularioMenu = new FormularioMenu(); FormularioMenu.Size = new System.Drawing.Size(600, 370); FormularioMenu.StartPosition = FormStartPosition.CenterScreen; FormularioMenu.FormBorderStyle = FormBorderStyle.FixedSingle; FormularioMenu.Text = "Menú Principal"; FormularioMenu.Show(); } } public class PanelListarClientes : Form { //DISEÑO //FORMA 7: VER NOMINA DE CLIENTES public PanelListarClientes() { //BotonVerLista ListBox BotonVerLista = new ListBox(); BotonVerLista.Size = new Size(340, 380); BotonVerLista.Location = new Point(12, 12); Controls.Add(BotonVerLista); //BOTON VOLVER Button Volver = new Button(); Volver.Location = new Point(150, 400); Volver.Text = "Volver"; Volver.Click += new EventHandler(BotonVolverClick); Controls.Add(Volver); if (File.Exists("C:\\Ventas.txt")) { StreamReader ArchDeLectura = new StreamReader("C:\\Ventas.txt"); string linea; linea = ArchDeLectura.ReadLine(); while (linea != null) { BotonVerLista.Items.Add(linea); linea = ArchDeLectura.ReadLine(); } ArchDeLectura.Close(); } else { MessageBox.Show("El Archivo de nómina no se encuentra", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } } //EVENTOS public void BotonVolverClick(object sender, EventArgs Arguments) { Close(); FormularioMenu FormularioMenu = new FormularioMenu(); FormularioMenu.Size = new System.Drawing.Size(600, 370); FormularioMenu.StartPosition = FormStartPosition.CenterScreen; FormularioMenu.FormBorderStyle = FormBorderStyle.FixedSingle; FormularioMenu.Text = "Menú Principal"; FormularioMenu.Show(); } } public class PanelVentas : Form { public System.Windows.Forms.TextBox textbox1; private System.Windows.Forms.ListBox BotonVerLista; private System.Windows.Forms.ListBox BotonVerLista2; public string[,] UnaMatriztor = new string[50, 2]; int iUnaMatriz = 0; double tot = 0; //DISEÑO //FORMA 8: VENTAS public PanelVentas() { //BotonVerLista this.BotonVerLista = new System.Windows.Forms.ListBox(); BotonVerLista.Size = new Size(300,340); BotonVerLista.Location = new Point(12,12); Controls.Add(BotonVerLista); //BotonVerLista2 this.BotonVerLista2 = new System.Windows.Forms.ListBox(); BotonVerLista2.Size = new Size(40, 340); BotonVerLista2.Location = new Point(310, 12); Controls.Add(BotonVerLista2); //LETRERO Label Rotulo1 = new Label(); Rotulo1.Text = "Nombre del Cliente"; Rotulo1.Size = new Size(110, 15); Rotulo1.Location = new Point(35, 365); Controls.Add(Rotulo1); //TEXTBOX this.textbox1 = new System.Windows.Forms.TextBox(); textbox1.Size = new Size(200, 20); textbox1.Location = new Point(150, 360); Controls.Add(textbox1); //BOTON COMPRAR Button Comprar = new Button(); Comprar.Location = new Point(100, 400); Comprar.Text = "Comprar"; Comprar.Click += new EventHandler(BotonComprarClick); Controls.Add(Comprar); //BOTON VOLVER Button Volver = new Button(); Volver.Location = new Point(200, 400); Volver.Text = "Volver"; Volver.Click += new EventHandler(BotonVolverClick); Controls.Add(Volver); if (File.Exists("C:\\Productos.txt")) { StreamReader ArchDeLectura = new StreamReader("C:\\Productos.txt"); StreamReader ArchDeLectura2 = new StreamReader("C:\\Precios.txt"); string linea; string linea2; linea = ArchDeLectura.ReadLine(); linea2 = ArchDeLectura2.ReadLine(); while (linea != null) { BotonVerLista.Items.Add(linea); BotonVerLista2.Items.Add(linea2); linea = ArchDeLectura.ReadLine(); linea2 = ArchDeLectura2.ReadLine(); } ArchDeLectura.Close(); ArchDeLectura2.Close(); } else { MessageBox.Show("El Archivo de los productos no se encuentra", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } } //EVENTOS //BOTON VOLVER public void BotonVolverClick(object sender, EventArgs Arguments) { Close(); FormularioMenu FormularioMenu = new FormularioMenu(); FormularioMenu.Size = new System.Drawing.Size(600, 370); FormularioMenu.StartPosition = FormStartPosition.CenterScreen; FormularioMenu.FormBorderStyle = FormBorderStyle.FixedSingle; FormularioMenu.Text = "Menú Principal"; FormularioMenu.Show(); } //BOTON COMPRAR public void BotonComprarClick(object sender, EventArgs Arguments) { if (BotonVerLista.SelectedIndex != -1 && textbox1.Text != "") { if(MessageBox.Show("¿Está seguro que quiere comprar el producto " + BotonVerLista.SelectedItem.ToString() + "?", "¿Comprar Producto?", MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation) == DialogResult.Yes) { UnaMatriztor[iUnaMatriz, 0] = BotonVerLista.SelectedItem.ToString(); BotonVerLista2.SelectedIndex = BotonVerLista.SelectedIndex; UnaMatriztor[iUnaMatriz, 1] = BotonVerLista2.SelectedItem.ToString(); iUnaMatriz++; if (!File.Exists("C:\\temp.txt")) { StreamWriter ArchDeEscriturat = new StreamWriter("C:\\temp.txt"); ArchDeEscriturat.WriteLine(textbox1.Text); ArchDeEscriturat.WriteLine(UnaMatriztor[iUnaMatriz - 1, 0] + " " + UnaMatriztor[iUnaMatriz - 1, 1]); ArchDeEscriturat.Close(); } else { ListBox l = new ListBox(); int cont = 0; StreamReader ArchDeLecturat = new StreamReader("C:\\temp.txt"); string linea; linea = ArchDeLecturat.ReadLine(); while (linea != null) { l.Items.Add(linea); cont = cont + 1; linea = ArchDeLecturat.ReadLine(); } l.Items.Add(UnaMatriztor[iUnaMatriz - 1, 0] + " " + UnaMatriztor[iUnaMatriz - 1, 1]); cont = cont + 1; ArchDeLecturat.Close(); StreamWriter ArchDeEscriturat = new StreamWriter("C:\\temp.txt"); for (int k = 0; k < cont; k++) { ArchDeEscriturat.WriteLine(l.Items[k]); } ArchDeEscriturat.Close(); } tot = tot + Convert.ToDouble(UnaMatriztor[iUnaMatriz-1, 1]); if (MessageBox.Show("¿Desea Comprar otro Producto?", "Comprar Producto", MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation) == DialogResult.No) { if (!File.Exists("C:\\Ventas.txt")) { StreamWriter ArchDeEscritura = new StreamWriter("C:\\Ventas.txt"); ArchDeEscritura.WriteLine(textbox1.Text); for(int j=0;j<=iUnaMatriz;j++) { ArchDeEscritura.WriteLine(UnaMatriztor[j, 0] + " " + UnaMatriztor[j, 1]); } ArchDeEscritura.Close(); } else { ListBox l = new ListBox(); int cont = 0; StreamReader ArchDeLectura = new StreamReader("C:\\Ventas.txt"); string linea; linea = ArchDeLectura.ReadLine(); while (linea != null) { l.Items.Add(linea); cont = cont + 1; linea = ArchDeLectura.ReadLine(); } l.Items.Add(textbox1.Text); cont = cont + 1; for (int j = 0; j <= iUnaMatriz; j++) { l.Items.Add(UnaMatriztor[j, 0] + " " + UnaMatriztor[j, 1]); cont = cont + 1; } ArchDeLectura.Close(); StreamWriter ArchDeEscritura = new StreamWriter("C:\\Ventas.txt"); for (int k = 0; k < cont; k++) { ArchDeEscritura.WriteLine(l.Items[k]); } ArchDeEscritura.Close(); } StreamWriter ArchDeEscriturat2 = new StreamWriter("C:\\temp2.txt"); ArchDeEscriturat2.WriteLine(Convert.ToString(tot)); ArchDeEscriturat2.Close(); Close(); PanelTicket PanelTicket = new PanelTicket(); PanelTicket.Size = new System.Drawing.Size(600, 450); PanelTicket.StartPosition = FormStartPosition.CenterScreen; PanelTicket.FormBorderStyle = FormBorderStyle.FixedSingle; PanelTicket.Text = "Ticket"; PanelTicket.Show(); } } } else { MessageBox.Show("Elija los productos e ingrese el nombre del cliente", "Comprar Producto", MessageBoxButtons.OK, MessageBoxIcon.Exclamation); } } } public class PanelTicket : Form { private System.Windows.Forms.ListBox BotonVerLista; private Font printFont; StreamReader streamToPrint; StreamReader ArchDeLectura = new StreamReader("C:\\temp.txt"); StreamReader ArchDeLectura2 = new StreamReader("C:\\temp2.txt"); StreamWriter ArchImpresion = new StreamWriter("C:\\print.txt"); //DISEÑO //FORMA 8: VENTAS public PanelTicket() { //TICKET this.BotonVerLista = new System.Windows.Forms.ListBox(); BotonVerLista.Size = new Size(400, 340); BotonVerLista.Location = new Point(12, 12); Controls.Add(BotonVerLista); //BOTON IMPRIMIR TICKET Button Imprimir = new Button(); Imprimir.Location = new Point(450, 50); Imprimir.Text = "Imprimir"; Imprimir.Click += new EventHandler(BotonImprimirClick); Controls.Add(Imprimir); //BOTON VOLVER Button Volver = new Button(); Volver.Location = new Point(450, 100); Volver.Text = "Volver"; Volver.Click += new EventHandler(BotonVolverClick); Controls.Add(Volver); //DATOS DEL TICKET BotonVerLista.Items.Add("C# Modelo Base 2006"); ArchImpresion.WriteLine("C# Modelo Base 2006"); BotonVerLista.Items.Add(""); ArchImpresion.WriteLine(""); BotonVerLista.Items.Add("TICKET"); ArchImpresion.WriteLine("TICKET"); BotonVerLista.Items.Add(""); ArchImpresion.WriteLine(""); BotonVerLista.Items.Add("Fecha: " + DateTime.Now.ToShortDateString()); ArchImpresion.WriteLine("Fecha: " + DateTime.Now.ToShortDateString()); BotonVerLista.Items.Add(""); ArchImpresion.WriteLine(""); BotonVerLista.Items.Add("Hora: " + DateTime.Now.ToShortTimeString()); ArchImpresion.WriteLine("Hora: " + DateTime.Now.ToShortTimeString()); BotonVerLista.Items.Add(""); ArchImpresion.WriteLine(""); string cli; cli = ArchDeLectura.ReadLine(); BotonVerLista.Items.Add("Cliente: " + cli); ArchImpresion.WriteLine("Cliente: " + cli); BotonVerLista.Items.Add(""); ArchImpresion.WriteLine(""); BotonVerLista.Items.Add("Productos:"); ArchImpresion.WriteLine("Productos:"); BotonVerLista.Items.Add(""); ArchImpresion.WriteLine(""); string a; a = ArchDeLectura.ReadLine(); while(a != null) { BotonVerLista.Items.Add(a); ArchImpresion.WriteLine(a); a = ArchDeLectura.ReadLine(); } BotonVerLista.Items.Add(""); ArchImpresion.WriteLine(""); a=ArchDeLectura2.ReadLine(); BotonVerLista.Items.Add("Total: $" + a); ArchImpresion.WriteLine("Total: $" + a); ArchDeLectura.Close(); ArchDeLectura2.Close(); ArchImpresion.Close(); } //EVENTOS //BOTON IMPRIMIR TICKET public void BotonImprimirClick(object sender, EventArgs Arguments) { try { streamToPrint = new StreamReader("C:\\print.txt"); try { printFont = new Font("Arial", 10); PrintDocument DocumentoDeImpresion = new PrintDocument(); DocumentoDeImpresion.PrintPage += new PrintPageEventHandler(this.DocumentoDeImpresion_PrintPage); DocumentoDeImpresion.Print(); } finally { streamToPrint.Close(); } } catch { MessageBox.Show("No se puede imprimir", "Error al imprimir", MessageBoxButtons.OK, MessageBoxIcon.Error); } } //Calculo para imprimir private void DocumentoDeImpresion_PrintPage(object sender, PrintPageEventArgs ev) { float lineArchImpresionerPage = 0; float yPos = 0; int count = 0; float leftMargin = ev.MarginBounds.Left; float topMargin = ev.MarginBounds.Top; string line = null; // Calcula el numero de linea por pagina lineArchImpresionerPage = ev.MarginBounds.Height / printFont.GetHeight(ev.Graphics); // Imprime cada linea del archivo while (count < lineArchImpresionerPage && ((line = streamToPrint.ReadLine()) != null)) { yPos = topMargin + (count * printFont.GetHeight(ev.Graphics)); ev.Graphics.DrawString(line, printFont, Brushes.Black, leftMargin, yPos, new StringFormat()); count++; } // Si hay más lineas imprime otra pagina if (line != null) ev.HasMorePages = true; else ev.HasMorePages = false; } //Boton VOLVER public void BotonVolverClick(object sender, EventArgs Arguments) { Close(); FormularioMenu FormularioMenu = new FormularioMenu(); FormularioMenu.Size = new System.Drawing.Size(600, 370); FormularioMenu.StartPosition = FormStartPosition.CenterScreen; FormularioMenu.FormBorderStyle = FormBorderStyle.FixedSingle; FormularioMenu.Text = "Menú Principal"; File.Delete("C:\\print.txt"); FormularioMenu.Show(); } } public class PanelListar : Form { private System.Windows.Forms.ListBox BotonVerLista; public PanelListar() { //BotonVerLista this.BotonVerLista = new System.Windows.Forms.ListBox(); BotonVerLista.Size = new Size(340, 390); BotonVerLista.Location = new Point(12, 12); Controls.Add(BotonVerLista); //BOTON VOLVER Button Volver = new Button(); Volver.Location = new Point(145, 400); Volver.Text = "Volver"; Volver.Click += new EventHandler(BotonVolverClick); Controls.Add(Volver); if (File.Exists("C:\\Productos.txt")) { StreamReader ArchDeLectura = new StreamReader("C:\\Productos.txt"); string linea; linea = ArchDeLectura.ReadLine(); while (linea != null) { BotonVerLista.Items.Add(linea); linea = ArchDeLectura.ReadLine(); } ArchDeLectura.Close(); } else { MessageBox.Show("El Archivo de Productos no se encuentra", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } } //EVENTOS //Boton VOLVER public void BotonVolverClick(object sender, EventArgs Arguments) { Close(); FormularioMenu FormularioMenu = new FormularioMenu(); FormularioMenu.Size = new System.Drawing.Size(600, 370); FormularioMenu.StartPosition = FormStartPosition.CenterScreen; FormularioMenu.FormBorderStyle = FormBorderStyle.FixedSingle; FormularioMenu.Text = "Menú Principal"; FormularioMenu.Show(); } } }
/////////////////////////////////////////////////////////////////// // MOVER UN AUTOMATA Wilo Carpio 26/10/09 // C#.NET /////////////////////////////////////////////////////////////////// using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; namespace MoverAutomata { public partial class FormuWilo : Form { public FormuWilo() { InitializeComponent(); } private void salirToolStripMenuItem1_Click(object sender, EventArgs e) { Close(); } private void pictCerrarAutomata_Click(object sender, EventArgs e) { panelAutomata.Visible = false; } private void picFlechaLeft_Click(object sender, EventArgs e) { int x = picPC.Location.X; int y = picPC.Location.Y; x = x - 5; picPC.Location = new System.Drawing.Point(x, y); } private void picFlechaDown_Click(object sender, EventArgs e) { int x = picPC.Location.X; int y = picPC.Location.Y; y = y + 5; picPC.Location = new System.Drawing.Point(x, y); } private void picUp_Click(object sender, EventArgs e) { int x = picPC.Location.X; int y = picPC.Location.Y; y = y - 5; picPC.Location = new System.Drawing.Point(x, y); } private void picFlechaRight_Click(object sender, EventArgs e) { int x = picPC.Location.X; int y = picPC.Location.Y; x = x + 5; picPC.Location = new System.Drawing.Point(x, y); } private void ejemploToolStripMenuItem_Click(object sender, EventArgs e) { panelAutomata.Visible = true; } private void picCerrarLenguaje_Click(object sender, EventArgs e) { panelLenguaje.Visible = false; } private void ejemplo1ToolStripMenuItem_Click(object sender, EventArgs e) { panelLenguaje.Visible = true; textBoxCadena.Focus(); } private void buttonLeerCad_Click(object sender, EventArgs e) { string a = textBoxCadena.Text; bool OtraLetra = false; int i,c=0,d=0; labelLenguaje.Visible = true; CadenaDigitada.Visible = true; CadenaDigitada.Text = Convert.ToString(a[0]); for (i = 1; i < a.Length; i++) { CadenaDigitada.Text = CadenaDigitada.Text + " " + Convert.ToString(a[i]); } for (i = 0; i < a.Length; i++) { if (a[i] == 'c' || a[i] == 'b' || a[i] == 'd') OtraLetra = false; else { OtraLetra = true; break; } if (a[i] == 'c' && d == 0) c++; else if (a[i] == 'd') d++; else if (a[i] == 'b' && d==1) c--; } if (OtraLetra) labelNoPertenece.Visible = true; else if (c == 0 && d==1) labelPertenece.Visible = true; else labelNoPertenece.Visible = true; buttoNuevaCadena.Visible = true; } private void buttoNuevaCadena_Click(object sender, EventArgs e) { labelLenguaje.Visible = false; CadenaDigitada.Visible = false; labelPertenece.Visible = false; labelNoPertenece.Visible = false; buttoNuevaCadena.Visible = false; textBoxCadena.Text = ""; textBoxCadena.Focus(); } private void salirToolStripMenuItem_Click(object sender, EventArgs e) { Close(); } private void picCerrarGramatica_Click(object sender, EventArgs e) { panelGramatica.Visible = false; GeneraCadena.Visible = false; GeneraCadena.Text = "Cadena generada"; Cadena.Text = ""; } private void ejemplo2ToolStripMenuItem_Click(object sender, EventArgs e) { panelGramatica.Visible = true; } private void picClick1_Click_1(object sender, EventArgs e) { picCabezal.Visible = true; int x = picCabezal.Location.X; int y = picCabezal.Location.Y; x = x + 60; picCabezal.Location = new System.Drawing.Point(x, y); switch (x) { case 70: Cadena.Text = textProduc1.Text; GeneraCadena.Text = "Producción usada: " + textProduc1.Text; break; case 130: Cadena.Text = Cadena.Text + " -> wiX "; GeneraCadena.Text = "Producción usada: " + textProduc2.Text; break; case 190: Cadena.Text = Cadena.Text + " -> wilY "; GeneraCadena.Text = "Producción usada: " + textProduc3.Text; break; case 250: Cadena.Text = Cadena.Text + " -> wil? "; GeneraCadena.Text = "Producción usada: " + textProduc4.Text; break; case 310: Cadena.Text = Cadena.Text + " -> wil"; GeneraCadena.Text = "Producción usada: " + textProduc5.Text; break; case 370: x = 10; picCabezal.Location = new System.Drawing.Point(x, y); GeneraCadena.Visible = false; Cadena.Text = ""; GeneraCadena.Text = "EJEMPLO 2: Clickea para procesar"; GeneraCadena.Visible = true; picClick1.Visible = false; picClick2.Visible = true; picClick3.Visible = false; groupLenguaje.Visible = true; textLenguaje.Text = "L = {w i l, . . }"; break; } } private void picClick2_Click_1(object sender, EventArgs e) { picCabezal.Visible = true; int x = picCabezal.Location.X; int y = picCabezal.Location.Y; x = x + 60; picCabezal.Location = new System.Drawing.Point(x, y); switch (x) { case 70: Cadena.Text = textProduc1.Text; GeneraCadena.Text = "Producción usada: " + textProduc1.Text; break; case 130: Cadena.Text = Cadena.Text + " -> wiX "; GeneraCadena.Text = "Producción usada: " + textProduc2.Text; break; case 190: Cadena.Text = Cadena.Text + " -> wilY "; GeneraCadena.Text = "Producción usada: " + textProduc3.Text; break; case 250: Cadena.Text = Cadena.Text + " -> wiloY "; GeneraCadena.Text = "Producción usada: " + textProduc4.Text; break; case 310: Cadena.Text = Cadena.Text + " -> wilo?"; GeneraCadena.Text = "Producción usada: " + textProduc5.Text; break; case 370: Cadena.Text = Cadena.Text + " -> wilo"; GeneraCadena.Text = "Producción usada: " + textProduc6.Text; break; case 430: x = 10; picCabezal.Location = new System.Drawing.Point(x, y); GeneraCadena.Visible = false; Cadena.Text = ""; GeneraCadena.Text = "EJEMPLO 3: Clickea para procesar"; GeneraCadena.Visible = true; picClick1.Visible = false; picClick2.Visible = false; picClick3.Visible = true; textLenguaje.Text = "L = {w i l, w i l o, . .}"; break; } } private void picClick3_Click(object sender, EventArgs e) { picCabezal.Visible = true; int x = picCabezal.Location.X; int y = picCabezal.Location.Y; x = x + 60; picCabezal.Location = new System.Drawing.Point(x, y); switch (x) { case 70: Cadena.Text = textProduc1.Text; GeneraCadena.Text = "Producción usada: " + textProduc1.Text; break; case 130: Cadena.Text = Cadena.Text + " -> wiX "; GeneraCadena.Text = "Producción usada: " + textProduc2.Text; break; case 190: Cadena.Text = Cadena.Text + " -> wilY "; GeneraCadena.Text = "Producción usada: " + textProduc3.Text; break; case 250: Cadena.Text = Cadena.Text + " -> wiloY "; GeneraCadena.Text = "Producción usada: " + textProduc4.Text; break; case 310: Cadena.Text = Cadena.Text + " -> wilonY"; GeneraCadena.Text = "Producción usada: " + textProduc5.Text; break; case 370: Cadena.Text = Cadena.Text + " -> wilon?"; GeneraCadena.Text = "Producción usada: " + textProduc6.Text; break; case 430: Cadena.Text = Cadena.Text + " -> wilon"; GeneraCadena.Text = "Producción usada: " + textProduc7.Text; break; case 490: x = 10; picCabezal.Location = new System.Drawing.Point(x, y); GeneraCadena.Visible = false; Cadena.Text = ""; GeneraCadena.Text = "EJEMPLO 1: Clickea para procesar"; GeneraCadena.Visible = true; picClick1.Visible = true; picClick2.Visible = false; picClick3.Visible = false; textLenguaje.Text = "L = {w i l, w i l o, w i l o n, . .}"; MessageBox.Show("NO HAY MAS EJEMPLOS"); panelGramatica.Visible = false; break; } } private void picGenerar_Click(object sender, EventArgs e) { Cadena.Text = ""; GeneraCadena.Text = "Clickea para procesar EJEMPLO 1"; picGenerar.Visible = false; GeneraCadena.Visible = true; picClick1.Visible = true; picClick2.Visible = false; picClick3.Visible = false; } private void tourToolStripMenuItem_Click(object sender, EventArgs e) { panelTuring.Visible = true; TuringCadenaDigitada.Focus(); } private void picCerrarPanelTouring_Click(object sender, EventArgs e) { panelTuring.Visible = false; TuringProceso.Visible = false; TuringCabezon.Visible = false; TuringLabelAcepta.Visible = false; TuringLabelNoAcepta.Visible = false; TuringCargaCadena.Visible = true; TuringCadenaDigitada.Text=""; } private void TuringPasaCadena_Click(object sender, EventArgs e) { string CadenaLeida = TuringCadenaDigitada.Text; int i; TuringCintaMaquina.Text = "| ß "; for (i = 0; i < CadenaLeida.Length; i++) { TuringCintaMaquina.Text = TuringCintaMaquina.Text + " | " + Convert.ToString(CadenaLeida[i]); } TuringCintaMaquina.Text = TuringCintaMaquina.Text + " | ß |"; TuringCargaCadena.Visible = false; TuringProceso.Visible = true; TuringAutomata.Visible = true; } private void TuringAutomata_Click(object sender, EventArgs e) { string a = TuringCadenaDigitada.Text; bool OtraLetra = false; int i, c = 0, d = 0; TuringCadenaDigitada.Text = Convert.ToString(a[0]); for (i = 0; i < a.Length; i++) { if (a[i] == 'c' || a[i] == 'b' || a[i] == 'd') OtraLetra = false; else { OtraLetra = true; break; } if (a[i] == 'c' && d == 0) c++; else if (a[i] == 'd') d++; else if (a[i] == 'b' && d == 1) c--; } if (OtraLetra) { TuringCabezon.Visible = true; TuringAutomata.Visible = false; TuringLabelNoAcepta.Visible = true; } else if (c == 0 && d == 1) { TuringCabezon.Visible = true; TuringAutomata.Visible = false; TuringLabelAcepta.Visible = true; } else TuringLabelNoAcepta.Visible = true; } private void TuringNuevaCadena_Click(object sender, EventArgs e) { TuringCadenaDigitada.Clear(); TuringCadenaDigitada.Focus(); } private void TuringOtraCadena_Click(object sender, EventArgs e) { TuringCadenaDigitada.Clear(); TuringCadenaDigitada.Focus(); } } }
/////////////////////////////////////////////////////////////// // MODELO 111111 MANEJO DE ALFABETOS y CADENAS DE TEXTO // Form1 Teoria de Lenguajes Formales /////////////////////////////////////////////////////////////// using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; namespace Practico { public partial class Formulario1 : Form { Alfabeto MiAlfabeto = new Alfabeto(); Lenguaje lenguaje1; Lenguaje lenguaje2; public Formulario1() { InitializeComponent(); } private void salirToolStripMenuItem_Click(object sender, EventArgs e) { Close(); } private void alfabetoToolStripMenuItem_Click(object sender, EventArgs e) { panelIngAlfabeto.Visible = true; if (MiAlfabeto.isEmpty()) { richTextBoxAlfabeto.Text = "Digita cada letra, luego clickea Ok"; } else { richTextBoxAlfabeto.Text = MiAlfabeto.toString(); } panelIngLenguaje.Visible = false; panelAutor.Visible = false; textBoxIngresoAlfabeto.Focus(); } private void buttonCerrarPanAlfa_Click(object sender, EventArgs e) { MessageBox.Show("Terminaste de cargar tu alfabeto", "Ahora carga los lenguajes", MessageBoxButtons.OK, MessageBoxIcon.Information); richTextBoxAlfabeto.Clear(); panelIngAlfabeto.Visible = false; } private void buttonIngAlfabeto_Click(object sender, EventArgs e) { CargaDeAlfabeto(); } private void habilitaMenu(int menu, Boolean estado) { switch (menu) { case 0: alfabetoToolStripMenuItem.Enabled = estado; break; case 1: lenguajeToolStripMenuItem.Enabled = estado; break; } } private void CargaDeAlfabeto() { MiAlfabeto.ingresarCaracteres(textBoxIngresoAlfabeto.Text.Trim()); if (!MiAlfabeto.isEmpty()) { richTextBoxAlfabeto.Clear(); richTextBoxAlfabeto.Text = MiAlfabeto.toString(); } textBoxIngresoAlfabeto.Clear(); textBoxIngresoAlfabeto.Focus(); } private void textBoxIngresoAlfabeto_KeyPress(object sender, KeyPressEventArgs e) { if (e.KeyChar == (char)(Keys.Enter)) { CargaDeAlfabeto(); } } private void button1_Click(object sender, EventArgs e) { MessageBox.Show("las Palabras del lenguaje", "Terminaste de cargar", MessageBoxButtons.OK, MessageBoxIcon.Information); panelIngLenguaje.Visible = false; } private void buttonIngCantLeng_Click(object sender, EventArgs e) { int cantidadPalabras = (int)numericUpDownIngLeng.Value; if (labelNumLeng.Text.CompareTo("1") == 0) { lenguaje1 = new Lenguaje(); lenguaje1.setCantPal(cantidadPalabras); } else { lenguaje2 = new Lenguaje(); lenguaje2.setCantPal(cantidadPalabras); } buttonBorrarLeng.Enabled = true; richTextBoxCompare.Text = MiAlfabeto.toString(); buttonIngCantLeng.Enabled = false; numericUpDownIngLeng.Enabled = false; if (numericUpDownIngLeng.Value != 0) { buttonIngLengueje.Enabled = true; textBoxComparador.Enabled = true; textBoxComparador.Focus(); } else { buttonIngLengueje.Enabled = false; textBoxComparador.Enabled = false; } if (labelNumLeng.Text.CompareTo("1") == 0) { richTextBoxCompare.Text += "\n" + lenguaje1.toString(); } else { richTextBoxCompare.Text += "\n" + lenguaje2.toString(); } } private void lenguajeNº1ToolStripMenuItem_Click(object sender, EventArgs e) { labelNumLeng.Text = "1"; abrirPanelLenguaje(1); } private void lenguajeNº2ToolStripMenuItem_Click(object sender, EventArgs e) { labelNumLeng.Text = "2"; abrirPanelLenguaje(2); } private void abrirPanelLenguaje(int nuLeng) { panelIngLenguaje.Visible = true; panelIngAlfabeto.Visible = false; panelAutor.Visible = false; richTextBoxCompare.Clear(); if (MiAlfabeto.isEmpty()) { richTextBoxCompare.Text = "Sin Alfabeto"; buttonIngLengueje.Enabled = false; buttonIngCantLeng.Enabled = false; numericUpDownIngLeng.Enabled = false; textBoxComparador.Enabled = false; buttonBorrarLeng.Enabled = false; buttonCargarLengArchivo.Enabled = false; buttonGuardarLeng.Enabled = false; } else { richTextBoxAlfabeto.Text = MiAlfabeto.toString(); buttonCargarLengArchivo.Enabled = true; buttonGuardarLeng.Enabled = true; if (nuLeng == 1) { if (lenguaje1 == null) { buttonBorrarLeng.Enabled = false; buttonIngLengueje.Enabled = false; textBoxComparador.Enabled = false; buttonIngCantLeng.Enabled = true; numericUpDownIngLeng.Enabled = true; numericUpDownIngLeng.Value = 0; } else { buttonBorrarLeng.Enabled = true; richTextBoxCompare.Text += "\n" + lenguaje1.toString(); buttonIngLengueje.Enabled = true; textBoxComparador.Enabled = true; buttonIngCantLeng.Enabled = false; numericUpDownIngLeng.Enabled = false; numericUpDownIngLeng.Value = lenguaje1.getCantPal(); } } else { if (lenguaje2 == null) { buttonBorrarLeng.Enabled = false; buttonIngLengueje.Enabled = false; textBoxComparador.Enabled = false; buttonIngCantLeng.Enabled = true; numericUpDownIngLeng.Enabled = true; numericUpDownIngLeng.Value = 0; } else { buttonBorrarLeng.Enabled = true; richTextBoxCompare.Text += "\n" + lenguaje2.toString(); buttonIngLengueje.Enabled = true; textBoxComparador.Enabled = true; buttonIngCantLeng.Enabled = false; numericUpDownIngLeng.Enabled = false; numericUpDownIngLeng.Value = lenguaje2.getCantPal(); } } } } private void buttonBorrarLeng_Click(object sender, EventArgs e) { if (labelNumLeng.Text.CompareTo("1") == 0) { lenguaje1 = null; abrirPanelLenguaje(1); } else { lenguaje2 = null; abrirPanelLenguaje(2); } richTextBoxCompare.Clear(); } private void buttonIngLengueje_Click(object sender, EventArgs e) { cargaLenguaje(textBoxComparador.Text.Trim()); } private void cargaLenguaje(String pala) { richTextBoxCompare.Clear(); richTextBoxCompare.Text = MiAlfabeto.toString(); if (MiAlfabeto.comprobarPertenencia(pala) || pala.CompareTo("@") == 0) { if (labelNumLeng.Text.CompareTo("1") == 0) { lenguaje1.setPalabra(pala); } else { lenguaje2.setPalabra(pala); } } else { richTextBoxCompare.Text += "\n" + pala + " NO PERTENECE AL LENGUAJE"; } if (labelNumLeng.Text.CompareTo("1") == 0) { richTextBoxCompare.Text += "\n" + lenguaje1.toString(); } else { richTextBoxCompare.Text += "\n" + lenguaje2.toString(); } textBoxComparador.Focus(); textBoxComparador.Clear(); } private void textBoxComparador_KeyPress(object sender, KeyPressEventArgs e) { if (e.KeyChar == (char)(Keys.Enter)) { cargaLenguaje(textBoxComparador.Text.Trim()); } } private void uniónToolStripMenuItem_Click(object sender, EventArgs e) { Formulario2 formuOperaciones = new Formulario2(1); formuOperaciones.leng1 = lenguaje1; formuOperaciones.leng2 = lenguaje2; formuOperaciones.alfab1 = MiAlfabeto; formuOperaciones.ShowDialog(); } private void buttonIngAlfArchivoCargar_Click(object sender, EventArgs e) { String nombreFichero = ""; openFileDialog1.Title = "Cargar Alfabeto"; openFileDialog1.FileName = "Alfabeto"; if (openFileDialog1.ShowDialog() == System.Windows.Forms.DialogResult.OK) { nombreFichero = openFileDialog1.FileName; } else { return; } MiAlfabeto = new Alfabeto(); lenguaje1 = null; lenguaje2 = null; MiAlfabeto.cargarDeFichero(nombreFichero); richTextBoxAlfabeto.Clear(); richTextBoxAlfabeto.Text = MiAlfabeto.toString(); textBoxIngresoAlfabeto.Clear(); textBoxIngresoAlfabeto.Focus(); } private void buttonIngAlfArchivoGuardar_Click(object sender, EventArgs e) { MessageBox.Show("los caracteres de tu alfabeto", "Estas por grabar en un archivo", MessageBoxButtons.OK, MessageBoxIcon.Information); if (MiAlfabeto.isEmpty()) { return; } saveFileDialog1.Title = "Guardar Alfabeto"; saveFileDialog1.FileName = "Alfabeto"; String nombreFichero = ""; if (saveFileDialog1.ShowDialog() == DialogResult.OK) { nombreFichero = saveFileDialog1.FileName; } else { return; } MiAlfabeto.guardarAFichero(nombreFichero); richTextBoxAlfabeto.Clear(); richTextBoxAlfabeto.Text = MiAlfabeto.toString(); textBoxIngresoAlfabeto.Clear(); textBoxIngresoAlfabeto.Focus(); } private void buttonBorrarAlfa_Click(object sender, EventArgs e) { MiAlfabeto = new Alfabeto(); lenguaje1 = null; lenguaje2 = null; richTextBoxAlfabeto.Clear(); richTextBoxAlfabeto.Text = MiAlfabeto.toString(); textBoxIngresoAlfabeto.Clear(); textBoxIngresoAlfabeto.Focus(); } private void textBoxComparador_TextChanged(object sender, EventArgs e) { } private void labelCantPal_Click(object sender, EventArgs e) { } private void numericUpDownIngLeng_ValueChanged(object sender, EventArgs e) { } private void buttonCargarLengArchivo_Click(object sender, EventArgs e) { if (MiAlfabeto.isEmpty()) { return; } String nombreFichero = ""; openFileDialog1.Title = "Cargar Lenguaje"; openFileDialog1.FileName = "Lenguaje" + labelNumLeng.Text; if (openFileDialog1.ShowDialog() == System.Windows.Forms.DialogResult.OK) { nombreFichero = openFileDialog1.FileName; } else { return; } if (labelNumLeng.Text.CompareTo("1") == 0) { lenguaje1 = new Lenguaje(); lenguaje1.cargarDeFichero(nombreFichero, MiAlfabeto); } else { lenguaje2 = new Lenguaje(); lenguaje2.cargarDeFichero(nombreFichero, MiAlfabeto); } abrirPanelLenguaje(Convert.ToInt32(labelNumLeng.Text)); } private void buttonGuardarLeng_Click(object sender, EventArgs e) { MessageBox.Show("las palabras de tu lenguaje", "Estas por grabar en un archivo", MessageBoxButtons.OK, MessageBoxIcon.Information); if (labelNumLeng.Text.CompareTo("1") == 0) { if (lenguaje1.isEmpty()) { return; } } else { if (lenguaje1.isEmpty()) { return; } } saveFileDialog1.Title = "Guardar Lenguaje"; saveFileDialog1.FileName = "Lenguaje" + labelNumLeng.Text; String nombreFichero = ""; if (saveFileDialog1.ShowDialog() == DialogResult.OK) { nombreFichero = saveFileDialog1.FileName; } else { return; } if (labelNumLeng.Text.CompareTo("1") == 0) { lenguaje1.guardarAFichero(nombreFichero); } else { lenguaje2.guardarAFichero(nombreFichero); } abrirPanelLenguaje(Convert.ToInt32(labelNumLeng.Text)); } private void intersecciónToolStripMenuItem_Click(object sender, EventArgs e) { Formulario2 formuOperaciones = new Formulario2(3); formuOperaciones.leng1 = lenguaje1; formuOperaciones.leng2 = lenguaje2; formuOperaciones.alfab1 = MiAlfabeto; formuOperaciones.ShowDialog(); } private void diferenciaToolStripMenuItem_Click(object sender, EventArgs e) { Formulario2 formuOperaciones = new Formulario2(2); formuOperaciones.leng1 = lenguaje1; formuOperaciones.leng2 = lenguaje2; formuOperaciones.alfab1 = MiAlfabeto; formuOperaciones.ShowDialog(); } private void complementoToolStripMenuItem_Click(object sender, EventArgs e) { Formulario2 formuOperaciones = new Formulario2(4); formuOperaciones.leng1 = lenguaje1; formuOperaciones.leng2 = lenguaje2; formuOperaciones.alfab1 = MiAlfabeto; formuOperaciones.ShowDialog(); } private void concatenaciónToolStripMenuItem_Click(object sender, EventArgs e) { Formulario2 formuOperaciones = new Formulario2(5); formuOperaciones.leng1 = lenguaje1; formuOperaciones.leng2 = lenguaje2; formuOperaciones.alfab1 = MiAlfabeto; formuOperaciones.ShowDialog(); } private void potenciaToolStripMenuItem_Click(object sender, EventArgs e) { Formulario2 formuOperaciones = new Formulario2(6); formuOperaciones.leng1 = lenguaje1; formuOperaciones.leng2 = lenguaje2; formuOperaciones.alfab1 = MiAlfabeto; formuOperaciones.ShowDialog(); } private void estrellaDeKleeneToolStripMenuItem_Click(object sender, EventArgs e) { Formulario2 formuOperaciones = new Formulario2(7); formuOperaciones.leng1 = lenguaje1; formuOperaciones.leng2 = lenguaje2; formuOperaciones.alfab1 = MiAlfabeto; formuOperaciones.ShowDialog(); } private void estrellaPositivaToolStripMenuItem_Click(object sender, EventArgs e) { Formulario2 formuOperaciones = new Formulario2(8); formuOperaciones.leng1 = lenguaje1; formuOperaciones.leng2 = lenguaje2; formuOperaciones.alfab1 = MiAlfabeto; formuOperaciones.ShowDialog(); } private void invertirToolStripMenuItem_Click(object sender, EventArgs e) { Formulario2 formuOperaciones = new Formulario2(9); formuOperaciones.leng1 = lenguaje1; formuOperaciones.leng2 = lenguaje2; formuOperaciones.alfab1 = MiAlfabeto; formuOperaciones.ShowDialog(); } private void autorToolStripMenuItem_Click(object sender, EventArgs e) { panelAutor.Visible = true; panelIngAlfabeto.Visible = false; panelIngLenguaje.Visible = false; } private void acercaDeToolStripMenuItem_Click(object sender, EventArgs e) { panelAutor.Visible = false; panelIngAlfabeto.Visible = false; panelIngLenguaje.Visible = false; } private void buttonCerrarAutor_Click(object sender, EventArgs e) { panelAutor.Visible = false; } private void salirToolStripMenuItem1_Click(object sender, EventArgs e) { DialogResult resultado = MessageBox.Show("Deseas cerrar este sistema ?", "Pulsa una opción", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question); if (resultado == DialogResult.Yes) Close(); } } } /////////////////////////////////////////////////////////////// // MODELO 111111 MANEJO DE ALFABETOS y CADENAS DE TEXTO // Form2 Teoria de Lenguajes Formales /////////////////////////////////////////////////////////////// using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; namespace Practico { public partial class Formulario2 : Form { public Formulario2() { InitializeComponent(); } public Formulario2(int operacion) { InitializeComponent(); abrirPanel(operacion); } private void abrirPanel(int nropanel) { switch (nropanel) { case 1: this.panelUnion.Visible = true; break; case 2: this.panelDiferencia.Visible = true; break; case 3: this.panelInters.Visible = true; break; case 4: this.panelComplem.Visible = true; break; case 5: this.panelConca.Visible = true; break; case 6: this.panelPotencia.Visible = true; break; case 7: this.panelEstrellaKleene.Visible = true; break; case 8: this.panelEstrellaPosit.Visible = true; break; case 9: this.panelInvertidora.Visible = true; break; } } private void buttonUnir_Click(object sender, EventArgs e) { Lenguaje nuevo; nuevo = leng1.unionLeng(leng2); richTextBoxUnionLeng3.Text = nuevo.toString(); } public Lenguaje leng1; public Lenguaje leng2; public Alfabeto alfab1; private void panelUnion_VisibleChanged(object sender, EventArgs e) { richTextBoxUnionLeng1.Clear(); richTextBoxUnionLeng2.Clear(); richTextBoxUnionLeng3.Clear(); buttonUnir.Enabled = true; if (leng1 == null) { richTextBoxUnionLeng1.Clear(); richTextBoxUnionLeng1.Text = "No existe el Lenguaje 1"; buttonUnir.Enabled = false; } else { if (leng1.faltanIngresar() > 0) { richTextBoxUnionLeng1.Clear(); buttonUnir.Enabled = false; } richTextBoxUnionLeng1.Text = leng1.toString(); } if (leng2 == null) { richTextBoxUnionLeng2.Text = "No existe el Lenguaje 2"; buttonUnir.Enabled = false; } else { if (leng2.faltanIngresar() > 0) { buttonUnir.Enabled = false; } richTextBoxUnionLeng2.Text = leng2.toString(); } } private void panelInters_VisibleChanged(object sender, EventArgs e) { richTextBoxIntLeng1.Clear(); richTextBoxIntLeng2.Clear(); richTextBoxIntLeng3.Clear(); buttonIntersectador.Enabled = true; if (leng1 == null) { richTextBoxIntLeng1.Text = "No existe el Lenguaje 1"; buttonIntersectador.Enabled = false; } else { if (leng1.faltanIngresar() > 0) { buttonIntersectador.Enabled = false; } richTextBoxIntLeng1.Text = leng1.toString(); } if (leng2 == null) { richTextBoxIntLeng2.Text = "No existe el Lenguaje 2"; buttonIntersectador.Enabled = false; } else { if (leng2.faltanIngresar() > 0) { buttonIntersectador.Enabled = false; } richTextBoxIntLeng2.Text = leng2.toString(); } } private void buttonIntersectador_Click(object sender, EventArgs e) { Lenguaje nuevo; nuevo = leng1.interseccionLeng(leng2); richTextBoxIntLeng3.Text = nuevo.toString(); } private void panelDiferencia_VisibleChanged(object sender, EventArgs e) { richTextBoxDifLen1.Clear(); richTextBoxDifLen2.Clear(); richTextBoxDifLen3.Clear(); buttonResta.Enabled = true; if (leng1 == null) { richTextBoxDifLen1.Text = "No existe el Lenguaje 1"; buttonResta.Enabled = false; } else { if (leng1.faltanIngresar() > 0) { richTextBoxDifLen1.Clear(); buttonResta.Enabled = false; } richTextBoxDifLen1.Text = leng1.toString(); } if (leng2 == null) { richTextBoxDifLen2.Text = "No existe el Lenguaje 2"; buttonResta.Enabled = false; } else { if (leng2.faltanIngresar() > 0) { buttonResta.Enabled = false; } richTextBoxDifLen2.Text = leng2.toString(); } } private void buttonResta_Click(object sender, EventArgs e) { Lenguaje nuevo; nuevo = leng1.diferenciaLenguaje(leng2); richTextBoxDifLen3.Text = nuevo.toString(); } private void panelComplem_VisibleChanged(object sender, EventArgs e) { int botonHabilitador = 0; richTextBoxCompLeng1.Clear(); richTextBoxCompLeng2.Clear(); richTextBoxCompLeng3.Clear(); buttonComplementar.Enabled = true; radioButtonCompLeng1.Enabled = true; radioButtonCompLeng2.Enabled = true; numericUpDownComplemento.Value = 25; if (leng1 == null) { richTextBoxCompLeng1.Text = "No existe el Lenguaje 1"; radioButtonCompLeng1.Enabled = false; botonHabilitador++; } else { if (leng1.faltanIngresar() > 0) { radioButtonCompLeng1.Enabled = false; botonHabilitador++; } richTextBoxCompLeng1.Text = leng1.toString(); } if (leng2 == null) { richTextBoxCompLeng2.Text = "No existe el Lenguaje 2"; radioButtonCompLeng2.Enabled = false; botonHabilitador++; } else { if (leng2.faltanIngresar() > 0) { radioButtonCompLeng2.Enabled = false; botonHabilitador++; } richTextBoxCompLeng2.Text = leng2.toString(); } if (botonHabilitador > 1) { buttonComplementar.Enabled = false; } } private int potencia(int num, int exponente) { int result; if (exponente == 1) return num; if (exponente == 0) return 1; exponente--; result = potencia(num, exponente) * num; return result; } private void buttonComplementar_Click(object sender, EventArgs e) { int cantPalaTotal = Convert.ToInt32(numericUpDownComplemento.Value); int cantidadDeCiclos = 0; int cantGene = 0; int cantPalAlfa = alfab1.getCarcter().Length; Lenguaje aux = new Lenguaje(); if (radioButtonCompLeng1.Checked) { aux = leng1; } else { if (radioButtonCompLeng2.Checked) { aux = leng2; } else { return; } } int palabrasLeng = aux.getCantPal(); while (cantGene < (palabrasLeng + cantPalaTotal)) { cantidadDeCiclos++; cantGene = 0; for (int i = 0; i < cantidadDeCiclos; i++) cantGene += potencia(cantPalAlfa, i); } Lenguaje nuevo; Lenguaje nuevo2 = new Lenguaje(); nuevo = aux.complemento(alfab1, cantidadDeCiclos); nuevo2.setCantPal(cantPalaTotal); for (int i = 0; i < cantPalaTotal; i++) { nuevo2.setPalabra(nuevo.getPalabras()[i]); } nuevo2.ordenarLenguajeXLongitud(); richTextBoxCompLeng3.Text = nuevo2.toString(); } private void panelConca_VisibleChanged(object sender, EventArgs e) { richTextBoxConLeng1.Clear(); richTextBoxConLeng2.Clear(); richTextBoxConLeng3.Clear(); buttonConcatenador.Enabled = true; if (leng1 == null) { richTextBoxConLeng1.Text = "No existe el Lenguaje 1"; buttonConcatenador.Enabled = false; } else { if (leng1.faltanIngresar() > 0) { richTextBoxConLeng1.Clear(); buttonConcatenador.Enabled = false; } richTextBoxConLeng1.Text = leng1.toString(); } if (leng2 == null) { richTextBoxConLeng2.Text = "No existe el Lenguaje 2"; buttonConcatenador.Enabled = false; } else { if (leng2.faltanIngresar() > 0) { buttonConcatenador.Enabled = false; } richTextBoxConLeng2.Text = leng2.toString(); } } private void buttonConcatenador_Click(object sender, EventArgs e) { Lenguaje nuevo; nuevo = leng1.concatencacion(leng2); richTextBoxConLeng3.Text = nuevo.toString(); } private void panelPotencia_VisibleChanged(object sender, EventArgs e) { int botonHabilitador = 0; richTextBoxPotLen1.Clear(); richTextBoxPotLen2.Clear(); richTextBoxPotLen3.Clear(); buttonPotenciador.Enabled = true; radioButtonPotLeng1.Enabled = true; radioButtonPotLeng2.Enabled = true; numericUpDownCantPot.Value = 1; if (leng1 == null) { richTextBoxPotLen1.Text = "No existe el Lenguaje 1"; radioButtonPotLeng1.Enabled = false; botonHabilitador++; } else { if (leng1.faltanIngresar() > 0) { radioButtonPotLeng1.Enabled = false; botonHabilitador++; } richTextBoxPotLen1.Text = leng1.toString(); } if (leng2 == null) { richTextBoxPotLen2.Text = "No existe el Lenguaje 2"; radioButtonPotLeng2.Enabled = false; botonHabilitador++; } else { if (leng2.faltanIngresar() > 0) { radioButtonPotLeng2.Enabled = false; botonHabilitador++; } richTextBoxPotLen2.Text = leng2.toString(); } if (botonHabilitador > 1) { buttonComplementar.Enabled = false; } } private void buttonPotenciador_Click(object sender, EventArgs e) { int exponente = Convert.ToInt32(numericUpDownCantPot.Value); if (radioButtonPotLeng1.Checked) { richTextBoxPotLen3.Text = leng1.potencia(exponente).toString(); } else { if (radioButtonPotLeng2.Checked) { richTextBoxPotLen3.Text = leng2.potencia(exponente).toString(); } } } private void panelEstrellaKleene_VisibleChanged(object sender, EventArgs e) { int botonHabilitador = 0; richTextBoxKleeneLeng1.Clear(); richTextBoxKleeneLeng2.Clear(); richTextBoxKleeneLeng3.Clear(); buttonKleene.Enabled = true; radioButtonKleeneLeng1.Enabled = true; radioButtonKleeneLeng2.Enabled = true; numericUpDownKleene.Value = 25; if (leng1 == null) { richTextBoxKleeneLeng1.Text = "No existe el Lenguaje 1"; radioButtonKleeneLeng1.Enabled = false; botonHabilitador++; } else { if (leng1.faltanIngresar() > 0) { radioButtonKleeneLeng1.Enabled = false; botonHabilitador++; } richTextBoxKleeneLeng1.Text = leng1.toString(); } if (leng2 == null) { richTextBoxKleeneLeng2.Text = "No existe el Lenguaje 2"; radioButtonKleeneLeng2.Enabled = false; botonHabilitador++; } else { if (leng2.faltanIngresar() > 0) { radioButtonKleeneLeng2.Enabled = false; botonHabilitador++; } richTextBoxKleeneLeng2.Text = leng2.toString(); } if (botonHabilitador > 1) { buttonKleene.Enabled = false; } } private void buttonKleene_Click(object sender, EventArgs e) { int cantidadPala = Convert.ToInt32(numericUpDownKleene.Value); int cantiPalaActual; Lenguaje aux = new Lenguaje(); Lenguaje nuevo = new Lenguaje(); if (radioButtonKleeneLeng1.Checked) { aux = leng1; } else { if (radioButtonKleeneLeng2.Checked) { aux = leng2; } else return; } cantiPalaActual = aux.getCantPal(); if (cantiPalaActual == 0) { nuevo = aux.estrellaKleene(1); richTextBoxKleeneLeng3.Text = nuevo.toString(); return; } if (cantiPalaActual == 1) if (aux.getPalabras()[0].CompareTo("@") == 0) { nuevo = aux.estrellaKleene(1); richTextBoxKleeneLeng3.Text = nuevo.toString(); return; } int cant = 0; nuevo.setCantPal(0); while (nuevo.getCantPal() < cantidadPala) { cant++; nuevo = aux.estrellaKleene(cant); } Lenguaje nuevo2 = new Lenguaje(); nuevo2.setCantPal(cantidadPala); for (int i = 0; i < cantidadPala; i++) nuevo2.setPalabra(nuevo.getPalabras()[i]); nuevo2.ordenarLenguajeXLongitud(); richTextBoxKleeneLeng3.Text = nuevo2.toString(); } private void panelEstrellaPosit_VisibleChanged(object sender, EventArgs e) { int botonHabilitador = 0; richTextBoxPositLeng1.Clear(); richTextBoxPositLeng2.Clear(); richTextBoxPositLeng3.Clear(); buttonPositiva.Enabled = true; radioButtonPosiLeng1.Enabled = true; radioButtonPosiLeng2.Enabled = true; numericUpDownCantPosi.Value = 25; if (leng1 == null) { richTextBoxPositLeng1.Text = "No existe el Lenguaje 1"; radioButtonPosiLeng1.Enabled = false; botonHabilitador++; } else { if (leng1.faltanIngresar() > 0) { radioButtonPosiLeng1.Enabled = false; botonHabilitador++; } richTextBoxPositLeng1.Text = leng1.toString(); } if (leng2 == null) { richTextBoxPositLeng2.Text = "No existe el Lenguaje 2"; radioButtonPosiLeng2.Enabled = false; botonHabilitador++; } else { if (leng2.faltanIngresar() > 0) { radioButtonPosiLeng2.Enabled = false; botonHabilitador++; } richTextBoxPositLeng2.Text = leng2.toString(); } if (botonHabilitador > 1) { buttonPositiva.Enabled = false; } } private void buttonPositiva_Click(object sender, EventArgs e) { int cantidadPala = Convert.ToInt32(numericUpDownCantPosi.Value); int cantiPalaActual; Lenguaje aux = new Lenguaje(); Lenguaje nuevo = new Lenguaje(); if (radioButtonPosiLeng1.Checked) { aux = leng1; } else { if (radioButtonPosiLeng2.Checked) { aux = leng2; } else return; } cantiPalaActual = aux.getCantPal(); if (cantiPalaActual == 0) { nuevo = aux.estrellaPositiva(1); richTextBoxPositLeng3.Text = nuevo.toString(); return; } if (cantiPalaActual == 1) if (aux.getPalabras()[0].CompareTo("@") == 0) { nuevo = aux.estrellaKleene(1); richTextBoxPositLeng3.Text = nuevo.toString(); return; } int cant = 0; nuevo.setCantPal(0); while (nuevo.getCantPal() < cantidadPala) { cant++; nuevo = aux.estrellaPositiva(cant); } Lenguaje nuevo2 = new Lenguaje(); nuevo2.setCantPal(cantidadPala); for (int i = 0; i < cantidadPala; i++) nuevo2.setPalabra(nuevo.getPalabras()[i]); nuevo2.ordenarLenguajeXLongitud(); richTextBoxPositLeng3.Text = nuevo2.toString(); } private void panelInvertidora_VisibleChanged(object sender, EventArgs e) { int botonHabilitador = 0; richTextBoxInvLeng1.Clear(); richTextBoxInvLeng2.Clear(); richTextBoxInvLeng3.Clear(); buttonInvierte.Enabled = true; radioButtonInverLeng1.Enabled = true; radioButtonInverLeng2.Enabled = true; if (leng1 == null) { richTextBoxInvLeng1.Text = "No existe el Lenguaje 1"; radioButtonInverLeng1.Enabled = false; botonHabilitador++; } else { if (leng1.faltanIngresar() > 0) { radioButtonInverLeng1.Enabled = false; botonHabilitador++; } richTextBoxInvLeng1.Text = leng1.toString(); } if (leng2 == null) { richTextBoxInvLeng2.Text = "No existe el Lenguaje 2"; radioButtonInverLeng2.Enabled = false; botonHabilitador++; } else { if (leng2.faltanIngresar() > 0) { radioButtonInverLeng2.Enabled = false; botonHabilitador++; } richTextBoxInvLeng2.Text = leng2.toString(); } if (botonHabilitador > 1) { buttonInvierte.Enabled = false; } } private void buttonInvierte_Click(object sender, EventArgs e) { if (radioButtonInverLeng1.Checked) { richTextBoxInvLeng3.Text = leng1.potencia(-1).toString(); } else { if (radioButtonInverLeng2.Checked) { richTextBoxInvLeng3.Text = leng2.potencia(-1).toString(); } } } } }
Para C el archivo es simplemente un flujo externo o una secuencia de bits almacenados en un soporte, de modo que si se abre para salida, es un flujo de archivo de salida y si el archivo se abre para entrada es un flujo de archivo para entrada.
El lenguaje C no distingue entre archivos secuenciales y archivos de acceso directo o aleatorio. Pero existen dos tipos distintos de Archivos de datos, los llamados
En C no existen archivos de acceso directo, sin embargo, existen funciones como fseek() y fgetpos() que permiten tratar los archivos como arrays, moviéndose directamente a un byte determinado del archivo abierto por fopen().
Para el acceso de estos archivos se usa el puntero asociado con el archivo, el cual a diferencia de los punteros de C++ , es un índice que apunta a una posición dada o a la posición actual es el punto en el que comienza el siguiente acceso archivo.
El lenguaje C no distingue entre archivos secuenciales y archivos de acceso directo o aleatorio. Pero existen dos tipos distintos de Archivos de datos, los llamados
APERTURA Y CIERRE DEL ARCHIVO SECUENCIAL:
Los archivos secuenciales de datos requieren recurrir a un área de buffer para almacenar temporalmente la ionformación, mientras se está transfiriendo entre la memoria de la computadora y el archivo de datos. La sintaxis para el área de buffer es:FILE *VariablePuntero;
Donde:
- FILE es un tipo de dato estructurado que establece el área de buffer
- VariablePuntero es la variable puntero que indica el principio de esta área.
Previo a procesado el archivo de datos debe ser abierto, de modo de asociar el nombre de archivo con el área de buffer y especificar el modo de uso del archivo, como sólo:
- Solo Lectura
- Sólo para escritura
- Para lectura / escritura.
La sintaxis para abrir el archivo es:
VariablePuntero = fopen (NombreArchivo, ModoDeUso);
La función fopen retorna un puntero al principio del área de buffer asociada con el archivo si este se puede abrir y caso contrario, retorna un valor NULL si no se puede abrir el archivo, por ejemplo si un archivo existente no ha sido encontrado.
Para terminar el archivo debe cerrarse al final de un programa, aplicando la función de biblioteca fclose. La sintaxis para cerrar es:
fclose(VariablePuntero);
PROCESAMIENTO DE UN ARCHIVO:
Las transacciones típicas del archivo son Altas, Bajas y Modificaciones (ABM), para lo cual se suele usar dos estrategias:ARCHIVOS SIN FORMATO:
Están basadas en las funciones de biblioteca fread y fwrite o funciones de lectura y escritura sin formato, que permiten almacenar bloques de datos, consistentes en un número de bytes continuos, que representaran una estructura de datos compleja, tal como arrays simples o múltiples.Para estas aplicaciones es necesario leer o escribir el bloque entero del archivo de datos en vez de leer o escribir separadamente las componentes individuales de cada bloque.
Estas funciones son operadas con cuatro argumentos:
- un puntero al bloque de datos,
- el tamaño del bloque de datos,
- el número de bloques a transferir y
- el puntero a un archivo secuencial.
La sintaxis es:
fwrite(&VariableTipoRegistro, sizeof(Registro), 1, PunteroArchivoSecuencial);Donde VariableTipoRegistro es una variable estructura de tipo registro y PunteroArchivoSecuencial es un puntero a archivo secuencial asociado a un archivo de datos abierto para salida.
ARCHIVOS DE ACCESO DIRECTO:
También llamados aleatorios, están distribuidos de manera que se puede acceder directamente conociendo su dirección.En C no existen archivos de acceso directo, sin embargo, existen funciones como fseek() y fgetpos() que permiten tratar los archivos como arrays, moviéndose directamente a un byte determinado del archivo abierto por fopen().
Para el acceso de estos archivos se usa el puntero asociado con el archivo, el cual a diferencia de los punteros de C++ , es un índice que apunta a una posición dada o a la posición actual es el punto en el que comienza el siguiente acceso archivo.
El puntero puede ser:
- Puntero get: que especifica la posición del archivo en el que se producirá la siguiente operación de entrada.
- Puntero put ,
que especifica la posición del archivo en el que se producirá la siguiente de salida.
Cada vez que se realiza una transacción de entrada o salida, el puntero correspondiente avanza automáticamente. Pero, si se usan las funciones seekg ( ) y seekp ( ) se puede acceder al archivo de modo directo, no secuencial.
fseek() usa tres argumentos:
La función fgetpos devuelve la posición actual del puntero a FILE, para ello necesita dos argumentos
- 1: Apuntador asociado con el archivo sobre el cual queremos realizar la búsqueda.
- 2:Variable de tipo fpos_t en donde se almacena la posición actual del apuntador al archivo.
LECTURA DE UN ARCHIVO TEXTO:
#include < stdio.h> int main() {
Esta estructura incluye entre otras cosas información sobre el nombre del archivo, la dirección de la zona de memoria donde se almacena el Archivo, tamaño del buffer.
FILE *Archivo; char letra;
Para abrir el archivo, la sintaxis de fopen:
FILE *fopen(const char *nombre_Archivo, const char *modo);
El nombre de Archivo se puede indicar directamente o usando una variable. Se puede abrir de diversas formas
El puntero se sitúa al final del archivo, así se puedan añadir datos si borrar los existentes.
Se puede agregar: b Para abrir en modo binario, t modo texto y + modo lectura y escritura
Ejemplo:
Archivo = fopen("origen.txt","r");
Comprobar si el archivo está abierto:
Después de abrir un Archivo es comprobar si realmente está abierto, para evitar fallos: el archivo puede no existir, estar dañado o no tener permisos de lecturaSi el Archivo no se ha abierto el puntero Archivo (puntero a FILE) tendrá el valor NULL y significa que no se abrió por algún error y se debe salir del programa, usando exit( 1 ), el 1 indica al sistema operativo que se han producido errores.
if (Archivo==NULL) { printf( "No se puede abrir el Archivo.\n" ); exit( 1 ); }
Leer el archivo:
La función getc, lee los caracteres uno a uno. Se puede usar también la función fgetc (son equivalentes, la diferencia es que getc está implementada como macro). Además de estas dos existen otras funciones como fgets, fread que leen más de un carácter. La sintaxis: getc (y de fgetc) es:int getc(FILE *Archivo);
Ej. letra = getc( Archivo ); Toma un carácter de Archivo, lo almacena en letra y el puntero se coloca en el siguiente carácter.
printf ( "Contenido del Archivo:\n" ); letra = getc ( Archivo);
En el ejemplo hemos usado la función feof. Esta función es de la forma: int feof ( FILE *Archivo); Esta función comprueba si se ha llegado al final de Archivo en cuyo caso devuelve un valor distinto de 0.
Si no se ha llegado al final de Archivo devuelve un cero.
Por eso usamos el siguiente modo:
while ( feof(Archivo)==0 ) o while ( !feof(Archivo) )
La segunda forma consiste en comprobar si el carácter leído es el de fin de Archivo EOF:
while ( letra!=EOF )
Cuando trabajamos con Archivos de texto no hay ningún problema, pero si manejamos un Archivo binario podemos encontrarnos EOF antes del fin de Archivo.
Por eso es mejor usar feof.
while (feof(Archivo)==0) { printf( "%c",letra ); letra=getc(Archivo); }
Al cerrarlo se vacían los buffers y se guarda el Archivo en disco. Un Archivo se cierra mediante la función fclose(Archivo). Si todo va bien fclose devuelve un cero, si hay problemas devuelve otro valor.
Estos problemas se pueden producir si el disco está lleno, por ejemplo.
if (fclose(Archivo)!=0) printf( "Problemas al cerrar el Archivo\n" ); }
LEER LINEAS COMPLETAS:
La función fgets se usa para leer líneas completas desde un Archivo.Sintaxis:
char *fgets(char *buffer, int longitud_max, FILE *Archivo);
Esta función lee desde el Archivo hasta que encuentra un carácter '\n' o hasta que lee longitud_max-1 caracteres y añade '\0' al final de la cadena.
La cadena leída la almacena en buffer. Si se encuentra EOF antes de leer ningún carácter o si se produce un error la función devuelve NULL, en caso contrario devuelve la dirección de buffer.
////////////////////////////////////// // Leer un archivo // C WiloCarpio ////////////////////////////////////// #includeint main() { FILE *Archivo; char MiTexto[100]; Archivo=fopen("Origen.txt","r"); if (Archivo==NULL) { printf( "No se puede abrir el Archivo.\n" ); exit( 1 ); } printf( "Contenido del Archivo:\n" ); fgets(MiTexto,100,Archivo); while (feof(Archivo)==0) { printf( "%s",MiTexto ); fgets(MiTexto,100,Archivo); } if (fclose(Archivo)!=0) printf( "Problemas al cerrar el Archivo\n" ); }
ESCRITURA EN ARCHIVOS:
Abrimos un Archivo 'origen.txt' y lo copiamos en otro Archivo 'destino.txt'. Además el Archivo se muestra en pantalla.////////////////////////////////////// // Escribir en un archivo // C WiloCarpio ////////////////////////////////////// #include < stdio.h> int main() {Como el puntero FILE es la base de la escritura/lectura de archivos, definimos dos punteros FILE:
Puntero 'origen' para almacenar la información sobre el Archivo origen.txt
Puntero 'destino' para guardar la información del Archivo destino.txt (el nombre del puntero no tiene por qué coincidir con el de Archivo).
FILE *origen, *destino; char letra;Abrir el Archivo usando fopen. La diferencia es que ahora tenemos que abrirlo para escritura. Usamos el modo 'w' (crea el Archivo o lo vacía si existe) porque queremos crear un Archivo.
Después de abrir un Archivo hay que comprobar si la operación se ha realizado con éxito. En este caso, como es un sencillo ejemplo, los he comprobado ambos a la vez: if (origen==NULL || destino==NULL) pero es más correcto hacerlo por separado así sabemos dónde se está produciendo el posible fallo
origen=fopen("origen.txt","r"); destino=fopen("destino.txt","w"); if (origen==NULL || destino==NULL) { printf( "Problemas con los Archivos.\n" ); exit( 1 ); }Lectura del origen y escritura en destino- getc y putc
Para la escritura usamos la función putc: int putc(int c, FILE *Archivo) ; donde c contiene el carácter que queremos escribir en el Archivo y el puntero Archivo es el Archivo sobre el que trabajamos.
De esta forma vamos escribiendo en el Archivo destino.txt el contenido del Archivo origen.txt.
letra=getc(origen); while (feof(origen)==0) { putc(letra,destino); printf( "%c",letra ); letra=getc(origen); } if (fclose(origen)!=0) printf( "Problemas al cerrar el Archivo origen.txt\n" );Leemos datos de un Archivo debemos comprobar si hemos llegado al final. Sólo debemos comprobar si estamos al final del Archivo que leemos.
No tenemos que comprobar el final del Archivo en el que escribimos puesto que lo estamos creando y aún no tiene final.
Cerrar el Archivo – fclose
No olvidar al trabajar con Archivos: cerrarlos. Debemos cerrar tanto los Archivos que leemos como aquellos sobre los que escribimos.
if (fclose(destino)!=0) printf( "Problemas al cerrar el Archivo destino.txt\n" ); }Escritura de líneas – fputs: La función fputs trabaja junto con la función fgets
int fputs(const char *cadena, FILE *Archivo);
SIMPLIFICANDO LA VIDA..!!
: Como las funciones getc, putc, fgets, fputs son adecuadas solo para operar con caracteres (1 byte) y cadenas. Si quisiéramos trabajar con otros tipos de datos, como almacenar variables de tipo int en el archivo, sería necesario convertir los valores a cadenas (con la función itoa), luego, para recuperar estos valores deberíamos leerlos como cadenas y pasarlos a enteros (atoi).Para simplificar esta tarea conviene usar las funciones fread y fwrite que nos permiten tratar con datos de cualquier tipo, incluso con estructuras.
Fwrite: Permite escribir en un Archivo. La sintaxis es
size_t fwrite(void *buffer, size_t tamano, size_t numero, FILE *pArchivo);
////////////////////////////////////// // Archivo // C WiloCarpio ////////////////////////////////////// #includeNOTA: El bucle termina cuando el 'nombre' se deja en blanco.struct { char nombre[20]; char apellido[20]; char telefono[15]; } registro; int main() { FILE *Archivo; Archivo = fopen( "nombres.txt", "a" ); do { printf( "Nombre: " ); fflush(stdout); gets(registro.nombre); if (strcmp(registro.nombre,"")) { printf( "Apellido: " ); fflush(stdout); gets(registro.apellido); printf( "Teléfono: " ); fflush(stdout); gets(registro.telefono); fwrite( ®istro, sizeof(registro), 1, Archivo ); } } while (strcmp(registro.nombre,"")!=0); fclose( Archivo ); }
Este programa guarda los datos personales mediante fwrite usando la estructura registro. Abrimos el Archivo en modo 'a' (append, añadir), para que los datos que introducimos se añadan al final del Archivo.
Una vez abierto abrimos estramos en un bucle do-while mediante el cual introducimos los datos. Los datos se van almacenando en la variable registro (que es una estructura).
Una vez tenemos todos los datos de la persona los metemos en el Archivo con fwrite:
fwrite( ®istro, sizeof(registro), 1, Archivo );
Fread: se utiliza para sacar información de un Archivo. Su formato es:
size_t fread(void *buffer, size_t tamano, size_t numero, FILE *pArchivo);
Siendo buffer la variable donde se van a escribir los datos leídos del Archivo pArchivo.
El valor que devuelve la función indica el número de elementos de tamaño 'tamano' que ha conseguido
leer. Podemos pedirle a fread que lea 10 elementos (numero=10), pero si en el Archivo sólo hay 6 elementos fread devolverá el número 6.
LOCALIZANDO REGISTROS:
#include < stdio.h> struct { char nombre[20]; char apellido[20]; char telefono[15]; } registro; int main() { FILE *Archivo; Archivo = fopen( "nombres.txt", "r" ); while ( ! feof ( Archivo ) ) { if (fread( ®istro, sizeof ( registro ) , 1, Archivo ) ) { printf( "Nombre: %s\n", registro.nombre ); printf( "Apellido: %s\n", registro.apellido); printf( "Teléfono: %s\n", registro.telefono); } } fclose( Archivo ); }Abrimos el Archivo nombres.txt en modo lectura. Con el bucle while nos aseguramos que recorremos el Archivo hasta el final (y que no nos pasamos).
La función fread lee un registro (numero=1) del tamaño de la estructura registro. Si realmente ha conseguido leer un registro la función devolverá un 1, en cuyo caso la condición del 'if' será verdadera y se imprimirá el registro en la pantalla.
En caso de que no queden más registros en el Archivo, fread devolverá 0 y no se mostrará nada en la pantalla.
Fseek:
Permite situarnos en la posición que queramos de un Archivo abierto. Cuando leemos un Archivo hay un 'puntero' que indica en qué lugar del Archivo nos encontramos.
Cada vez que leemos datos del Archivo este puntero se desplaza.
Con la función fseek podemos situar este puntero en el lugar que deseemos.
Sintaxis de fseek:
int fseek(FILE *pArchivo, long desplazamiento, int modo);
Como siempre pArchivo es un puntero de tipo FILE que apunta al Archivo con el que queremos trabajar. desplazamiento son las posiciones (o bytes) que queremos desplazar el puntero. Este desplazamiento puede ser de tres tipos dependiendo del valor de modo:
- SEEK_SET: El puntero se desplaza desde el principio del Archivo.
- SEEK_CUR: El puntero se desplaza desde la posición actual del Archivo
- SEEK_END: El puntero se desplaza desde el final del Archivo
Si se produce algún error al intentar posicionar el puntero, la función devuelve un valor distinto de 0. Si todo ha ido bien el valor devuelto es 0.
LOCALIZACION ACTUAL:
#includeftell: Esta función es complementaria a fseek, devuelve la posición actual dentro del Archivo.int main() { FILE *Archivo; long posicion; int resultado; Archivo = fopen( "origen.txt", "r" ); printf( "¿Qué posición quieres leer? " ); fflush(stdout); scanf( "%D", &posicion ); resultado = fseek( Archivo, posicion, SEEK_SET ); if (!resultado) printf( "En la posición %D está la letra %c.\n", posicion, getc(Archivo) ); else printf( "Problemas posicionando el cursor.\n" ); fclose( Archivo ); }
Su formato es el siguiente: long ftell(FILE *pArchivo);
El valor que nos da ftell puede ser usado por fseek para volver a la posición actual.
fprintf y fscanf:
Estas dos funciones trabajan igual que sus equivalentes printf y scanf. La única diferencia es que podemos especificar el Archivo sobre el que operar (si se desea puede ser la pantalla para fprintf o el teclado para fscanf).
Los formatos de estas dos funciones son:
int fprintf(FILE *pArchivo, const char *formato, ...);
int fscanf(FILE *pArchivo, const char *formato, ...);
Te propongo analizar este ejemplo que te permitirá de manera simple aprender el manejo integral en C# de los archivos.
////////////////////////////////////////////////////////////////////////////// // C# PROGRAMA CONSOLA MODELO BASE con ARCHIVO TEXTO 2006 Wilo Carpio // CLASES, SUBCLASES y OBJETOS 230806 ///////////////////////////////////////////////////////////////////////////// using System; using System.IO; using System.Data.Common; using System.Collections; using System.ComponentModel; using System.Runtime.InteropServices;
PROCESAMIENTO DE UN ARCHIVO
:namespace ArchivoModelo { ////////////////////////////////////////////////// // CLASE PRINCIPAL ////////////////////////////////////////////////// class Principal { [STAThread] static void Main(string[] args) { ClaseMenu MiMenu = new ClaseMenu(); MiMenu.Mostrar(); } }
////////////////////////////////////////////////// // CLASE MENU ////////////////////////////////////////////////// public class ClaseMenu { public void Mostrar() { ClaseWilo MiClase = new ClaseWilo(); SubClaseWilo MiSubClase = new SubClaseWilo(); Archivo UnArchivo = new Archivo(); int Opcion, OpcionPrincipal; string MiFichero; do { OpcionPrincipal = MiSubClase.OpcionMenuPrincipal(); switch (OpcionPrincipal) { case 1: MiFichero = UnArchivo.LeerNombreDelArchivo(); do { Opcion = OpcionMenu(MiFichero); switch (Opcion) { case 1: UnArchivo.EscribirEnArchivo(); break; case 2: UnArchivo.LeerArchivo(MiFichero); break; case 3: UnArchivo.BuscarEnArchivo(MiFichero); break; case 4: UnArchivo.BorrarDatoDelArchivo(); break; case 5: break; default: MiClase.Aguarda(Opcion + " Opción nula..!! METISTE MAL EL DEDO Enter para Volver"); break; } } while (Opcion != 5); break;
case 2: UnArchivo.CrearArchivo(); break; case 3: UnArchivo.BuscarUnArchivo(); break; case 4: UnArchivo.ElimininarUnArchivo(); break; case 5: MiClase.Aguarda("CERRARAS EL PROGRAMA..!!"); break; default: MiClase.Aguarda(OpcionPrincipal + " Opción nula..!! METISTE MAL EL DEDO Enter para Volver"); break; } } while (OpcionPrincipal != 5); }
////////////////////////////////////////////////// // METODOS DE LA CLASE MENU ////////////////////////////////////////////////// static int OpcionMenu(string FicheroActivado) { ClaseWilo MiClase = new ClaseWilo(); Console.BackgroundColor = ConsoleColor.Yellow; Console.Clear(); Console.ForegroundColor = ConsoleColor.Red; Console.Write(" ┌"); MiClase.TrazarRayaSimple(65); Console.Write("┐\n"); Console.Write(" │ MENU SECUNDARIO │\n"); Console.Write(" └"); MiClase.TrazarRayaSimple(65);Console.WriteLine("┘"); MiClase.RotuloAzul(" Archivo: "+FicheroActivado); Console.ForegroundColor = ConsoleColor.DarkBlue; Console.WriteLine("\n 1 → ESCRIBIR EN EL ARCHIVO "); Console.WriteLine("\n 2 → VER EL CONTENIDO DEL ARCHIVO"); Console.WriteLine("\n 3 → BUSCAR UN DATO EN EL ARCHIVO"); Console.WriteLine("\n 4 → BORRAR UN DATO DEL ARCHIVO"); Console.WriteLine("\n 5 → Volver al MENU PRINCIPAL\n"); Console.Write(" "); Console.ForegroundColor = ConsoleColor.DarkGreen; MiClase.TrazarRayaSimple(78); Console.Write("\n\n\t Digita opción (Luego ENTER): "); int OpcionElegida = Convert.ToInt32(Console.ReadLine()); return OpcionElegida; } }
////////////////////////////////////////////////// // CLASE ARCHIVO ////////////////////////////////////////////////// public class Archivo { public string FicheroActivado; public string MiCadena; ClaseWilo MiClase = new ClaseWilo(); SubClaseWilo MiSubClase = new SubClaseWilo(); public string LeerNombreDelArchivo() { string PathLeido; Console.Write(" "); Console.BackgroundColor = ConsoleColor.DarkBlue; Console.ForegroundColor = ConsoleColor.White; Console.Write(" Digita path y NOMBRE del archivo (Luego ENTER) \n"); Console.BackgroundColor = ConsoleColor.Yellow; Console.ForegroundColor = ConsoleColor.DarkBlue; Console.Write("C:\\"); PathLeido = ("C:\\" + Console.ReadLine()); return PathLeido; }
public void LeerArchivo(string FicheroActivado) { try { if (System.IO.File.Exists(FicheroActivado)) { System.IO.StreamReader Fichero_aLeer = System.IO.File.OpenText(FicheroActivado); MiClase.MarcoSimpleDeTitulo("\n CONTENIDO del archivo: " + FicheroActivado); Console.Write("\n"); Console.WriteLine(Fichero_aLeer.ReadToEnd()); Fichero_aLeer.Close(); } else { MiClase.Aguarda("El archivo " + FicheroActivado + " que deseas leer no existe"); } } catch { MiClase.Aguarda("El archivo que deseas leer " + FicheroActivado + " esta siendo usado por otro proceso"); } MiClase.Aguarda(""); }
public void BuscarEnArchivo(string FicheroActivado) { MiClase.MarcoSimpleDeTitulo(" BUSQUEDA EN EL ARCHIVO "); bool LoEncontre = false; ArrayList FicheroListado = new ArrayList(); if (System.IO.File.Exists(FicheroActivado)) { MiCadena = MiClase.LeerDatoDeConsola(); System.IO.StreamReader FicheroLeido = new System.IO.StreamReader(FicheroActivado); string FicheroAuxiliar = FicheroLeido.ReadLine(); while (FicheroAuxiliar.CompareTo(".") != 0) { if (FicheroAuxiliar.CompareTo(MiCadena) == 0 || FicheroAuxiliar.ToUpper().CompareTo(MiCadena) == 0 || FicheroAuxiliar.ToLower().CompareTo(MiCadena) == 0) { LoEncontre = true; } else { FicheroListado.Add(FicheroAuxiliar); } FicheroAuxiliar = FicheroLeido.ReadLine(); } if (LoEncontre) MiClase.Aguarda("EXITO: El dato " + MiCadena + " si esta grabada"); else MiClase.Aguarda("LAMENTO: El dato " + MiCadena + " no fue grabada"); } else { Console.WriteLine("El archivo: " + FicheroActivado + " no existe"); } }
public void EscribirEnArchivo() { MiClase.MarcoSimpleDeTitulo(" ALTA EN EL ARCHIVO "); FicheroActivado = LeerNombreDelArchivo(); if (System.IO.File.Exists(FicheroActivado)) { do { if (check()) { System.IO.StreamReader FicheroLeido = new System.IO.StreamReader(FicheroActivado); string FicheroAuxiliar = FicheroLeido.ReadLine(); ArrayList FicheroListado = new ArrayList(); while (FicheroAuxiliar.CompareTo(".") != 0) { FicheroListado.Add(FicheroAuxiliar); FicheroAuxiliar = FicheroLeido.ReadLine(); } FicheroListado.Add(MiCadena); FicheroListado.Add("."); FicheroLeido.Close(); System.IO.StreamWriter FicheroEscrito = new System.IO.StreamWriter(FicheroActivado, false, System.Text.Encoding.ASCII); foreach (string s in FicheroListado) { FicheroEscrito.WriteLine(s); } FicheroEscrito.Close(); MiSubClase.Aguarda("El dato: " + MiCadena + " se acaba de grabar..!!"); } else { MiClase.Aguarda("NO SE GRABÓ: " + MiCadena + " ya existe en archivo: " + FicheroActivado); } } while (MiSubClase.OtraVez("Queres grabar otro dato en el archivo " + FicheroActivado)); } else { MiClase.Aguarda("El archivo " + FicheroActivado + " no existe"); } }
private bool check() { MiCadena = MiClase.LeerDatoDeConsola(); System.IO.StreamReader FicheroLeido = new System.IO.StreamReader(FicheroActivado); string FicheroAuxiliar = FicheroLeido.ReadLine(); while (FicheroAuxiliar.CompareTo(".") != 0) { if (FicheroAuxiliar.CompareTo(MiCadena) == 0) { FicheroLeido.Close(); return false; } else { FicheroAuxiliar = FicheroLeido.ReadLine(); } } FicheroLeido.Close(); return true; }
public void CrearArchivo() { FicheroActivado = LeerNombreDelArchivo(); if (System.IO.File.Exists(FicheroActivado)) MiClase.Aguarda("El archivo " + FicheroActivado + " ya fue creado"); else { using (StreamWriter FicheroEscrito = File.CreateText(FicheroActivado)) { FicheroEscrito.WriteLine("."); MiClase.Aguarda("El archivo " + FicheroActivado + " fue creado"); } } }
public void ElimininarUnArchivo() { MiClase.MarcoSimpleDeTitulo(" ELIMINAR UN ARCHIVO "); FicheroActivado = LeerNombreDelArchivo(); try { if (System.IO.File.Exists(FicheroActivado)) { System.IO.File.Delete(FicheroActivado); MiClase.Aguarda("EXITO: El archivo " + FicheroActivado + " se fue al infierno..!!"); } else MiClase.Aguarda("El archivo " + FicheroActivado + " NO existe..!!!"); } catch { MiClase.Aguarda("El archivo " + FicheroActivado + " esta siendo usado por otro proceso"); } }
public void BuscarUnArchivo() { MiClase.MarcoSimpleDeTitulo(" BUSCAR SI EXISTE EL ARCHIVO "); FicheroActivado = LeerNombreDelArchivo(); try { if (System.IO.File.Exists(FicheroActivado)) MiClase.Aguarda("El archvio " + FicheroActivado + " SI existe"); else MiClase.Aguarda("El archivo: " + FicheroActivado + " NO existe"); } catch { MiClase.Aguarda("El archivo: " + FicheroActivado + " esta siendo usado por otro proceso"); } }
public void BorrarDatoDelArchivo() { MiClase.MarcoSimpleDeTitulo(" BORRAR FICHA DEL ARCHIVO "); FicheroActivado = LeerNombreDelArchivo(); bool LoEncontre = false; ArrayList FicheroListado = new ArrayList(); if (System.IO.File.Exists(FicheroActivado)) { MiCadena = MiClase.LeerDatoDeConsola(); System.IO.StreamReader FicheroLeido = new System.IO.StreamReader(FicheroActivado); string FicheroAuxiliar = FicheroLeido.ReadLine(); while (FicheroAuxiliar.CompareTo(".") != 0) { if (FicheroAuxiliar.CompareTo(MiCadena) == 0 || FicheroAuxiliar.ToUpper().CompareTo(MiCadena) == 0 || FicheroAuxiliar.ToLower().CompareTo(MiCadena) == 0) { LoEncontre = true; } else { FicheroListado.Add(FicheroAuxiliar); } FicheroAuxiliar = FicheroLeido.ReadLine(); } FicheroListado.Add("."); FicheroLeido.Close(); System.IO.StreamWriter FicheroEscrito = new System.IO.StreamWriter(FicheroActivado); foreach (string s in FicheroListado) { FicheroEscrito.WriteLine(s); } FicheroEscrito.Close(); if (LoEncontre) { MiClase.Aguarda("EXITO: El dato " + MiCadena + " se fue al cielo..!!"); } else { MiClase.Aguarda("Error: " + MiCadena + " No existe "); } } else Console.WriteLine("El archivo " + FicheroActivado + " no existe"); } }
/////////////////////////////////////////////////////////////////// // CLASE WILO ( herramientas ) ////////////////////////////////////////////////////////////////// public class ClaseWilo { public void MarcoSimpleDeTitulo(string Mensaje) { Console.BackgroundColor = ConsoleColor.Yellow; Console.Clear(); Console.ForegroundColor = ConsoleColor.DarkGreen; Console.Write("┌"); TrazarRayaSimple(78); Console.Write("┐"); Console.Write("│ Wilo Carpio C# PROGRAMA MODELO CON ARCHIVO 2006 │"); Console.Write("└"); TrazarRayaSimple(78); Console.Write("┘"); Console.BackgroundColor = ConsoleColor.Red;Console.ForegroundColor = ConsoleColor.White; Console.Write(Mensaje); Console.BackgroundColor = ConsoleColor.Yellow;Console.ForegroundColor = ConsoleColor.DarkBlue; } public void TrazarRayaSimple(int TotalRayitas) { int i; Console.ForegroundColor = ConsoleColor.Red; for (i = 1; i <= TotalRayitas; i++) Console.Write("─"); Console.ForegroundColor = ConsoleColor.DarkBlue; } public string LeerDatoDeConsola() { string Dato; TrazarRayaSimple(78); Console.Write("\n Digita el dato: "); Dato = Console.ReadLine(); return Dato; } public void RotuloAzul(string TextoDelRotulo) { Console.ForegroundColor = ConsoleColor.White; Console.Write(" "); Console.BackgroundColor = ConsoleColor.Blue; Console.Write(TextoDelRotulo + "\n"); Console.BackgroundColor = ConsoleColor.Yellow; Console.ForegroundColor = ConsoleColor.DarkBlue; }
public void Aguarda(string Mensaje) { Console.Write("\n "); Console.BackgroundColor = ConsoleColor.Red;Console.ForegroundColor = ConsoleColor.Yellow; Console.Write(" " + Mensaje + "..!!\n"); Console.BackgroundColor = ConsoleColor.Yellow; Console.Write(" "); Console.BackgroundColor = ConsoleColor.Red; Console.ForegroundColor = ConsoleColor.White; Console.Write(" ENTER para seguir "); Console.BackgroundColor = ConsoleColor.Yellow;Console.ForegroundColor = ConsoleColor.DarkBlue; Console.ReadLine(); }
public bool OtraVez(string Pregunta) { bool Respuesta = false; string Opcion; Console.Write("\n\t" + Pregunta + "? (s/n)"); Opcion = Console.ReadLine(); if ((Opcion == "s") || (Opcion == "S")) Respuesta = true; return Respuesta; } }
////////////////////////////////////////////////// // EJEMPLO DE UNA SUBCLASE ////////////////////////////////////////////////// public class SubClaseWilo : ClaseWilo { public void MarcoDobleConTitulo(string Mensaje) { int i; Console.BackgroundColor = ConsoleColor.DarkGreen; Console.Clear(); Console.Write("\n"); Console.ForegroundColor = ConsoleColor.Yellow; Console.Write(" "); Console.BackgroundColor = ConsoleColor.DarkYellow; Console.Write("╔"); for (i = 1; i <= 34; i++) Console.Write("═"); Console.WriteLine("╗"); Console.BackgroundColor = ConsoleColor.DarkGreen;Console.Write(" "); Console.BackgroundColor = ConsoleColor.DarkYellow; Console.Write("║"); Console.ForegroundColor = ConsoleColor.Green; Console.Write(" C#: MANEJO DE ARCHIVOS 2006 "); Console.ForegroundColor = ConsoleColor.Yellow; Console.Write("║"); Console.WriteLine(); Console.BackgroundColor = ConsoleColor.DarkGreen; Console.Write(" "); Console.BackgroundColor = ConsoleColor.DarkYellow; Console.Write("║"); Console.ForegroundColor = ConsoleColor.Yellow; Console.Write(" WILUCHA 1.0 "); Console.ForegroundColor = ConsoleColor.Yellow; Console.Write("║"); Console.WriteLine(); Console.BackgroundColor = ConsoleColor.DarkGreen; Console.Write(" "); Console.BackgroundColor = ConsoleColor.DarkYellow; Console.Write("╚"); for (i = 1; i <= 34; i++) Console.Write("═"); Console.Write("╝"); Console.BackgroundColor = ConsoleColor.DarkGreen; Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine("\t\t\t\t\t\t" + Mensaje); Console.ForegroundColor = ConsoleColor.Blue; }
public int OpcionMenuPrincipal() { MarcoDobleConTitulo(""); int i; Console.Write(" "); Console.ForegroundColor = ConsoleColor.Yellow; Console.BackgroundColor = ConsoleColor.Green; Console.Write("╔"); for (i = 1; i <= 34; i++) Console.Write("═"); Console.WriteLine("╗"); Console.BackgroundColor = ConsoleColor.DarkGreen; Console.BackgroundColor = ConsoleColor.DarkGreen; Console.Write(" "); Console.BackgroundColor = ConsoleColor.Green; Console.Write("║"); Console.ForegroundColor = ConsoleColor.Red; Console.Write(" MENU PRINCIPAL "); Console.ForegroundColor = ConsoleColor.Yellow; Console.Write("║"); Console.WriteLine(); Console.BackgroundColor = ConsoleColor.DarkGreen; Console.Write(" "); Console.BackgroundColor = ConsoleColor.Green; Console.Write("╠"); for (i = 1; i <= 34; i++) Console.Write("═"); Console.WriteLine("╣"); Console.BackgroundColor = ConsoleColor.DarkGreen; Console.Write(" "); Console.BackgroundColor = ConsoleColor.Green; Console.Write("║"); Console.ForegroundColor = ConsoleColor.DarkRed; Console.Write(" 1 → ABRIR ARCHIVO "); Separacion(); Console.Write(" 2 → CREAR ARCHIVO "); Separacion(); Console.Write(" 3 → VER SI HAY ARCHIVO "); Separacion(); Console.Write(" 4 → BORRAR UN ARCHIVO "); Separacion(); Console.Write(" "); Separacion(); Console.Write(" 5 → SALIR "); Console.ForegroundColor = ConsoleColor.Yellow; Console.Write("║"); Console.WriteLine(); Console.BackgroundColor = ConsoleColor.DarkGreen; Console.Write(" "); Console.BackgroundColor = ConsoleColor.Green; Console.Write("╚"); for (i = 1; i <= 34; i++) Console.Write("═"); Console.Write("╝"); Console.BackgroundColor = ConsoleColor.DarkGreen; Console.ForegroundColor = ConsoleColor.White; Console.Write("\n\n\t Digita opción (Luego ENTER): "); int OpcionElegida = Convert.ToInt32(Console.ReadLine()); return OpcionElegida; } public void Separacion() { Console.ForegroundColor = ConsoleColor.Yellow; Console.Write("║"); Console.WriteLine(); Console.BackgroundColor = ConsoleColor.Yellow; Console.BackgroundColor = ConsoleColor.DarkGreen; Console.Write(" "); Console.BackgroundColor = ConsoleColor.Green; Console.Write("║"); Console.ForegroundColor = ConsoleColor.DarkRed; } } ////////////////////////////////////////////////// // FIN DEL PROGRAMA ////////////////////////////////////////////////// }
Para entrar en tema, te muestro a continuación 6 versiones de un mismo programa:
using System; using System.IO; namespace Agenda { public class Clase { char resp; string salida = ""; public Clase() { } private void menu() { Clase C = new Clase(); do { salida = "NO"; Console.Clear(); Console.WriteLine("***** AGENDA EN CONSOLA *****"); Console.WriteLine("* *"); Console.WriteLine("* 1) Agregar contacto *"); Console.WriteLine("* 2) Eliminar contacto *"); Console.WriteLine("* 3) Listar contacto *"); Console.WriteLine("* 4) Salir *"); Console.WriteLine("* *"); Console.WriteLine("*****************************"); ConsoleKeyInfo info = Console.ReadKey(true); resp = info.KeyChar; switch (resp) { case '1': C.Agregar(); break; case '2': C.Eliminar(0); break; case '3': C.Eliminar(1); break; case '4': salida = "SI"; break; default: Console.WriteLine("\nOpción incorrecta. Elija una de las opciones que se muestran en el Menú."); break; } } while (salida != "SI"); } private void Agregar() { Console.Clear(); string lectura = ""; string nombre = ""; string tel = ""; Console.WriteLine("Nombre:"); nombre = Console.ReadLine(); Console.WriteLine("Teléfono:"); tel = Console.ReadLine(); StreamReader lector = new StreamReader("Agenda.txt"); StreamWriter escritor = new StreamWriter("AgendaBACK.txt"); while ((lectura = lector.ReadLine()) != null) { escritor.WriteLine(lectura); } lector.Close(); escritor.WriteLine(nombre); escritor.WriteLine(tel); escritor.Close(); File.Delete("Agenda.txt"); File.Copy("AgendaBACK.txt", "Agenda.txt"); File.Delete("AgendaBACK.txt"); } private void Eliminar(int num) { if (num == 0) { Console.Clear(); StreamReader lector = new StreamReader("Agenda.txt"); string lectura = ""; string busqueda = ""; while ((lectura = lector.ReadLine()) != null) { Console.WriteLine(lectura); lectura = lector.ReadLine(); Console.WriteLine(lectura); Console.WriteLine("*************************************"); } lector.Close(); Console.WriteLine("Ingrese el nombre de la persona que desea eliminar"); busqueda = Console.ReadLine(); lector = new StreamReader("Agenda.txt"); StreamWriter escritorback = new StreamWriter("AgendaBACK.txt"); while ((lectura = lector.ReadLine()) != null) { if (lectura == busqueda) { lector.ReadLine(); } else { escritorback.WriteLine(lectura); } } escritorback.Close(); lector.Close(); File.Delete("Agenda.txt"); File.Copy("AgendaBACK.txt", "Agenda.txt"); File.Delete("AgendaBACK.txt"); } else { Console.Clear(); StreamReader lector = new StreamReader("Agenda.txt"); string lectura = ""; while ((lectura = lector.ReadLine()) != null) { Console.WriteLine(lectura); lectura = lector.ReadLine(); Console.WriteLine(lectura); Console.WriteLine("*************************************"); } lector.Close(); Console.WriteLine("Presione 'Enter' para volver al menú principal"); Console.ReadLine(); } } static void Main() { if (!File.Exists("Agenda.txt")) { StreamWriter escritor = new StreamWriter("Agenda.txt"); escritor.Close(); } Clase C = new Clase(); C.menu(); } } }
using System; using System.Drawing; using System.IO; using System.Windows.Forms; namespace Agenda { public class Clase { public Clase() { } public void DForma(Form nom, int x, int y, int w, int h, string text, FormStartPosition pos, FormBorderStyle est, bool min, bool max) { nom.Size = new Size(w, h); nom.StartPosition = pos; nom.FormBorderStyle = est; nom.MaximizeBox = max; nom.MinimizeBox = min; nom.Text = text; } public void DLabel(Label nom, string text, int x, int y, int w, int h) { nom.Size = new Size(w, h); nom.Location = new Point(x, y); nom.Text = text; } public void DButton(Button nom, string text, int x, int y, int w, int h) { nom.Size = new Size(w, h); nom.Location = new Point(x, y); nom.Text = text; } public void DTextBox(TextBox nom, int x, int y, int w, int h) { nom.Size = new Size(w, h); nom.Location = new Point(x, y); } public void DListBox(ListBox nom, int x, int y, int w, int h) { nom.Size = new Size(w, h); nom.Location = new Point(x, y); } } public class Form1:Form { public Form1() { Diseñador(); } private void Diseñador() { Clase C = new Clase(); Label lb_agenda = new Label(); C.DLabel(lb_agenda, "AGENDA EN CONSOLA CON VENTANAS", 50, 10, 210, 20); Controls.Add(lb_agenda); Button btn_agregar = new Button(); C.DButton(btn_agregar, "Agregar", 100, 50, 100, 22); btn_agregar.Click += new EventHandler(BotonAgregarClick); Controls.Add(btn_agregar); Button btn_eliminar = new Button(); C.DButton(btn_eliminar, "Eliminar", 100, 80, 100, 22); btn_eliminar.Click += new EventHandler(BotonEliminarClick); Controls.Add(btn_eliminar); Button btn_listar = new Button(); C.DButton(btn_listar, "Listar", 100, 110, 100, 22); btn_listar.Click += new EventHandler(BotonListarClick); Controls.Add(btn_listar); Button btn_salir = new Button(); C.DButton(btn_salir, "Salir", 100, 140, 100, 22); btn_salir.Click += new EventHandler(BotonSalirClick); Controls.Add(btn_salir); } private void BotonAgregarClick(object sender, EventArgs e) { Clase C = new Clase(); Form2 form2 = new Form2(); C.DForma(form2, 0, 0, 300, 200, "Agregar Contacto", FormStartPosition.CenterScreen, FormBorderStyle.FixedSingle, true, false); form2.ShowDialog(this); } private void BotonEliminarClick(object sender, EventArgs e) { Clase C = new Clase(); Form3 form3 = new Form3(0); C.DForma(form3, 0, 0, 300, 420, "Eliminar Contacto", FormStartPosition.CenterScreen, FormBorderStyle.FixedSingle, true, false); form3.ShowDialog(this); } private void BotonListarClick(object sender, EventArgs e) { Clase C = new Clase(); Form3 form3 = new Form3(1); C.DForma(form3, 0, 0, 300, 420, "Listar Contactos", FormStartPosition.CenterScreen, FormBorderStyle.FixedSingle, true, false); form3.ShowDialog(this); } private void BotonSalirClick(object sender, EventArgs e) { Application.Exit(); } static void Main() { Clase C = new Clase(); Form1 form1 = new Form1(); C.DForma(form1, 0, 0, 300, 220, "Agenda con Ventanas", FormStartPosition.CenterScreen, FormBorderStyle.FixedSingle, true, false); Application.EnableVisualStyles(); Application.Run(form1); } } public class Form2 : Form { TextBox txt_nom; TextBox txt_tel; public Form2() { Diseñador(); } private void Diseñador() { Clase C = new Clase(); Label lb_agenda = new Label(); C.DLabel(lb_agenda, "AGREGAR NUEVO CONTACTO", 50, 10, 210, 20); Controls.Add(lb_agenda); Label lb_nom = new Label(); C.DLabel(lb_nom, "Nombre", 10, 50, 80, 20); Controls.Add(lb_nom); txt_nom = new TextBox(); C.DTextBox(txt_nom, 90, 50, 150, 20); Controls.Add(txt_nom); Label lb_tel = new Label(); C.DLabel(lb_tel, "Teléfono", 10, 80, 80, 20); Controls.Add(lb_tel); txt_tel = new TextBox(); C.DTextBox(txt_tel, 90, 80, 150, 20); Controls.Add(txt_tel); Button btn_aceptar = new Button(); C.DButton(btn_aceptar, "Aceptar", 50, 120, 100, 22); btn_aceptar.Click += new EventHandler(BotonAceptarClick); Controls.Add(btn_aceptar); Button btn_cancel = new Button(); C.DButton(btn_cancel, "Cancelar", 160, 120, 100, 22); btn_cancel.Click += new EventHandler(BotonCancelClick); Controls.Add(btn_cancel); } private void BotonAceptarClick(object sender, EventArgs e) { if (txt_nom.Text != "" && txt_tel.Text != "") { string lectura = ""; StreamReader lector = new StreamReader("Agenda.txt"); StreamWriter escritor = new StreamWriter("AgendaBACK.txt"); while ((lectura = lector.ReadLine()) != null) { escritor.WriteLine(lectura); } lector.Close(); escritor.WriteLine(txt_nom.Text); escritor.WriteLine(txt_tel.Text); escritor.Close(); File.Delete("Agenda.txt"); File.Copy("AgendaBACK.txt", "Agenda.txt"); File.Delete("AgendaBACK.txt"); MessageBox.Show("Contacto ingresado", "Exito", MessageBoxButtons.OK, MessageBoxIcon.Information); BotonCancelClick(sender, e); } else { MessageBox.Show("Debe ingresar el nombre y el teléfono para agregar el contacto", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); txt_nom.SelectAll(); txt_nom.Focus(); } } private void BotonCancelClick(object sender, EventArgs e) { this.Close(); } } public class Form3 : Form { ListBox ltb_cont; TextBox txt_nom; int Num; public Form3(int num) { Num = num; Diseñador(); } private void Diseñador() { Clase C = new Clase(); if (Num == 0) { Label lb_agenda = new Label(); C.DLabel(lb_agenda, "ELIMINAR CONTACTO", 50, 10, 210, 20); Controls.Add(lb_agenda); ltb_cont = new ListBox(); C.DListBox(ltb_cont, 10, 50, 270, 250); this.ltb_cont.SelectedIndexChanged += new System.EventHandler(this.ltb_cont_SIC); Controls.Add(ltb_cont); Label lb_nom = new Label(); C.DLabel(lb_nom, "Nombre", 10, 310, 80, 20); Controls.Add(lb_nom); txt_nom = new TextBox(); C.DTextBox(txt_nom, 90, 310, 150, 20); txt_nom.ReadOnly = true; Controls.Add(txt_nom); Button btn_elim = new Button(); C.DButton(btn_elim, "Eliminar", 50, 350, 100, 22); btn_elim.Click += new EventHandler(BotonEliminarClick); Controls.Add(btn_elim); Button btn_cancel = new Button(); C.DButton(btn_cancel, "Cancelar", 160, 350, 100, 22); btn_cancel.Click += new EventHandler(BotonCancelClick); Controls.Add(btn_cancel); this.Load += new System.EventHandler(this.Form3_Load); } else { Label lb_agenda = new Label(); C.DLabel(lb_agenda, "LISTAR CONTACTOS", 50, 10, 210, 20); Controls.Add(lb_agenda); ltb_cont = new ListBox(); C.DListBox(ltb_cont, 10, 50, 270, 300); Controls.Add(ltb_cont); Button btn_cancel = new Button(); C.DButton(btn_cancel, "Cerrar", 100, 350, 100, 22); btn_cancel.Click += new EventHandler(BotonCancelClick); Controls.Add(btn_cancel); this.Load += new System.EventHandler(this.Form3_Load); } } private void Form3_Load(object sender, EventArgs e) { if (Num == 0) { string lectura = ""; ltb_cont.Items.Clear(); StreamReader lector = new StreamReader("Agenda.txt"); while ((lectura = lector.ReadLine()) != null) { ltb_cont.Items.Add(lectura); lector.ReadLine(); } lector.Close(); } else { string lectura = ""; ltb_cont.Items.Clear(); StreamReader lector = new StreamReader("Agenda.txt"); while ((lectura = lector.ReadLine()) != null) { ltb_cont.Items.Add(lectura + " - " + lector.ReadLine()); } lector.Close(); } } private void ltb_cont_SIC(object sender, EventArgs e) { txt_nom.Text = ltb_cont.SelectedItem.ToString().Trim(); } private void BotonEliminarClick(object sender, EventArgs e) { if (txt_nom.Text != "") { string lectura = ""; StreamReader lector = new StreamReader("Agenda.txt"); StreamWriter escritorback = new StreamWriter("AgendaBACK.txt"); while ((lectura = lector.ReadLine()) != null) { if (lectura == txt_nom.Text) { lector.ReadLine(); } else { escritorback.WriteLine(lectura); } } escritorback.Close(); lector.Close(); File.Delete("Agenda.txt"); File.Copy("AgendaBACK.txt", "Agenda.txt"); File.Delete("AgendaBACK.txt"); MessageBox.Show("Contacto eliminado", "Exito", MessageBoxButtons.OK, MessageBoxIcon.Information); txt_nom.Clear(); Form3_Load(sender, e); } else { MessageBox.Show("Debe elegir un contacto para eliminar", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } } private void BotonCancelClick(object sender, EventArgs e) { this.Close(); } } }
using System; using System.IO; using System.Data.OleDb; namespace Agenda { public class Clase { char resp; string salida = ""; public Clase() { } private void menu() { Clase C = new Clase(); do { salida = "NO"; Console.Clear(); Console.WriteLine("***** AGENDA EN CONSOLA *****"); Console.WriteLine("* *"); Console.WriteLine("* 1) Agregar contacto *"); Console.WriteLine("* 2) Eliminar contacto *"); Console.WriteLine("* 3) Listar contacto *"); Console.WriteLine("* 4) Salir *"); Console.WriteLine("* *"); Console.WriteLine("*****************************"); ConsoleKeyInfo info = Console.ReadKey(true); resp = info.KeyChar; switch (resp) { case '1': C.Agregar(); break; case '2': C.Eliminar(0); break; case '3': C.Eliminar(1); break; case '4': salida = "SI"; break; default: Console.WriteLine("\nOpción incorrecta. Elija una de las opciones que se muestran en el Menú."); break; } } while (salida != "SI"); } private void Agregar() { Console.Clear(); string nombre = ""; string tel = ""; Console.WriteLine("Nombre:"); nombre = Console.ReadLine(); Console.WriteLine("Teléfono:"); tel = Console.ReadLine(); try { OleDbConnection con = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=Agenda.mdb;User Id=admin;Password=;"); con.Open(); string insert = "INSERT INTO contactos (nom,tel) VALUES ('" + nombre + "','" + tel + "');"; OleDbCommand com = new OleDbCommand(insert, con); com.ExecuteNonQuery(); con.Close(); } catch { Console.WriteLine("Ocurrió un error cuando se estaba ingresando. Presione 'Enter' para volver."); Console.ReadLine(); } } private void Eliminar(int num) { if (num == 0) { Console.Clear(); string busqueda = ""; OleDbConnection con = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=Agenda.mdb;User Id=admin;Password=;"); con.Open(); string select = "SELECT nom,tel FROM contactos ORDER BY nom"; OleDbCommand com = new OleDbCommand(select, con); OleDbDataReader lector = com.ExecuteReader(); while (lector.Read()) { Console.WriteLine(lector.GetValue(0).ToString().Trim()); Console.WriteLine(lector.GetValue(1).ToString().Trim()); Console.WriteLine("*************************************"); } lector.Close(); Console.WriteLine("Ingrese el nombre de la persona que desea eliminar"); busqueda = Console.ReadLine(); string delete = "DELETE FROM contactos WHERE nom='" + busqueda + "'"; com = new OleDbCommand(delete, con); com.ExecuteNonQuery(); con.Close(); } else { Console.Clear(); OleDbConnection con = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=Agenda.mdb;User Id=admin;Password=;"); con.Open(); string select = "SELECT nom,tel FROM contactos ORDER BY nom"; OleDbCommand com = new OleDbCommand(select, con); OleDbDataReader lector = com.ExecuteReader(); while (lector.Read()) { Console.WriteLine(lector.GetValue(0).ToString().Trim()); Console.WriteLine(lector.GetValue(1).ToString().Trim()); Console.WriteLine("*************************************"); } lector.Close(); con.Close(); Console.WriteLine("Presione 'Enter' para volver al menú principal"); Console.ReadLine(); } } static void Main() { if (!File.Exists("Agenda.txt")) { StreamWriter escritor = new StreamWriter("Agenda.txt"); escritor.Close(); } Clase C = new Clase(); C.menu(); } } }
using System; using System.Drawing; using System.Data.OleDb; using System.Windows.Forms; namespace Agenda { public class Clase { public Clase() { } public void DForma(Form nom, int x, int y, int w, int h, string text, FormStartPosition pos, FormBorderStyle est, bool min, bool max) { nom.Size = new Size(w, h); nom.StartPosition = pos; nom.FormBorderStyle = est; nom.MaximizeBox = max; nom.MinimizeBox = min; nom.Text = text; } public void DLabel(Label nom, string text, int x, int y, int w, int h) { nom.Size = new Size(w, h); nom.Location = new Point(x, y); nom.Text = text; } public void DButton(Button nom, string text, int x, int y, int w, int h) { nom.Size = new Size(w, h); nom.Location = new Point(x, y); nom.Text = text; } public void DTextBox(TextBox nom, int x, int y, int w, int h) { nom.Size = new Size(w, h); nom.Location = new Point(x, y); } public void DListBox(ListBox nom, int x, int y, int w, int h) { nom.Size = new Size(w, h); nom.Location = new Point(x, y); } } public class Form1 : Form { public Form1() { Diseñador(); } private void Diseñador() { Clase C = new Clase(); Label lb_agenda = new Label(); C.DLabel(lb_agenda, "AGENDA EN CONSOLA CON VENTANAS", 50, 10, 210, 20); Controls.Add(lb_agenda); Button btn_agregar = new Button(); C.DButton(btn_agregar, "Agregar", 100, 50, 100, 22); btn_agregar.Click += new EventHandler(BotonAgregarClick); Controls.Add(btn_agregar); Button btn_eliminar = new Button(); C.DButton(btn_eliminar, "Eliminar", 100, 80, 100, 22); btn_eliminar.Click += new EventHandler(BotonEliminarClick); Controls.Add(btn_eliminar); Button btn_listar = new Button(); C.DButton(btn_listar, "Listar", 100, 110, 100, 22); btn_listar.Click += new EventHandler(BotonListarClick); Controls.Add(btn_listar); Button btn_salir = new Button(); C.DButton(btn_salir, "Salir", 100, 140, 100, 22); btn_salir.Click += new EventHandler(BotonSalirClick); Controls.Add(btn_salir); } private void BotonAgregarClick(object sender, EventArgs e) { Clase C = new Clase(); Form2 form2 = new Form2(); C.DForma(form2, 0, 0, 300, 200, "Agregar Contacto", FormStartPosition.CenterScreen, FormBorderStyle.FixedSingle, true, false); form2.ShowDialog(this); } private void BotonEliminarClick(object sender, EventArgs e) { Clase C = new Clase(); Form3 form3 = new Form3(0); C.DForma(form3, 0, 0, 300, 420, "Eliminar Contacto", FormStartPosition.CenterScreen, FormBorderStyle.FixedSingle, true, false); form3.ShowDialog(this); } private void BotonListarClick(object sender, EventArgs e) { Clase C = new Clase(); Form3 form3 = new Form3(1); C.DForma(form3, 0, 0, 300, 420, "Listar Contactos", FormStartPosition.CenterScreen, FormBorderStyle.FixedSingle, true, false); form3.ShowDialog(this); } private void BotonSalirClick(object sender, EventArgs e) { Application.Exit(); } static void Main() { Clase C = new Clase(); Form1 form1 = new Form1(); C.DForma(form1, 0, 0, 300, 220, "Agenda con Ventanas", FormStartPosition.CenterScreen, FormBorderStyle.FixedSingle, true, false); Application.EnableVisualStyles(); Application.Run(form1); } } public class Form2 : Form { TextBox txt_nom; TextBox txt_tel; public Form2() { Diseñador(); } private void Diseñador() { Clase C = new Clase(); Label lb_agenda = new Label(); C.DLabel(lb_agenda, "AGREGAR NUEVO CONTACTO", 50, 10, 210, 20); Controls.Add(lb_agenda); Label lb_nom = new Label(); C.DLabel(lb_nom, "Nombre", 10, 50, 80, 20); Controls.Add(lb_nom); txt_nom = new TextBox(); C.DTextBox(txt_nom, 90, 50, 150, 20); Controls.Add(txt_nom); Label lb_tel = new Label(); C.DLabel(lb_tel, "Teléfono", 10, 80, 80, 20); Controls.Add(lb_tel); txt_tel = new TextBox(); C.DTextBox(txt_tel, 90, 80, 150, 20); Controls.Add(txt_tel); Button btn_aceptar = new Button(); C.DButton(btn_aceptar, "Aceptar", 50, 120, 100, 22); btn_aceptar.Click += new EventHandler(BotonAceptarClick); Controls.Add(btn_aceptar); Button btn_cancel = new Button(); C.DButton(btn_cancel, "Cancelar", 160, 120, 100, 22); btn_cancel.Click += new EventHandler(BotonCancelClick); Controls.Add(btn_cancel); } private void BotonAceptarClick(object sender, EventArgs e) { if (txt_nom.Text != "" && txt_tel.Text != "") { try { OleDbConnection con = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=Agenda.mdb;User Id=admin;Password=;"); con.Open(); string insert = "INSERT INTO contactos (nom,tel) VALUES ('" + txt_nom.Text + "','" + txt_tel.Text + "');"; OleDbCommand com = new OleDbCommand(insert, con); com.ExecuteNonQuery(); con.Close(); MessageBox.Show("Contacto ingresado", "Exito", MessageBoxButtons.OK, MessageBoxIcon.Information); BotonCancelClick(sender, e); } catch { MessageBox.Show("Ocurrió un error cuando se estaba ingresando.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); txt_nom.SelectAll(); txt_nom.Focus(); } } else { MessageBox.Show("Debe ingresar el nombre y el teléfono para agregar el contacto", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); txt_nom.SelectAll(); txt_nom.Focus(); } } private void BotonCancelClick(object sender, EventArgs e) { this.Close(); } } public class Form3 : Form { ListBox ltb_cont; TextBox txt_nom; int Num; public Form3(int num) { Num = num; Diseñador(); } private void Diseñador() { Clase C = new Clase(); if (Num == 0) { Label lb_agenda = new Label(); C.DLabel(lb_agenda, "ELIMINAR CONTACTO", 50, 10, 210, 20); Controls.Add(lb_agenda); ltb_cont = new ListBox(); C.DListBox(ltb_cont, 10, 50, 270, 250); this.ltb_cont.SelectedIndexChanged += new System.EventHandler(this.ltb_cont_SIC); Controls.Add(ltb_cont); Label lb_nom = new Label(); C.DLabel(lb_nom, "Nombre", 10, 310, 80, 20); Controls.Add(lb_nom); txt_nom = new TextBox(); C.DTextBox(txt_nom, 90, 310, 150, 20); txt_nom.ReadOnly = true; Controls.Add(txt_nom); Button btn_elim = new Button(); C.DButton(btn_elim, "Eliminar", 50, 350, 100, 22); btn_elim.Click += new EventHandler(BotonEliminarClick); Controls.Add(btn_elim); Button btn_cancel = new Button(); C.DButton(btn_cancel, "Cancelar", 160, 350, 100, 22); btn_cancel.Click += new EventHandler(BotonCancelClick); Controls.Add(btn_cancel); this.Load += new System.EventHandler(this.Form3_Load); } else { Label lb_agenda = new Label(); C.DLabel(lb_agenda, "LISTAR CONTACTOS", 50, 10, 210, 20); Controls.Add(lb_agenda); ltb_cont = new ListBox(); C.DListBox(ltb_cont, 10, 50, 270, 300); Controls.Add(ltb_cont); Button btn_cancel = new Button(); C.DButton(btn_cancel, "Cerrar", 100, 350, 100, 22); btn_cancel.Click += new EventHandler(BotonCancelClick); Controls.Add(btn_cancel); this.Load += new System.EventHandler(this.Form3_Load); } } private void Form3_Load(object sender, EventArgs e) { if (Num == 0) { ltb_cont.Items.Clear(); OleDbConnection con = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=Agenda.mdb;User Id=admin;Password=;"); con.Open(); string select = "SELECT nom FROM contactos ORDER BY nom;"; OleDbCommand com = new OleDbCommand(select, con); OleDbDataReader lector = com.ExecuteReader(); while (lector.Read()) { ltb_cont.Items.Add(lector.GetValue(0).ToString().Trim()); } con.Close(); } else { ltb_cont.Items.Clear(); OleDbConnection con = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=Agenda.mdb;User Id=admin;Password=;"); con.Open(); string select = "SELECT nom,tel FROM contactos ORDER BY nom;"; OleDbCommand com = new OleDbCommand(select, con); OleDbDataReader lector = com.ExecuteReader(); while (lector.Read()) { ltb_cont.Items.Add(lector.GetValue(0).ToString().Trim() + " - " + lector.GetValue(1).ToString().Trim()); } con.Close(); } } private void ltb_cont_SIC(object sender, EventArgs e) { txt_nom.Text = ltb_cont.SelectedItem.ToString().Trim(); } private void BotonEliminarClick(object sender, EventArgs e) { if (txt_nom.Text != "") { OleDbConnection con = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=Agenda.mdb;User Id=admin;Password=;"); con.Open(); string delete = "DELETE FROM contactos WHERE nom='" + txt_nom.Text + "'"; OleDbCommand com = new OleDbCommand(delete, con); com.ExecuteNonQuery(); con.Close(); MessageBox.Show("Contacto eliminado", "Exito", MessageBoxButtons.OK, MessageBoxIcon.Information); txt_nom.Clear(); Form3_Load(sender, e); } else { MessageBox.Show("Debe elegir un contacto para eliminar", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } } private void BotonCancelClick(object sender, EventArgs e) { this.Close(); } } }
using System; using System.Collections.Generic; using System.Windows.Forms; namespace Agenda5 { static class Program { ////// Punto de entrada principal para la aplicación. /// [STAThread] static void Main() { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new Form1()); } } } using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Text; using System.Windows.Forms; namespace Agenda5 { public partial class Form1 : Form { public Form1() { InitializeComponent(); } private void btn_agregar_Click(object sender, EventArgs e) { Form2 form2 = new Form2(); form2.ShowDialog(this); } private void btn_eliminar_Click(object sender, EventArgs e) { Form3 form3 = new Form3(0); form3.ShowDialog(this); } private void btn_listar_Click(object sender, EventArgs e) { Form3 form3 = new Form3(1); form3.ShowDialog(this); } private void btn_salir_Click(object sender, EventArgs e) { Application.Exit(); } } } namespace Agenda5 { partial class Form1 { ////// Variable del diseñador requerida. /// private System.ComponentModel.IContainer components = null; ////// Limpiar los recursos que se estén utilizando. /// /// true si los recursos administrados se deben eliminar; false en caso contrario, false. protected override void Dispose(bool disposing) { if (disposing && (components != null)) { components.Dispose(); } base.Dispose(disposing); } #region Código generado por el Diseñador de Windows Forms ////// Método necesario para admitir el Diseñador. No se puede modificar /// el contenido del método con el editor de código. /// private void InitializeComponent() { this.lb_agenda = new System.Windows.Forms.Label(); this.btn_agregar = new System.Windows.Forms.Button(); this.btn_eliminar = new System.Windows.Forms.Button(); this.btn_listar = new System.Windows.Forms.Button(); this.btn_salir = new System.Windows.Forms.Button(); this.SuspendLayout(); // // lb_agenda // this.lb_agenda.AutoSize = true; this.lb_agenda.Location = new System.Drawing.Point(80, 27); this.lb_agenda.Name = "lb_agenda"; this.lb_agenda.Size = new System.Drawing.Size(135, 13); this.lb_agenda.TabIndex = 0; this.lb_agenda.Text = "AGENDA CON VENTANAS"; // // btn_agregar // this.btn_agregar.Location = new System.Drawing.Point(110, 58); this.btn_agregar.Name = "btn_agregar"; this.btn_agregar.Size = new System.Drawing.Size(75, 23); this.btn_agregar.TabIndex = 1; this.btn_agregar.Text = "Agregar"; this.btn_agregar.UseVisualStyleBackColor = true; this.btn_agregar.Click += new System.EventHandler(this.btn_agregar_Click); // // btn_eliminar // this.btn_eliminar.Location = new System.Drawing.Point(110, 87); this.btn_eliminar.Name = "btn_eliminar"; this.btn_eliminar.Size = new System.Drawing.Size(75, 23); this.btn_eliminar.TabIndex = 2; this.btn_eliminar.Text = "Eliminar"; this.btn_eliminar.UseVisualStyleBackColor = true; this.btn_eliminar.Click += new System.EventHandler(this.btn_eliminar_Click); // // btn_listar // this.btn_listar.Location = new System.Drawing.Point(110, 116); this.btn_listar.Name = "btn_listar"; this.btn_listar.Size = new System.Drawing.Size(75, 23); this.btn_listar.TabIndex = 3; this.btn_listar.Text = "Listar"; this.btn_listar.UseVisualStyleBackColor = true; this.btn_listar.Click += new System.EventHandler(this.btn_listar_Click); // // btn_salir // this.btn_salir.Location = new System.Drawing.Point(110, 145); this.btn_salir.Name = "btn_salir"; this.btn_salir.Size = new System.Drawing.Size(75, 23); this.btn_salir.TabIndex = 4; this.btn_salir.Text = "Salir"; this.btn_salir.UseVisualStyleBackColor = true; this.btn_salir.Click += new System.EventHandler(this.btn_salir_Click); // // Form1 // this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; this.ClientSize = new System.Drawing.Size(294, 188); this.Controls.Add(this.btn_salir); this.Controls.Add(this.btn_listar); this.Controls.Add(this.btn_eliminar); this.Controls.Add(this.btn_agregar); this.Controls.Add(this.lb_agenda); this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle; this.MaximizeBox = false; this.Name = "Form1"; this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; this.Text = "Agenda con Ventanas"; this.ResumeLayout(false); this.PerformLayout(); } #endregion private System.Windows.Forms.Label lb_agenda; private System.Windows.Forms.Button btn_agregar; private System.Windows.Forms.Button btn_eliminar; private System.Windows.Forms.Button btn_listar; private System.Windows.Forms.Button btn_salir; } } using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Text; using System.Windows.Forms; using System.IO; namespace Agenda5 { public partial class Form2 : Form { public Form2() { InitializeComponent(); } private void btn_aceptar_Click(object sender, EventArgs e) { if (txt_nom.Text != "" && txt_tel.Text != "") { string lectura = ""; StreamReader lector = new StreamReader("Agenda.txt"); StreamWriter escritor = new StreamWriter("AgendaBACK.txt"); while ((lectura = lector.ReadLine()) != null) { escritor.WriteLine(lectura); } lector.Close(); escritor.WriteLine(txt_nom.Text); escritor.WriteLine(txt_tel.Text); escritor.Close(); File.Delete("Agenda.txt"); File.Copy("AgendaBACK.txt", "Agenda.txt"); File.Delete("AgendaBACK.txt"); MessageBox.Show("Contacto ingresado", "Exito", MessageBoxButtons.OK, MessageBoxIcon.Information); btn_cancel_Click(sender, e); } else { MessageBox.Show("Debe ingresar el nombre y el teléfono para agregar el contacto", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); txt_nom.SelectAll(); txt_nom.Focus(); } } private void btn_cancel_Click(object sender, EventArgs e) { this.Close(); } } } namespace Agenda5 { partial class Form2 { ////// Variable del diseñador requerida. /// private System.ComponentModel.IContainer components = null; ////// Limpiar los recursos que se estén utilizando. /// /// true si los recursos administrados se deben eliminar; false en caso contrario, false. protected override void Dispose(bool disposing) { if (disposing && (components != null)) { components.Dispose(); } base.Dispose(disposing); } #region Código generado por el Diseñador de Windows Forms ////// Método necesario para admitir el Diseñador. No se puede modificar /// el contenido del método con el editor de código. /// private void InitializeComponent() { this.lb_agenda = new System.Windows.Forms.Label(); this.lb_nom = new System.Windows.Forms.Label(); this.lb_tel = new System.Windows.Forms.Label(); this.txt_nom = new System.Windows.Forms.TextBox(); this.txt_tel = new System.Windows.Forms.TextBox(); this.btn_aceptar = new System.Windows.Forms.Button(); this.btn_cancel = new System.Windows.Forms.Button(); this.SuspendLayout(); // // lb_agenda // this.lb_agenda.AutoSize = true; this.lb_agenda.Location = new System.Drawing.Point(67, 28); this.lb_agenda.Name = "lb_agenda"; this.lb_agenda.Size = new System.Drawing.Size(158, 13); this.lb_agenda.TabIndex = 0; this.lb_agenda.Text = "AGREGAR NUEVO CONTACTO"; // // lb_nom // this.lb_nom.AutoSize = true; this.lb_nom.Location = new System.Drawing.Point(12, 60); this.lb_nom.Name = "lb_nom"; this.lb_nom.Size = new System.Drawing.Size(48, 13); this.lb_nom.TabIndex = 1; this.lb_nom.Text = "Nombre"; // // lb_tel // this.lb_tel.AutoSize = true; this.lb_tel.Location = new System.Drawing.Point(12, 94); this.lb_tel.Name = "lb_tel"; this.lb_tel.Size = new System.Drawing.Size(52, 13); this.lb_tel.TabIndex = 2; this.lb_tel.Text = "Teléfono"; // // txt_nom // this.txt_nom.Location = new System.Drawing.Point(82, 57); this.txt_nom.Name = "txt_nom"; this.txt_nom.Size = new System.Drawing.Size(181, 22); this.txt_nom.TabIndex = 3; // // txt_tel // this.txt_tel.Location = new System.Drawing.Point(82, 91); this.txt_tel.Name = "txt_tel"; this.txt_tel.Size = new System.Drawing.Size(181, 22); this.txt_tel.TabIndex = 4; // // btn_aceptar // this.btn_aceptar.Location = new System.Drawing.Point(56, 131); this.btn_aceptar.Name = "btn_aceptar"; this.btn_aceptar.Size = new System.Drawing.Size(75, 23); this.btn_aceptar.TabIndex = 5; this.btn_aceptar.Text = "Aceptar"; this.btn_aceptar.UseVisualStyleBackColor = true; this.btn_aceptar.Click += new System.EventHandler(this.btn_aceptar_Click); // // btn_cancel // this.btn_cancel.Location = new System.Drawing.Point(161, 131); this.btn_cancel.Name = "btn_cancel"; this.btn_cancel.Size = new System.Drawing.Size(75, 23); this.btn_cancel.TabIndex = 6; this.btn_cancel.Text = "Cancelar"; this.btn_cancel.UseVisualStyleBackColor = true; this.btn_cancel.Click += new System.EventHandler(this.btn_cancel_Click); // // Form2 // this.ClientSize = new System.Drawing.Size(292, 166); this.Controls.Add(this.btn_cancel); this.Controls.Add(this.btn_aceptar); this.Controls.Add(this.txt_tel); this.Controls.Add(this.txt_nom); this.Controls.Add(this.lb_tel); this.Controls.Add(this.lb_nom); this.Controls.Add(this.lb_agenda); this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle; this.MaximizeBox = false; this.Name = "Form2"; this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; this.Text = "Agregar Contacto"; this.ResumeLayout(false); this.PerformLayout(); } #endregion private System.Windows.Forms.Label lb_agenda; private System.Windows.Forms.Label lb_nom; private System.Windows.Forms.Label lb_tel; private System.Windows.Forms.TextBox txt_nom; private System.Windows.Forms.TextBox txt_tel; private System.Windows.Forms.Button btn_aceptar; private System.Windows.Forms.Button btn_cancel; } } using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Text; using System.Windows.Forms; using System.IO; namespace Agenda5 { public partial class Form3 : Form { int Num; public Form3(int num) { InitializeComponent(); Num = num; } private void Form3_Load(object sender, EventArgs e) { if (Num == 0) { string lectura = ""; ltb_cont.Items.Clear(); StreamReader lector = new StreamReader("Agenda.txt"); while ((lectura = lector.ReadLine()) != null) { ltb_cont.Items.Add(lectura); lector.ReadLine(); } lector.Close(); } else { this.Text = "Listar Contactos"; lb_agenda.Text = "LISTAR CONTACTOS"; lb_nom.Visible = false; txt_nom.Visible = false; ltb_cont.Size = new Size(268, 310); btn_elim.Visible = false; btn_cancel.Location = new Point(110, 351); btn_cancel.Text = "Cerrar"; string lectura = ""; ltb_cont.Items.Clear(); StreamReader lector = new StreamReader("Agenda.txt"); while ((lectura = lector.ReadLine()) != null) { ltb_cont.Items.Add(lectura + " - " + lector.ReadLine()); } lector.Close(); } } private void ltb_cont_SelectedIndexChanged(object sender, EventArgs e) { txt_nom.Text = ltb_cont.SelectedItem.ToString().Trim(); } private void btn_eliminar_Click(object sender, EventArgs e) { if (txt_nom.Text != "") { string lectura = ""; StreamReader lector = new StreamReader("Agenda.txt"); StreamWriter escritorback = new StreamWriter("AgendaBACK.txt"); while ((lectura = lector.ReadLine()) != null) { if (lectura == txt_nom.Text) { lector.ReadLine(); } else { escritorback.WriteLine(lectura); } } escritorback.Close(); lector.Close(); File.Delete("Agenda.txt"); File.Copy("AgendaBACK.txt", "Agenda.txt"); File.Delete("AgendaBACK.txt"); MessageBox.Show("Contacto eliminado", "Exito", MessageBoxButtons.OK, MessageBoxIcon.Information); txt_nom.Clear(); Form3_Load(sender, e); } else { MessageBox.Show("Debe elegir un contacto para eliminar", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } } private void btn_cancel_Click(object sender, EventArgs e) { this.Close(); } } } namespace Agenda5 { partial class Form3 { ////// Variable del diseñador requerida. /// private System.ComponentModel.IContainer components = null; ////// Limpiar los recursos que se estén utilizando. /// /// true si los recursos administrados se deben eliminar; false en caso contrario, false. protected override void Dispose(bool disposing) { if (disposing && (components != null)) { components.Dispose(); } base.Dispose(disposing); } #region Código generado por el Diseñador de Windows Forms ////// Método necesario para admitir el Diseñador. No se puede modificar /// el contenido del método con el editor de código. /// private void InitializeComponent() { this.ltb_cont = new System.Windows.Forms.ListBox(); this.lb_agenda = new System.Windows.Forms.Label(); this.btn_cancel = new System.Windows.Forms.Button(); this.btn_elim = new System.Windows.Forms.Button(); this.txt_nom = new System.Windows.Forms.TextBox(); this.lb_nom = new System.Windows.Forms.Label(); this.SuspendLayout(); // // ltb_cont // this.ltb_cont.FormattingEnabled = true; this.ltb_cont.Location = new System.Drawing.Point(12, 44); this.ltb_cont.Name = "ltb_cont"; this.ltb_cont.Size = new System.Drawing.Size(268, 264); this.ltb_cont.TabIndex = 0; this.ltb_cont.SelectedIndexChanged += new System.EventHandler(this.ltb_cont_SelectedIndexChanged); // // lb_agenda // this.lb_agenda.AutoSize = true; this.lb_agenda.Location = new System.Drawing.Point(88, 19); this.lb_agenda.Name = "lb_agenda"; this.lb_agenda.Size = new System.Drawing.Size(116, 13); this.lb_agenda.TabIndex = 1; this.lb_agenda.Text = "ELIMINAR CONTACTO"; // // btn_cancel // this.btn_cancel.Location = new System.Drawing.Point(161, 351); this.btn_cancel.Name = "btn_cancel"; this.btn_cancel.Size = new System.Drawing.Size(75, 23); this.btn_cancel.TabIndex = 12; this.btn_cancel.Text = "Cancelar"; this.btn_cancel.UseVisualStyleBackColor = true; this.btn_cancel.Click += new System.EventHandler(this.btn_cancel_Click); // // btn_elim // this.btn_elim.Location = new System.Drawing.Point(56, 351); this.btn_elim.Name = "btn_elim"; this.btn_elim.Size = new System.Drawing.Size(75, 23); this.btn_elim.TabIndex = 11; this.btn_elim.Text = "Eliminar"; this.btn_elim.UseVisualStyleBackColor = true; this.btn_elim.Click += new System.EventHandler(this.btn_eliminar_Click); // // txt_nom // this.txt_nom.Location = new System.Drawing.Point(91, 314); this.txt_nom.Name = "txt_nom"; this.txt_nom.ReadOnly = true; this.txt_nom.Size = new System.Drawing.Size(181, 22); this.txt_nom.TabIndex = 9; // // lb_nom // this.lb_nom.AutoSize = true; this.lb_nom.Location = new System.Drawing.Point(21, 317); this.lb_nom.Name = "lb_nom"; this.lb_nom.Size = new System.Drawing.Size(48, 13); this.lb_nom.TabIndex = 7; this.lb_nom.Text = "Nombre"; // // Form3 // this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; this.ClientSize = new System.Drawing.Size(292, 386); this.Controls.Add(this.btn_cancel); this.Controls.Add(this.btn_elim); this.Controls.Add(this.txt_nom); this.Controls.Add(this.lb_nom); this.Controls.Add(this.lb_agenda); this.Controls.Add(this.ltb_cont); this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle; this.MaximizeBox = false; this.Name = "Form3"; this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; this.Text = "Eliminar Contacto"; this.Load += new System.EventHandler(this.Form3_Load); this.ResumeLayout(false); this.PerformLayout(); } #endregion private System.Windows.Forms.ListBox ltb_cont; private System.Windows.Forms.Label lb_agenda; private System.Windows.Forms.Button btn_cancel; private System.Windows.Forms.Button btn_elim; private System.Windows.Forms.TextBox txt_nom; private System.Windows.Forms.Label lb_nom; } }
using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Text; using System.Windows.Forms; namespace Agenda6 { public partial class Form1 : Form { public Form1() { InitializeComponent(); } private void btn_agregar_Click(object sender, EventArgs e) { Form2 form2 = new Form2(); form2.ShowDialog(this); } private void btn_eliminar_Click(object sender, EventArgs e) { Form3 form3 = new Form3(0); form3.ShowDialog(this); } private void btn_listar_Click(object sender, EventArgs e) { Form3 form3 = new Form3(1); form3.ShowDialog(this); } private void btn_salir_Click(object sender, EventArgs e) { Application.Exit(); } } } using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Text; using System.Windows.Forms; using System.Data.OleDb; namespace Agenda6 { public partial class Form2 : Form { public Form2() { InitializeComponent(); } private void btn_aceptar_Click(object sender, EventArgs e) { if (txt_nom.Text != "" && txt_tel.Text != "") { try { OleDbConnection con = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=Agenda.mdb;User Id=admin;Password=;"); con.Open(); string insert = "INSERT INTO contactos (nom,tel) VALUES ('" + txt_nom.Text + "','" + txt_tel.Text + "');"; OleDbCommand com = new OleDbCommand(insert, con); com.ExecuteNonQuery(); con.Close(); MessageBox.Show("Contacto ingresado", "Exito", MessageBoxButtons.OK, MessageBoxIcon.Information); btn_cancel_Click(sender, e); } catch { MessageBox.Show("Ocurrió un error cuando se estaba ingresando.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); txt_nom.SelectAll(); txt_nom.Focus(); } } else { MessageBox.Show("Debe ingresar el nombre y el teléfono para agregar el contacto", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); txt_nom.SelectAll(); txt_nom.Focus(); } } private void btn_cancel_Click(object sender, EventArgs e) { this.Close(); } } } using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Text; using System.Windows.Forms; using System.Data.OleDb; namespace Agenda6 { public partial class Form3 : Form { int Num; public Form3(int num) { InitializeComponent(); Num = num; } private void Form3_Load(object sender, EventArgs e) { if (Num == 0) { ltb_cont.Items.Clear(); OleDbConnection con = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=Agenda.mdb;User Id=admin;Password=;"); con.Open(); string select = "SELECT nom FROM contactos ORDER BY nom;"; OleDbCommand com = new OleDbCommand(select, con); OleDbDataReader lector = com.ExecuteReader(); while (lector.Read()) { ltb_cont.Items.Add(lector.GetValue(0).ToString().Trim()); } con.Close(); } else { this.Text = "Listar Contactos"; lb_agenda.Text = "LISTAR CONTACTOS"; lb_nom.Visible = false; txt_nom.Visible = false; ltb_cont.Size = new Size(268, 310); btn_elim.Visible = false; btn_cancel.Location = new Point(110, 351); btn_cancel.Text = "Cerrar"; ltb_cont.Items.Clear(); OleDbConnection con = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=Agenda.mdb;User Id=admin;Password=;"); con.Open(); string select = "SELECT nom,tel FROM contactos ORDER BY nom;"; OleDbCommand com = new OleDbCommand(select, con); OleDbDataReader lector = com.ExecuteReader(); while (lector.Read()) { ltb_cont.Items.Add(lector.GetValue(0).ToString().Trim() + " - " + lector.GetValue(1).ToString().Trim()); } con.Close(); } } private void ltb_cont_SelectedIndexChanged(object sender, EventArgs e) { txt_nom.Text = ltb_cont.SelectedItem.ToString().Trim(); } private void btn_elim_Click(object sender, EventArgs e) { if (txt_nom.Text != "") { OleDbConnection con = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=Agenda.mdb;User Id=admin;Password=;"); con.Open(); string delete = "DELETE FROM contactos WHERE nom='" + txt_nom.Text + "'"; OleDbCommand com = new OleDbCommand(delete, con); com.ExecuteNonQuery(); con.Close(); MessageBox.Show("Contacto eliminado", "Exito", MessageBoxButtons.OK, MessageBoxIcon.Information); txt_nom.Clear(); Form3_Load(sender, e); } else { MessageBox.Show("Debe elegir un contacto para eliminar", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } } private void btn_cancel_Click(object sender, EventArgs e) { this.Close(); } } } using System; using System.Collections.Generic; using System.Windows.Forms; namespace Agenda6 { static class Program { ////// Punto de entrada principal para la aplicación. /// [STAThread] static void Main() { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new Form1()); } } } namespace Agenda6 { partial class Form1 { ////// Variable del diseñador requerida. /// private System.ComponentModel.IContainer components = null; ////// Limpiar los recursos que se estén utilizando. /// /// true si los recursos administrados se deben eliminar; false en caso contrario, false. protected override void Dispose(bool disposing) { if (disposing && (components != null)) { components.Dispose(); } base.Dispose(disposing); } #region Código generado por el Diseñador de Windows Forms ////// Método necesario para admitir el Diseñador. No se puede modificar /// el contenido del método con el editor de código. /// private void InitializeComponent() { this.btn_salir = new System.Windows.Forms.Button(); this.btn_listar = new System.Windows.Forms.Button(); this.btn_eliminar = new System.Windows.Forms.Button(); this.btn_agregar = new System.Windows.Forms.Button(); this.lb_agenda = new System.Windows.Forms.Label(); this.SuspendLayout(); // // btn_salir // this.btn_salir.Location = new System.Drawing.Point(108, 138); this.btn_salir.Name = "btn_salir"; this.btn_salir.Size = new System.Drawing.Size(75, 23); this.btn_salir.TabIndex = 9; this.btn_salir.Text = "Salir"; this.btn_salir.UseVisualStyleBackColor = true; this.btn_salir.Click += new System.EventHandler(this.btn_salir_Click); // // btn_listar // this.btn_listar.Location = new System.Drawing.Point(108, 109); this.btn_listar.Name = "btn_listar"; this.btn_listar.Size = new System.Drawing.Size(75, 23); this.btn_listar.TabIndex = 8; this.btn_listar.Text = "Listar"; this.btn_listar.UseVisualStyleBackColor = true; this.btn_listar.Click += new System.EventHandler(this.btn_listar_Click); // // btn_eliminar // this.btn_eliminar.Location = new System.Drawing.Point(108, 80); this.btn_eliminar.Name = "btn_eliminar"; this.btn_eliminar.Size = new System.Drawing.Size(75, 23); this.btn_eliminar.TabIndex = 7; this.btn_eliminar.Text = "Eliminar"; this.btn_eliminar.UseVisualStyleBackColor = true; this.btn_eliminar.Click += new System.EventHandler(this.btn_eliminar_Click); // // btn_agregar // this.btn_agregar.Location = new System.Drawing.Point(108, 51); this.btn_agregar.Name = "btn_agregar"; this.btn_agregar.Size = new System.Drawing.Size(75, 23); this.btn_agregar.TabIndex = 6; this.btn_agregar.Text = "Agregar"; this.btn_agregar.UseVisualStyleBackColor = true; this.btn_agregar.Click += new System.EventHandler(this.btn_agregar_Click); // // lb_agenda // this.lb_agenda.AutoSize = true; this.lb_agenda.Location = new System.Drawing.Point(79, 20); this.lb_agenda.Name = "lb_agenda"; this.lb_agenda.Size = new System.Drawing.Size(135, 13); this.lb_agenda.TabIndex = 5; this.lb_agenda.Text = "AGENDA CON VENTANAS"; // // Form1 // this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; this.ClientSize = new System.Drawing.Size(292, 186); this.Controls.Add(this.btn_salir); this.Controls.Add(this.btn_listar); this.Controls.Add(this.btn_eliminar); this.Controls.Add(this.btn_agregar); this.Controls.Add(this.lb_agenda); this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle; this.MaximizeBox = false; this.Name = "Form1"; this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; this.Text = "Agenda con Ventanas"; this.ResumeLayout(false); this.PerformLayout(); } #endregion private System.Windows.Forms.Button btn_salir; private System.Windows.Forms.Button btn_listar; private System.Windows.Forms.Button btn_eliminar; private System.Windows.Forms.Button btn_agregar; private System.Windows.Forms.Label lb_agenda; } } using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Text; using System.Windows.Forms; using System.Data.OleDb; namespace Agenda6 { public partial class Form2 : Form { public Form2() { InitializeComponent(); } private void btn_aceptar_Click(object sender, EventArgs e) { if (txt_nom.Text != "" && txt_tel.Text != "") { try { OleDbConnection con = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=Agenda.mdb;User Id=admin;Password=;"); con.Open(); string insert = "INSERT INTO contactos (nom,tel) VALUES ('" + txt_nom.Text + "','" + txt_tel.Text + "');"; OleDbCommand com = new OleDbCommand(insert, con); com.ExecuteNonQuery(); con.Close(); MessageBox.Show("Contacto ingresado", "Exito", MessageBoxButtons.OK, MessageBoxIcon.Information); btn_cancel_Click(sender, e); } catch { MessageBox.Show("Ocurrió un error cuando se estaba ingresando.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); txt_nom.SelectAll(); txt_nom.Focus(); } } else { MessageBox.Show("Debe ingresar el nombre y el teléfono para agregar el contacto", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); txt_nom.SelectAll(); txt_nom.Focus(); } } private void btn_cancel_Click(object sender, EventArgs e) { this.Close(); } } } namespace Agenda6 { partial class Form3 { ////// Variable del diseñador requerida. /// private System.ComponentModel.IContainer components = null; ////// Limpiar los recursos que se estén utilizando. /// /// true si los recursos administrados se deben eliminar; false en caso contrario, false. protected override void Dispose(bool disposing) { if (disposing && (components != null)) { components.Dispose(); } base.Dispose(disposing); } #region Código generado por el Diseñador de Windows Forms ////// Método necesario para admitir el Diseñador. No se puede modificar /// el contenido del método con el editor de código. /// private void InitializeComponent() { this.btn_cancel = new System.Windows.Forms.Button(); this.btn_elim = new System.Windows.Forms.Button(); this.txt_nom = new System.Windows.Forms.TextBox(); this.lb_nom = new System.Windows.Forms.Label(); this.lb_agenda = new System.Windows.Forms.Label(); this.ltb_cont = new System.Windows.Forms.ListBox(); this.SuspendLayout(); // // btn_cancel // this.btn_cancel.Location = new System.Drawing.Point(161, 348); this.btn_cancel.Name = "btn_cancel"; this.btn_cancel.Size = new System.Drawing.Size(75, 23); this.btn_cancel.TabIndex = 18; this.btn_cancel.Text = "Cancelar"; this.btn_cancel.UseVisualStyleBackColor = true; this.btn_cancel.Click += new System.EventHandler(this.btn_cancel_Click); // // btn_elim // this.btn_elim.Location = new System.Drawing.Point(56, 348); this.btn_elim.Name = "btn_elim"; this.btn_elim.Size = new System.Drawing.Size(75, 23); this.btn_elim.TabIndex = 17; this.btn_elim.Text = "Eliminar"; this.btn_elim.UseVisualStyleBackColor = true; this.btn_elim.Click += new System.EventHandler(this.btn_elim_Click); // // txt_nom // this.txt_nom.Location = new System.Drawing.Point(91, 311); this.txt_nom.Name = "txt_nom"; this.txt_nom.ReadOnly = true; this.txt_nom.Size = new System.Drawing.Size(181, 22); this.txt_nom.TabIndex = 16; // // lb_nom // this.lb_nom.AutoSize = true; this.lb_nom.Location = new System.Drawing.Point(21, 314); this.lb_nom.Name = "lb_nom"; this.lb_nom.Size = new System.Drawing.Size(48, 13); this.lb_nom.TabIndex = 15; this.lb_nom.Text = "Nombre"; // // lb_agenda // this.lb_agenda.AutoSize = true; this.lb_agenda.Location = new System.Drawing.Point(88, 16); this.lb_agenda.Name = "lb_agenda"; this.lb_agenda.Size = new System.Drawing.Size(116, 13); this.lb_agenda.TabIndex = 14; this.lb_agenda.Text = "ELIMINAR CONTACTO"; // // ltb_cont // this.ltb_cont.FormattingEnabled = true; this.ltb_cont.Location = new System.Drawing.Point(12, 41); this.ltb_cont.Name = "ltb_cont"; this.ltb_cont.Size = new System.Drawing.Size(268, 264); this.ltb_cont.TabIndex = 13; this.ltb_cont.SelectedIndexChanged += new System.EventHandler(this.ltb_cont_SelectedIndexChanged); // // Form3 // this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; this.ClientSize = new System.Drawing.Size(292, 386); this.Controls.Add(this.btn_cancel); this.Controls.Add(this.btn_elim); this.Controls.Add(this.txt_nom); this.Controls.Add(this.lb_nom); this.Controls.Add(this.lb_agenda); this.Controls.Add(this.ltb_cont); this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle; this.MaximizeBox = false; this.Name = "Form3"; this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; this.Text = "Eliminar Contacto"; this.Load += new System.EventHandler(this.Form3_Load); this.ResumeLayout(false); this.PerformLayout(); } #endregion private System.Windows.Forms.Button btn_cancel; private System.Windows.Forms.Button btn_elim; private System.Windows.Forms.TextBox txt_nom; private System.Windows.Forms.Label lb_nom; private System.Windows.Forms.Label lb_agenda; private System.Windows.Forms.ListBox ltb_cont; } }
Te cuento que mucha de la información que leerás en esta page, la aprendi con el auxilio de la siguiente bibliografia:
LIBRO AUTOR EDITORIAL AÑO Programación C++ - Luis Joyanes - Mc Graw Hill 1999 C++ Cómo programar - Deitel y Deitel - Prentice Hall 1999 Visual C++ 6 - Kate gregory - Prentice Hall 2000 Visual C++ 6 - Cris H. Pappas - Mc Graw - Hill 2000 Visual C++6 Manual - Beck Zaratian - Mc Graw Hill 1999 Visual C++6 - Holzner - Mc Graw Hill 1999 Manual C / C++ - Wiliam H. Murray - Mc Graw Hill 1997 Visual C++6 - María Cascon Sánchez - Prentice Hall 1999 Visual C++ - Ori y Nathan Gurenwich - SAMS Publishing 1998 C++ Builder 5 - Fransisco Charte - Anaya 2000 Visual C# - Erika Alarcon - Megabyte 2004 Visual C#.NET 2008 - Cristina Sanchez - Edit MACRO 2008 Entornos y Metodologias de Programación - Alonso Amo - Paraninfo 2000 Lenguajes de Programación - Ravi Sethi - Addison-Wesley 2000 Lenguajes de Programación - Mauricio Strauchler Orientación a Objetos - Carlos Fontela - Nueva Librería 2008
|
||
BONUS: En este ámbito paradigmático ademas te ofrezco:
|
||
Lenguajes | Gramáticas | |
Autómatas | Series | |
Laplace | Ecuación | |
Operador | Compilador |
Y para el cruel que me arranca
el corazón con que vivo,
cardo ni ortiga cultivo;
..cultivo una rosa blanca..!
José Martí
Te espero en: wilucha@gmail.com
Esta page está en: www.wilocarpio.com
18/10/2010