Fecha y hora actual: Viernes 23 Jun 2017 19:47
Índice del Foro

Foros de programación informática, diseño gráfico y Web

En esta comunidad intentaremos dar soporte de programación a todos los niveles, desde principiantes a profesionales de la informática, desarrollo de programas, programación web y mucho más.

Programando desde 0: 19- Más tipos a definir: Registros.

Responder al Tema Ir a página 12Siguiente

Índice del Foro > Programación en general > Programando desde 0: 19- Más tipos a definir: Registros.

Autor Mensaje
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1015

Mensaje Publicado: Lunes 27 Jun 2011 22:53

Título del mensaje: Programando desde 0: 19- Más tipos a definir: Registros.

Responder citando

Lección 19: Más tipos a definir por el programador: Los Registros.

Seguimos aprendiendo tipos que nosotros mismos podremos definir en nuestros programas. Llegó la hora de darle un poco más de diversidad a esos tipos, o sea, de poder almacenar información un poco más completa y de diversos tipos. Veamos cómo lograr eso:

Registros:

Los tipos de datos que hemos visto hasta ahora han podido ser primitivos (char, integer, real, boolean) o estructurados (subrangos, arreglos, enumerados). Los tres tipos estructurados que vimos son homogéneos, o sea, que todos los datos que contienen son de un mismo tipo. Por ejemplo, en un arreglo todas las celdas contienen datos de un mismo tipo, ya sean enteros, reales, u otro tipo definidos por ustedes mismos. Un subrango no es más que un intervalo más pequeño dentro de un conjunto de elementos mayor, pero sigue contiendo todos sus elementos de un mismo tipo. Aquí es donde los registros se diferencian de todos los demás tipos ya que pueden contener muchos datos y todos de diferentes tipos.
Por ejemplo, podríamos tener un registro que contenga caracteres, enteros, reales, cadenas, arreglos y mucho más. Para ser un poco más específicos, podríamos crear un registro que dada una persona contenga su nombre, apellido, edad, documento de identidad, dirección, fecha de nacimiento, y todo lo que a ustedes se les ocurra.


Declaración:

Bien, primero les diré como se declara genéricamente un registro, luego veremos un ejemplo de programa donde guardaremos datos de dos personas, primero sin usar registros y luego usándolos.

Código:
Type
NombreDelRegistro= Record
   campo1: tipo;
   campo2: tipo;
   .
   .
   .
   campoN: tipo;
End;


Como estamos hablando de un tipo resulta obvio que declararemos un registro debajo de la palabra TYPE. Al igual que a los demás tipos definidos por ustedes mismos debemos darle un nombre seguido del signo de igual y luego utilizamos la palabra reservada RECORD (registro en inglés). Después definimos cada uno de los campos que contendrá tal como si fueran variables (en efecto eso son), o sea, le damos un nombre seguido por dos puntos y luego le asignamos un tipo cualquiera recordando que si usaremos uno definido por nosotros mismos debemos haber declarado este antes.

Veamos un ejemplo de declaración de un registro llamado ESTUDIANTE en el cual guardaremos el nombre de un estudiante, su edad, su documento de identidad y el grado que cursa:

Código:
Type
   Grados= (primero, segundo, tercero, cuarto, quinto, sexto);

   Estudiante= record
      nombre: string;
      edad, documento: integer;
      grado: Grados;
   End;

Como ven primero tenemos un tipo llamado GRADOS que no es más que un enumerado de los grados posibles que un estudiante puede cursar. Nuestro registro contiene cuatro campos (variables), una del tipo string, dos del tipo integer y una última del tipo grados, el cual fue declarado previamente por nosotros mismos.

Ahora veamos los dos ejemplos de los que hablé para ver cómo funcionan los registros. En el siguiente programa guardaremos el nombre, la edad, el documento de identidad y el grado de dos estudiantes distintos. Todos estos datos los asignaremos nosotros manualmente internamente en el programa, o sea, no haremos READ de nada, simplemente le daremos valores a nuestras variables y ya, como si nuestros estudiantes vinieran precargados en el programa:

Código:
1.   PROGRAM Reg1;
2.
3.   TYPE
4.      Grados= (primero, segundo, tercero, cuarto, quinto, sexto);
5.
6.   VAR
7.      NombreEstudiante1, NombreEstudiante2: String;
8.      EdadEstudiante1, EdadEstudiante2: Integer;
9.      DocumentoEstudiante1, DocumentoEstudiante2: Integer;
10.    GradoEstudiante1, GradoEstudiante2: Grados;
11.
12. BEGIN
13. NombreEstudiante1:= 'Fulano de Tal';
14. EdadEstudiante1:= 16;
15. DocumentoEstudiante1:= 12345;
16. GradoEstudiante1:= cuarto;
17.
18. NombreEstudiante2:= 'Mengano';
19. EdadEstudiante2:= 18;
20. DocumentoEstudiante2:= 16543;
21. GradoEstudiante2:= sexto;
22. END.

Muy bien, este programa no representa ningún tipo de dificultad para ustedes, simplemente declaramos variables y las inicializamos con valores adecuados a su tipo. Tal vez debo aclarar por qué en las líneas 8 y 9 declaré cuatro variables integer cuando podría haber usado una sola línea. Simplemente para separar las variables que se corresponden con la edad a las que se corresponden con los documentos de identidad. Este programa sería mejor si obtuviera los datos de la entrada estándar, sin embargo eso solo es utilizar READ en cada línea y ya. Ustedes mismos pueden hacerlo si quieren.

Ahora veamos el mismo programa pero usando un registro:
Código:
1.   PROGRAM Reg1;
2.
3.   TYPE
4.      Grados= (primero, segundo, tercero, cuarto, quinto, sexto);
5.
6.      Estudiante= RECORD
7.         Nombre: String;
8.         Edad, Documento: Integer;
9.         Grado: Grados;
10.    END;
11.
12. VAR
13.    Est1, Est2: Estudiante;
14.
15. BEGIN
16. Est1.Nombre:= 'Fulano de Tal';
17. Est1.Edad:= 16;
18. Est1.Documento:= 12345;
19. Est1.Grado:= cuarto;
20.
21. Est2.Nombre:= 'Mengano';
22. Est2.Edad:= 18;
23. Est2.Documento:= 16543;
24. Est2.Grado:= sexto;
25. END.

Bien. Como ven, luego del tipo Grados he declarado el tipo Estudiante que es un registro. Es el mismo que usé como primer ejemplo. Dicho registro tiene cuatro campos que funcionan tal cual las variables que ya conocen y se declaran de la misma manera. Como el registro es un tipo creado por nosotros mismos, debemos declarar variables de ese tipo para poder usarlo. Eso hice en la línea 13 de nuestro programa, declaré las variables Est1 y Est2 del tipo Estudiante. Cada una de estas variables contiene a las otras cuatro “dentro”. De este modo tendremos una variable Nombre, una Edad, una Documento, y una Grados para Est1 así como otras cuatro para Est2.

Si queremos acceder a la variable Nombre de Est1 lo hacemos mediante la notación Est1.Nombre. Así con todas las demás. De forma genérica, si tengo un registro genérico como el siguiente

Código:
MiRegistro= RECORD
   Campo1: Tipo1;
   Campo2: Tipo2;
   . . .
   CampoN: TipoN;
END;

y luego declaro una variable MiVariable: MiRegistro; , o sea, una variable llamada MiVariable del tipo MiRegistro, para acceder al Campo1 escribo MiVariable.Campo1, lo mismo si quiero acceder al Campo2. O sea, para acceder al campo número I, si I es un número entre 1 y N, escribo MiVariable.CampoI.

Los campos de un registro son variables comunes y corrientes y por tanto todo lo que aplicamos a estas se aplica a dichos campos.

El hecho de tener una estructura como esta es para facilitar las cosas, o sea, imaginen que no tenemos el tipo RECORD, deberíamos hacer todo como lo hice yo en el ejemplo de los estudiantes, o sea, declarar tantas variables como datos queremos tener para cada uno de nuestras personas.
Para nuestros ejemplos teníamos cuatro datos a guardar para cada estudiante, o sea que deberíamos declarar manualmente cuatro variables por cada uno de ellos. Si en vez de solo dos personas tuviéramos cincuenta, cien, o muchas mas, la cosa se volvería sumamente tediosa. ¿Y si tenemos que buscar algún dato de algún estudiante en particular? ¿Si hay que modificar algo?

En tanto sigamos avanzando verán cuanto simplifican el trabajo los registros. Por eso les pido que trabajen con ellos en todo lo que les ponga como ejercicios.

-------------------------------------------------------------------------------------

Una estructura compleja:

Teniendo los registros podemos crear estructuras muy complejas. Simplemente citaré un ejemplo para que les quede ya que lo necesitarán para trabajar en lo que se viene.
Supongan las siguiente declaración

Código:
TYPE
   Registro= Record
      Nombre: String;
      Documento: Integer;
      Edad: Integer;
End;

   ListaRegistro= Array[1..7] of Registro;

VAR
   MiLista: ListaRegistro;

Como pueden observar simplemente he declarado un registro de tres campos y luego un arreglo de siete celdas donde cada una corresponde al registro. Si lo dibujara podríamos tener algo así:



Si cada celda es un registro, entonces para acceder al campo Nombre de la celda número 1 tendríamos lo siguiente:

Código:
MiLista[1].Nombre


Recuerden que cada celda de un arreglo es como una variable del tipo del arreglo, por lo tanto, cada celda de este arreglo es del tipo Registro por lo cual funciona como tal. Espero que este simple ejemplo les sirva para visualizar esto.

Ahora les propongo un ejercicio para comprender mejor lo básico de los registros para luego continuar con un programa más complejo:

Ejercicio 1: Determinen cuáles de las siguientes definiciones de registro son válidas:
a)
Código:
TYPE
   estado = RECORD
      nombre : ARRAY[1..30] OF CHAR;
      edad : 0..120;
      sexo : (Fem, Masc);


b)
Código:
TYPE
   ejemplo = RECORD
      prueba : 0..100;
      final : 'A'..'F';
     orden : 1..100
   END;


c)
Código:
TYPE
   franco = RECORD
      prueba : 0..100;
      examen : 0..10;
      prueba : 0..100
   END;


d)
Código:
TYPE
   califs = RECORD
      nombre,
      direccion : ARRAY[1..30] OF CHAR;
      prueba,
      examen : 0..100;
      tipoest : (flojo, trabajador, puntual, impuntual)
   END;

------------------------------------------------------------------------------------

Ejercicio 2:

Dado un registro para guardar datos de estudiantes tal como el que ya vimos, teniendo en mente también el tipo Grados

Código:

TYPE
     Grados= (primero, segundo, tercero, cuarto, quinto, sexto);

     Estudiante= RECORD
        Nombre: String;
        Edad, Documento: Integer;
        Grado: Grados;
    END;



sabiendo que cada campo del registro es una variable, podemos ingresar datos al mismo desde la entrada estándar. Por ejemplo, si tenemos una variable Est1 del tipo Estudiante, podríamos leer el nombre del estudiante desde la entrada estándar de la siguiente manera:

Código:
Read(Est1.Nombre);


Del mismo modo podemos leer los demás datos excepto Grados ya que es un enumerado y debemos pensar un poco más.

Teniendo los tipos anteriores y la siguiente declaración de un nuevo tipo:

Código:
BasesEstuidantes= Array[1..10] Of Estudiante;


y una variable

Código:
Est: BaseEstudiantes;


se pide crear un programa en pascal que lea los datos de la entrada estándar para los 10 estudiantes que se pueden guardar en Est, y luego permita buscar un estudiante según su Documento y muestre todos sus datos.

Este ejercicio lo he pensado para que apliquen todo lo que acabo de enseñar más alguna cosita de antes.

Mucha suerte, y tengan en mente que estaré para ayudarles.
Saludos.[/b]

Volver arriba
Ver perfil del usuario Enviar mensaje privado
juan alejandro
Usuario Iniciado


Registrado: 07 Ene 2011
Mensajes: 43
Ubicación: Bogotá - Colombia

Mensaje Publicado: Miércoles 29 Jun 2011 13:38

Título del mensaje: Re: Programando desde 0: 19- Más tipos a definir: Registros.

Responder citando

Oye muchisimas gracias por esta lección, es algo que no conocía en cuanto a programación, vamos a practicar.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
espino316
Usuario Iniciado


Registrado: 13 Ene 2010
Mensajes: 16
Ubicación: Monterrey - Mexico

Mensaje Publicado: Jueves 11 Ago 2011 21:10

Título del mensaje: Re: Programando desde 0: 19- Más tipos a definir: Registros.

Responder citando

Los registros son como las estructuras en C, ¿Como se haría un arreglo de registros?

EDIT:
---------------

Nevermind, en la última lección (21) viene.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1015

Mensaje Publicado: Jueves 11 Ago 2011 21:20

Título del mensaje: Re: Programando desde 0: 19- Más tipos a definir: Registros.

Responder citando

espino316 escribió:
Los registros son como las estructuras en C, ¿Como se haría un arreglo de registros?

EDIT:
---------------

Nevermind, en la última lección (21) viene.


En esta misma lección, justo al final, antes de los ejercicios, hay un título que dice Una estructura compleja y explica justamente como hacer un arreglo de registros.

Saludos.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Sebastián Marcos
Usuario Inquieto


Registrado: 04 Oct 2011
Mensajes: 133

Mensaje Publicado: Viernes 14 Oct 2011 04:28

Título del mensaje: Re: Programando desde 0: 19- Más tipos a definir: Registros.

Responder citando

Hola a todos !!!.
Primero que nada, y como siempre, debo agradecer a Kyshuo por este fantástico curso. Este tipo de oportunidades que se presentan en internet no hay que desperdiciarlas; por eso animo a todos los que estén interesados en iniciarse en la programación a que se dispongan a trabajar (el trabajo y la práctica son fundamentales en esto), y así progresar paso a paso teniendo este curso como guia fundamental.

Aquí publico el código del Ejercicio 2. Me costó un poco la parte de imprimir el grado del estudiante, ya que no se pueden utilizar los procedimientos read(ln) ni write(ln) con enumerados; pero al final salió tomando como referencia el ejemplo de la lección.
Me gustaría que me dijieran si hay algo que criticarle al código. Por ejemplo si se puede reducir un poco la extensión. Desde un tiempo a la parte se me presenta la necesidad (aunque a veces no lo logro) de hacer los códigos lo más compactos posibles (No sé hasta dónde esto puede ser beneficioso para la comprensión del mismo, pero queda más lindo a la vista).
La única variante que le realicé a la letra del problema es que utilicé una constante para marcar el tope del arreglo y no dejarlo fijo en 10).
Una pregunta más, las soluciones de los ejercicios de la lección 11 en adelante no están publicadas, supongo que en parte es por culpa nuestra al no publicar en las lecciones, por eso nuevamente animo a todos a trabajar !!!.
Un abrazo grande para todos !!!:

Aquí el código:

Código:
program Ejercicio2_Leccion19;

const N=10;

type
   Grados=(primero, segundo, tercero, cuarto, quinto, sexto);

   Estudiante=Record
      nombre: string;
      edad, documento: integer;
      grado: Grados;
   end;

   BasesEstudiantes=array[1..N] of Estudiante;

var
   est: BasesEstudiantes;
   docum: integer;   {auxiliar para buscar estudiante por documento}
   i: integer;
   aux: integer;   {auxiliar para el enumerado grados}

begin
   {ingreso de datos de los N estudiantes}
   writeln('Ingreso de datos de ',N,' estudiantes.');
   writeln;
   for i:=1 to N do
   begin
      writeln('Estudiante ',i);
      write('Nombre: ');
      readln(est[i].nombre);
      write('Documento: ');
      readln(est[i].documento);
      write('Edad: ');
      readln(est[i].edad);
      write('Grado (1 ... 6): ');
      readln(aux);
      est[i].grado:=grados(aux-1);
      writeln;
   end;

   {búsqueda del estudiante por su número de documento y}
   exposición de sus datos}
   writeln('Búsqueda de estudiante.');
   write('Ingrese el documento: ');
   readln(docum);

   {buscamos el estudiante por su número de documento en el arreglo}
   i:=1;
   while(est[i].documento<>docum) and (i<=N) do
      i:=i+1;

   if (est[i].documento=docum) then
   begin
      writeln('Nombre: ',est[i].nombre);
      writeln('Edad: ',est[i].edad);

      {escribimos el grado usando un case}
      write('Grado: ');
      case (ord(est[i].grado)+1) of
         1: write('primero');
         2: write('segundo');
         3: write('tercero');
         4: write('cuarto');
         5: write('quinto');
         6: write('sexto');
      end;
   end
   else
      begin
         write('Ese número de documento no corresponde a un estudiante ');
         write('de la lista.');
      end;

end.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1015

Mensaje Publicado: Viernes 14 Oct 2011 15:51

Título del mensaje: Re: Programando desde 0: 19- Más tipos a definir: Registros.

Responder citando

Amigo Sebastián, has hecho un trabajo excelente.

Este fragmento para leer el grado de un estudiante:

Código:
write('Grado (1 ... 6): ');
readln(aux);
est[i].grado:=grados(aux-1);
writeln;


está genial. Un tanto avanzado para los novatos, pero perfectamente aplicable con lo dado hasta el momento.

Lo único que yo cambiaría, pero por comodidad personal, es esto:

Código:
case (ord(est[i].grado)+1) of
         1: write('primero');
         2: write('segundo');
         3: write('tercero');
         4: write('cuarto');
         5: write('quinto');
         6: write('sexto');
      end;


Y lo haría así:

Código:
case est[i].grado of
      primero: write('primero');
      segundo: write('segundo');
      tercero: write('tercero');
      cuarto: write('cuarto');
      quinto: write('quinto');
      sexto: write('sexto');
end;


Como ves, podemos utilizar directamente un tipo enumerado en un CASE, no hace falta trabajar con su ordinal, que a mi juicio, es más complicado. De este modo el código queda aún más entendible.

A mi criterio está super compacto, acortarlo más podría hacerlo más complejo, aunque parezca mentira. A veces, los códigos cortos son muy compejos y difíciles de entender, aunque estamos de acuerdo que un código extenso es dificil de seguir. Debemos mediar entre ambas cosas.

Un trabajo excelente, la verdad.

Respecto a las soluciones, pues no he publicado más justamente porque nadie se ha preocupado más por los ejercicios. Nadie ha venido a preguntar cómo se hace tal o cual ejercicio de alguna de las lecciones posteriores a la 11.

Cuando vea que alguien intenta hacerlos entonces publicaré soluciones, en tanto, quedará así.

Gracias por tu trabajo. Muy bien hecho. Saludos.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
sr floyd
Usuario Activo


Registrado: 05 Sep 2011
Mensajes: 196

Mensaje Publicado: Miércoles 09 Nov 2011 01:33

Título del mensaje: Re: Programando desde 0: 19- Más tipos a definir: Registros.

Responder citando

los arreglos y el método de búsqueda lineal son dos herramientas potentes.

Volver arriba
Ver perfil del usuario Enviar mensaje privado MSN Messenger
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1015

Mensaje Publicado: Miércoles 09 Nov 2011 17:57

Título del mensaje: Re: Programando desde 0: 19- Más tipos a definir: Registros.

Responder citando

Pues sí, sin embargo la búsqueda por bipartición es mucho más potente en cuanto a eficiencia.

Como dije antes, todo tiene sus pro y sus contras. Los arreglos son perfectos en cuanto a eficiencia en velocidad de búsqueda porque uno puede ir a la celda número 873 sin necesidad de recorrer las 872 anteriores. Sin embargo son malos en cuanto a consumo de memoria, es decir, en cuanto a consumo de recursos del sistema.

Si tuvieras que guardar un máximo de un millón de datos en un arreglo, entonces tendrías un millón de celdas. Sin embargo tal vez para tu situación estarías guardando solo diez mil, por lo tanto estarías usando 990.000 celdas para nada, las cuales ocupan memoria.

Por esto existen estructuras de memoria dinámica, que permiten ocupar solo lo que se está utilizando. El problema es que se pierde velocidad al recorrer esos datos y por lo tanto, mejoramos el consumo de recursos pero perdemos eficiencia en velocidad.

Esto implica un problema típico para el cual no hay mucha solución:

  • Si mejoro la eficiencia en velocidad consumo recursos del sistema.
  • Si mejoro el consumo de recursos pierdo eficiencia en velocidad.


Entonces, dado el problema uno deberá decidir qué hacer.

Podría, por ejemplo, una empresa pedirnos un sistema de gestión de sus funcionarios exigiendo que el sistema sea rápido. Entonces usamos por ejemplo ARRAY.

Luego la empresa, por alguna razón, no tiene tantos recursos del sistema como antes y necesita que el programa no consuma tanto porque les entorpece otros asuntos. Entonces vamos y reestructuramos el sistema para que use memoria dinámica y no use memoria estática.

Eso es así.

Hay formas para utilizar memoria dinámica casi como estática, pero las veremos luego, y como todo, tienen sus contras. Por eso todo es importante, porque cada cosa responderá a distintos problemas.

Saludos.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
sr floyd
Usuario Activo


Registrado: 05 Sep 2011
Mensajes: 196

Mensaje Publicado: Miércoles 09 Nov 2011 20:06

Título del mensaje: Re: Programando desde 0: 19- Más tipos a definir: Registros.

Responder citando

muy buena aclaración! y me imagino que en algunos casos nos veremos obligados a usar un recurso determinado, por ejemplo refiriendome al ejercicio 2 de esta lección podría decidir por declarar como arreglo el tipo de la variable documento, ya que al declararlo tipo integer se está limitado al maximo valor de los enteros de pascal (mayormente los documentos de identidad tienen muchos digitos), pero al mismo tiempo al hacerlo como dices se consume mas recursos porque además hay que agregar instrucciones al programa.
Excelente detalle al brindarnos tu experiencia Kishuo !

Volver arriba
Ver perfil del usuario Enviar mensaje privado MSN Messenger
AndresTJ96
Usuario Iniciado


Registrado: 08 Dic 2011
Mensajes: 40

Mensaje Publicado: Lunes 12 Mar 2012 21:30

Título del mensaje: Re: Programando desde 0: 19- Más tipos a definir: Registros.

Responder citando

profe aki esta mi programa de los alumnos:

Código:
program ej19;
uses
        crt;

const
        n=10;

type
        grados= (primero, segundo, tercero, cuarto, quinto, sexto);

        Estudiante= record
                Nombre: string;
                Documento: integer;
                Edad:integer;
                Grado: grados;
        end;

        BasesEstudiantes= array[1..n] of Estudiante;

var
        Est: BasesEstudiantes;
        i, v, aux, doc: integer;
        x:char;
        z:string;
        error, salir:boolean;

procedure ingresalumno(c:integer);
begin
for i:=1 to c do
begin
writeln;
error:=true;
writeln('Estudiante ',i);
write('Nombre: ');
readln(z);
Est[i].Nombre:=z;
write('Documento: ');
readln(Est[i].Documento);
write('Edad: ');
readln(Est[i].Edad);
while (error=true) do
begin
write('Grado [1-6]: ');
readln(aux);
if (aux>6) then
error:=true
else
error:=false;
end;
Est[i].grado:=grados(aux);
end;
readln;
end;

procedure buscalumno (doc:integer);
begin
i:=1;
repeat
begin
if (Est[i].Documento<>doc) then
i:=i+1;
if (Est[i].Documento=doc) then
begin
writeln;
writeln('Estudiante N°',i);
writeln;
writeln('Nombre: ',Est[i].Nombre);
writeln('Documento: ',Est[i].Documento);
writeln('Edad: ',Est[i].Edad);
write('Grado: ');
case(ord(Est[i].Grado)) of
1: write('1');
2: write('2');
3: write('3');
4: write('4');
5: write('5');
6: write('6');
end;
error:=false;
end
else
begin
if (i>v) then
write('Ese documento no existe en la lista.');
error:=false;
end;
end;
until (i=v+1) or (error=false);
readln;
end;

Begin

        repeat
        begin
        clrscr;
        writeln;
        write('Seleccione una opcion: ');
        writeln;
        writeln('1. Ingresar datos de Estudiantes.');
        writeln('2. Buscar Estudiante.');
        writeln('3. Salir.');
        writeln;
        write('Opcion: ');
        read(x);
        case (x) of
        '1': begin
               clrscr;
               writeln('Ingrese el numero de estudiantes que va a fichar.');
               write('N°: ');
               readln(v);
               ingresalumno(v);
             end;
         '2': begin
                clrscr;
                error:=true;
                readln;
                writeln('Ingrese el documento del alumno a buscar.');
                writeln;
                write('N° documento: ');
                read(doc);
                readln;
                buscalumno(doc);
              end;

         '3': salir:=true;

        else
        begin
                writeln('Error. La opcion no existe.');
                error:=true;
        end;
        end;
        end;
        until (salir=true);
        readln;
       
End.

digame si tiene algun error.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
AndresTJ96
Usuario Iniciado


Registrado: 08 Dic 2011
Mensajes: 40

Mensaje Publicado: Lunes 12 Mar 2012 22:52

Título del mensaje: Re: Programando desde 0: 19- Más tipos a definir: Registros.

Responder citando

profe mejor pruebe este encontré un error y lo arreglé:

Código:
program ej19alumnos;
uses
        crt;

const
        n=10;

type
        grados= (primero, segundo, tercero, cuarto, quinto, sexto);

        Estudiante= record
                Nombre: string;
                Documento: integer;
                Edad:integer;
                Grado: grados;
        end;

        BasesEstudiantes= array[1..n] of Estudiante;

var
        Est: BasesEstudiantes;
        i, v, aux, doc: integer;
        x:char;
        z:string;
        error, salir:boolean;
//ingresar los datos del alumno a la lista
procedure ingresalumno(c:integer);
begin
for i:=1 to c do
begin
        writeln;
        error:=true;
        writeln('Estudiante ',i);
        write('Nombre: ');
        readln(z);
        Est[i].Nombre:=z;
        write('Documento: ');
        readln(Est[i].Documento);
        write('Edad: ');
        readln(Est[i].Edad);
        while (error=true) do
        begin
                write('Grado [1-6]: ');
                readln(aux);
                if (aux>6) then
                        error:=true
                else
                        error:=false;
        end;
        Est[i].grado:=grados(aux);
end;
readln;
end;
//Buscar el alumno
procedure buscalumno (doc:integer);
begin
i:=1;
while (Est[i].Documento<>doc) do
        i:=i+1;
if (Est[i].Documento=doc) then
begin
        writeln;
        writeln('Estudiante N°',i);
        writeln;
        writeln('Nombre: ',Est[i].Nombre);
        writeln('Documento: ',Est[i].Documento);
        writeln('Edad: ',Est[i].Edad);
        write('Grado: ');
        case(ord(Est[i].Grado)) of
                1: write('1');
                2: write('2');
                3: write('3');
                4: write('4');
                5: write('5');
                6: write('6');
        end;
        error:=false;
end
else
begin
        if (i>v) then
                write('Ese documento no existe en la lista.');
                error:=false;
end;
readln;
end;

Begin
        //comienza bucle principal
        repeat
        begin
                clrscr;
                writeln;
                write('Seleccione una opcion: ');
                writeln;
                writeln('1. Ingresar datos de Estudiantes.');
                writeln('2. Buscar Estudiante.');
                writeln('3. Salir.');
                writeln;
                write('Opcion: ');
                read(x);
                case (x) of
                '1': begin
                        clrscr;
                        writeln('Ingrese el numero de estudiantes que va a fichar.');
                        write('N°: ');
                        readln(v);
                        ingresalumno(v);
                end;
                '2': begin
                        clrscr;
                        error:=true;
                        readln;
                        writeln('Ingrese el documento del alumno a buscar.');
                        writeln;
                        write('N° documento: ');
                        read(doc);
                        readln;
                        buscalumno(doc);
                end;
                '3': salir:=true;
                else
                begin
                        writeln('Error. La opcion no existe.');
                        error:=true;
                end;
                end;
        end;
        until (salir=true);
        readln;

End.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
tugatime
Usuario Inquieto


Registrado: 09 Oct 2012
Mensajes: 117

Mensaje Publicado: Miércoles 05 Dic 2012 19:38

Título del mensaje: Re: Programando desde 0: 19- Más tipos a definir: Registros.

Responder citando

Dejo mi duda de esta forma que asi se queda mejor y se entiende mejor.
Este es mi programa:

Código:
  1. program Productos_en_la_cesta;
  2.  
  3. uses crt;
  4.  
  5. const
  6. tamxcesta=3;
  7.  
  8. type
  9. producto = record
  10. nombre: string;
  11. num_unidades: integer;
  12. precio_unidad: real;
  13. en_cesta: boolean;
  14. end;
  15.  
  16. cesta=array[1..tamxcesta] of producto;
  17.  
  18. var
  19. mi_producto: producto;
  20. mi_cesta: cesta;
  21. i: integer;
  22. producto_en_cesta: string;
  23. exito: boolean;
  24.  
  25. procedure lee_producto(var mi_producto: producto);
  26. begin
  27. write('Introduzca su producto: ');
  28. readln(mi_producto.nombre);
  29. write('Introduzca la cantidad de su producto: ');
  30. readln(mi_producto.num_unidades);
  31. write('Introduzca el precio de cada unidad de su producto: ');
  32. readln(mi_producto.precio_unidad);
  33. mi_producto.en_cesta:=true;
  34. end;
  35.  
  36. procedure escribe_producto(var mi_producto: producto);
  37. begin
  38. writeln('Su producto es ',mi_producto.nombre,'.');
  39. writeln('Tienes una cantidad de ',mi_producto.num_unidades,' del producto.');
  40. writeln('El precio de cada unidad es de ',mi_producto.precio_unidad:0:2,'.');
  41. end;
  42.  
  43. procedure inicializa_cesta(var mi_cesta: cesta);
  44. var
  45. i: integer;
  46.  
  47. begin
  48. for i:=1 to tamxcesta do
  49. begin
  50. mi_cesta[i].nombre:= 'Nombre del producto';
  51. mi_cesta[i].num_unidades:= 0;
  52. mi_cesta[i].precio_unidad:= 0.00;
  53. mi_cesta[i].en_cesta:= false;
  54. end;
  55. end;
  56.  
  57. procedure mostrar_producto(var mi_producto: producto);
  58. begin
  59. mi_producto.nombre:= 'Nombre del producto';
  60. mi_producto.num_unidades:= 0;
  61. mi_producto.precio_unidad:= 0.00;
  62. mi_producto.en_cesta:= true;
  63.  
  64. writeln('Su producto es ',mi_producto.nombre,'.');
  65. writeln('Tienes una cantidad de ',mi_producto.num_unidades,' del producto.');
  66. writeln('El precio de cada unidad es de ',mi_producto.precio_unidad:0:2,'.');
  67.  
  68. if (mi_producto.en_cesta=true) then
  69. writeln('El producto esta en la cesta.');
  70. end;
  71.  
  72. procedure mostrar_cesta(var mi_cesta: cesta);
  73. var
  74. i: integer;
  75.  
  76. begin
  77. for i:=1 to tamxcesta do
  78. begin
  79. if (mi_cesta[i].en_cesta=true) then
  80. begin
  81. writeln('Su producto es ',mi_cesta[i].nombre,'.');
  82. writeln('Tienes una cantidad de ',mi_cesta[i].num_unidades,' del producto.');
  83. writeln('El precio de cada unidad es de ',mi_cesta[i].precio_unidad:0:2,'.');
  84. end;
  85.  
  86. writeln;
  87.  
  88. end;
  89. end;
  90.  
  91. procedure cuenta_producto(var mi_cesta: cesta);
  92. var
  93. i: integer;
  94. cantidad: integer;
  95.  
  96. begin
  97. cantidad:=0;
  98. for i:=1 to tamxcesta do
  99. if (mi_cesta[i].en_cesta=true) then
  100. cantidad:=cantidad+1;
  101.  
  102. if (mi_cesta[i].en_cesta=true) then
  103. write('En la cesta hay ',cantidad,' procutos.')
  104. else
  105. write('En la cesta nao hay ningun producto.');
  106. end;
  107.  
  108. procedure busca_libre(var mi_cesta: cesta; var exito: boolean);
  109. var
  110. i: integer;
  111.  
  112. begin
  113. i:=0;
  114. repeat
  115. i:=i+1;
  116. exito:= mi_cesta[i].en_cesta=false;
  117. until (exito) or (i=tamxcesta);
  118.  
  119. if exito then
  120. begin
  121. writeln('Su producto es ',mi_cesta[i].nombre,'.');
  122. writeln('Tienes una cantidad de ',mi_cesta[i].num_unidades,' del producto.');
  123. writeln('El precio de cada unidad es de ',mi_cesta[i].precio_unidad:0:2,'.');
  124. writeln('El producto no esta en la cesta.');
  125. end
  126. else
  127. write('0');
  128. end;
  129.  
  130. procedure incluir_producto_en_cesta(var mi_cesta: cesta; var mi_producto: producto; exito: boolean);
  131. var
  132. i: integer;
  133.  
  134. begin
  135. if exito then
  136. begin
  137. read(mi_producto.nombre);
  138. read(mi_producto.num_unidades);
  139. read(mi_producto.precio_unidad);
  140.  
  141. if exito then
  142. for i:=1 to tamxcesta do
  143. begin
  144. writeln('Su producto es ',mi_cesta[i].nombre,'.');
  145. writeln('Tienes una cantidad de ',mi_cesta[i].num_unidades,' del producto.');
  146. writeln('El precio de cada unidad es de ',mi_cesta[i].precio_unidad:0:2,'.');
  147. end
  148. else
  149. write('Cesta llena');
  150. end;
  151. end;
  152.  
  153. begin
  154. lee_producto(mi_producto);
  155.  
  156. writeln;
  157.  
  158. escribe_producto(mi_producto);
  159. readln;
  160. clrscr;
  161.  
  162. inicializa_cesta(mi_cesta);
  163.  
  164. mostrar_producto(mi_producto);
  165. readln;
  166. clrscr;
  167.  
  168. for i:=1 to tamxcesta do
  169. begin
  170. write('Introduzca el nombre de su producto: ');
  171. readln(mi_cesta[i].nombre);
  172. write('Introduzca la cantidad del producto: ');
  173. readln(mi_cesta[i].num_unidades);
  174. write('Introduzca el precio de cada unidad: ');
  175. readln(mi_cesta[i].precio_unidad);
  176. write('El producto esta en la cesta? (responda con "si" o "no"): ');
  177. readln(producto_en_cesta);
  178.  
  179. if (producto_en_cesta='si') then
  180. mi_cesta[i].en_cesta:=true
  181. else
  182. mi_cesta[i].en_cesta:=false;
  183.  
  184. writeln;
  185.  
  186. end;
  187. clrscr;
  188.  
  189. mostrar_cesta(mi_cesta);
  190.  
  191. cuenta_producto(mi_cesta);
  192.  
  193. writeln;
  194. writeln;
  195.  
  196. busca_libre(mi_cesta, exito);
  197.  
  198. incluir_producto_en_cesta(mi_cesta, mi_producto, exito);
  199.  
  200. readln;
  201. end.


Este es mi ejercicio:

Código:
  1. Añada un procedimiento (incluir_producto_en_cesta) que introduzca un nuevo producto en la cesta de la compra, si hay alguna posición libre, o presente el mensaje de “Cesta llena” si no hay posición libre.
  2.  
  3. Este procedimiento debe hacer uso de los procedimientos busca_libre y lee_producto, que ya ha definido en cuestiones y actividades anteriores.


Yo se como hacer el ejercicio, el problema es que dice que utilice el procedimiento lee_producto. Al decir esto, supongo que se refiere a que el producto que el usuario introduce en lee_producto, lo ponga como el nuevo producto en la tabla. El problema es que yo no se como poner el producto de lee_producto en la tabla para que se quede como el nuevo producto sustituyendo al producto que no esta en la cesta.

No hace falta que resuelvas el ejercicio por mi, solo necesito que me expliques como hacer eso.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1015

Mensaje Publicado: Jueves 06 Dic 2012 14:40

Título del mensaje: Re: Programando desde 0: 19- Más tipos a definir: Registros.

Responder citando

El procedimiento LEE_PRODUCTO recibe un producto como parámetro por referencia, entonces, teniendo una variable global de ese tipo, por ejemplo

Código:
  1. VAR miProducto: Producto;


tú se la pasas a dicho procedimiento, quién obtiene los datos de entrada y los introduce en la variable a través del parámetro. Por tanto, luego de que el procedimiento termina sus tareas, la variable miProducto contendrá los datos.

Con eso se lo pasas a tu procedimiento INCLUIR_PRODUCTO_EN_CESTA quién además debe recibir una variable del tipo Cesta.

Este procedimiento, primero verifica que la cesta tenga lugar a través de la operación BUSCA_LIBRE. Si esta indica que no hay espacio muestras el mensaje correspondiente y en caso contrario te lanzas a la tarea de insertar el producto en la primera posición libre que encuentres.

Podrías hacerlo de varias maneras. Por ejemplo leer el producto, luego verificar la cesta y en caso afirmativo invocas a INCLUIR_PRODUCTO_EN_CESTA y en caso contrario publicas el mensaje.

Espero haberte ayudado.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
tugatime
Usuario Inquieto


Registrado: 09 Oct 2012
Mensajes: 117

Mensaje Publicado: Jueves 06 Dic 2012 15:48

Título del mensaje: Re: Programando desde 0: 19- Más tipos a definir: Registros.

Responder citando

Mira, estoy complicando mi vida y la tuya y eso no pude ser. Voy a poner aqui el codigo que tengo y mi problema, pero de una forma mas simples.

Mi codigo:

Código:
  1. program Productos_en_la_cesta;
  2.  
  3. uses crt;
  4.  
  5. const
  6. tamxcesta=3;
  7.  
  8. type
  9. producto = record
  10. nombre: string;
  11. num_unidades: integer;
  12. precio_unidad: real;
  13. en_cesta: boolean;
  14. end;
  15.  
  16. cesta=array[1..tamxcesta] of producto;
  17.  
  18. var
  19. mi_producto: producto;
  20. mi_cesta: cesta;
  21. i, posicion: integer;
  22. producto_en_cesta: string;
  23. exito: boolean;
  24.  
  25. procedure lee_producto(var mi_producto: producto);
  26. begin
  27. write('Introduzca su producto: ');
  28. readln(mi_producto.nombre);
  29. write('Introduzca la cantidad de su producto: ');
  30. readln(mi_producto.num_unidades);
  31. write('Introduzca el precio de cada unidad de su producto: ');
  32. readln(mi_producto.precio_unidad);
  33. mi_producto.en_cesta:=true;
  34. end;
  35.  
  36. procedure escribe_producto(var mi_producto: producto);
  37. begin
  38. writeln('Su producto es ',mi_producto.nombre,'.');
  39. writeln('Tienes una cantidad de ',mi_producto.num_unidades,' del producto.');
  40. writeln('El precio de cada unidad es de ',mi_producto.precio_unidad:0:2,'.');
  41. end;
  42.  
  43. procedure inicializa_cesta(var mi_cesta: cesta);
  44. var
  45. i: integer;
  46.  
  47. begin
  48. for i:=1 to tamxcesta do
  49. begin
  50. mi_cesta[i].nombre:= 'Nombre del producto';
  51. mi_cesta[i].num_unidades:= 0;
  52. mi_cesta[i].precio_unidad:= 0.00;
  53. mi_cesta[i].en_cesta:= false;
  54. end;
  55. end;
  56.  
  57. procedure mostrar_producto(mi_producto: producto);
  58. begin
  59. mi_producto.nombre:= 'Nombre del producto';
  60. mi_producto.num_unidades:= 0;
  61. mi_producto.precio_unidad:= 0.00;
  62. mi_producto.en_cesta:= true;
  63.  
  64. writeln('Su producto es ',mi_producto.nombre,'.');
  65. writeln('Tienes una cantidad de ',mi_producto.num_unidades,' del producto.');
  66. writeln('El precio de cada unidad es de ',mi_producto.precio_unidad:0:2,'.');
  67.  
  68. if (mi_producto.en_cesta=true) then
  69. writeln('El producto esta en la cesta.');
  70. end;
  71.  
  72. procedure mostrar_cesta(var mi_cesta: cesta);
  73. var
  74. i: integer;
  75.  
  76. begin
  77. for i:=1 to tamxcesta do
  78. begin
  79. if (mi_cesta[i].en_cesta=true) then
  80. begin
  81. writeln('Su producto es ',mi_cesta[i].nombre,'.');
  82. writeln('Tienes una cantidad de ',mi_cesta[i].num_unidades,' del producto.');
  83. writeln('El precio de cada unidad es de ',mi_cesta[i].precio_unidad:0:2,'.');
  84. end;
  85.  
  86. writeln;
  87.  
  88. end;
  89. end;
  90.  
  91. procedure cuenta_producto(var mi_cesta: cesta);
  92. var
  93. i: integer;
  94. cantidad: integer;
  95.  
  96. begin
  97. cantidad:=0;
  98. for i:=1 to tamxcesta do
  99. if (mi_cesta[i].en_cesta=true) then
  100. cantidad:=cantidad+1;
  101.  
  102. if (mi_cesta[i].en_cesta=true) then
  103. write('En la cesta hay ',cantidad,' procutos.')
  104. else
  105. write('En la cesta nao hay ningun producto.');
  106. end;
  107.  
  108. procedure busca_libre(var mi_cesta: cesta; var exito: boolean; var posicion: integer);
  109. var
  110. i: integer;
  111.  
  112. begin
  113. i:=0;
  114. repeat
  115. i:=i+1;
  116. exito:= mi_cesta[i].en_cesta=false;
  117. posicion:=i;
  118. until (exito) or (i=tamxcesta);
  119.  
  120. if exito then
  121. begin
  122. writeln('Su producto es ',mi_cesta[i].nombre,'.');
  123. writeln('Tienes una cantidad de ',mi_cesta[i].num_unidades,' del producto.');
  124. writeln('El precio de cada unidad es de ',mi_cesta[i].precio_unidad:0:2,'.');
  125. writeln('El producto no esta en la cesta.');
  126. end
  127. else
  128. write('0');
  129. end;
  130.  
  131. procedure incluir_producto_en_cesta(var mi_cesta: cesta; var mi_producto: producto; exito: boolean; posicion: integer);
  132. var
  133. i: integer;
  134.  
  135. begin
  136. if exito then
  137. begin
  138. i:=posicion;
  139.  
  140. with mi_cesta[i] do
  141. begin
  142. writeln(mi_producto.nombre);
  143. writeln(mi_producto.num_unidades);
  144. writeln(mi_producto.precio_unidad:0:2);
  145. end;
  146. end
  147. else
  148. write('Cesta llena');
  149. end;
  150.  
  151. begin
  152. lee_producto(mi_producto);
  153.  
  154. writeln;
  155.  
  156. escribe_producto(mi_producto);
  157. readln;
  158. clrscr;
  159.  
  160. inicializa_cesta(mi_cesta);
  161.  
  162. mostrar_producto(mi_producto);
  163. readln;
  164. clrscr;
  165.  
  166. for i:=1 to tamxcesta do
  167. begin
  168. write('Introduzca el nombre de su producto: ');
  169. readln(mi_cesta[i].nombre);
  170. write('Introduzca la cantidad del producto: ');
  171. readln(mi_cesta[i].num_unidades);
  172. write('Introduzca el precio de cada unidad: ');
  173. readln(mi_cesta[i].precio_unidad);
  174. write('El producto esta en la cesta? (responda con "si" o "no"): ');
  175. readln(producto_en_cesta);
  176.  
  177. if (producto_en_cesta='si') then
  178. mi_cesta[i].en_cesta:=true
  179. else
  180. mi_cesta[i].en_cesta:=false;
  181.  
  182. writeln;
  183.  
  184. end;
  185. clrscr;
  186.  
  187. mostrar_cesta(mi_cesta);
  188.  
  189. cuenta_producto(mi_cesta);
  190.  
  191. writeln;
  192. writeln;
  193.  
  194. busca_libre(mi_cesta, exito, posicion);
  195.  
  196. writeln;
  197.  
  198. incluir_producto_en_cesta(mi_cesta, mi_producto, exito, posicion);
  199.  
  200. readln;
  201. end.


Mira, lo que pasa es lo siguiente. Mi problema esta en el procedimiento
Código:
  1. incluir_producto_en_cesta


Se supone que en el procedimiento "busca_libre" busco si hay algun hueco libre en la cesta.
Luego en el procedimiento "incluir_producto_en_cesta" si no hay ningun hueco libre me dice que la cesta esta llena, pero si hay algun hueco libre, lo que tengo que hacer es volver a escribir toda la cesta (o sea, volver a escribir los productos que estan en la cesta) añadiendo un nuevo producto al hueco que esta libre. (Ese producto que se añade es el producto que el usuario introduce en el procedimiento "lee_producto").

Mi problema es que por mucho que lo intente, no encuentro una forma de escribir toda la cesta añadiendo el nuevo producto.

Me puede alguien dar una ayuda con eso ??

Volver arriba
Ver perfil del usuario Enviar mensaje privado
matias.SANZ
Usuario Iniciado


Registrado: 05 Jun 2013
Mensajes: 35

Mensaje Publicado: Viernes 05 Jul 2013 16:19

Título del mensaje: Re: Programando desde 0: 19- Más tipos a definir: Registros.

Responder citando

Una lección muy interesante y muy bien explicada Ok Los registros sin duda una herramienta muy completa.

Os dejo los ejercicios propuestos.

Ejercicio 1:

Definiciones válidas de registro:b, d

Ejercicio 2:

Código:
Program ejercico2;

Uses crt;

TYPE
     Grados= (primero, segundo, tercero, cuarto, quinto, sexto);

     Estudiante= RECORD
        Nombre: String;
        Edad, Documento: Integer;
        Grado: Grados;
    END;

    BasesEstudiantes= Array[1..10] Of Estudiante;

Var
    Est: BasesEstudiantes;
    aux: char;
    i, doc:integer;

Begin
        writeln('Presione ENTER para ingresar los datos del estudiante');
        readln;
        For i:=1 to 10 do
        begin
        clrscr;
        write('Nombre: ');
        read(Est[i].Nombre);
        write('Edad: ');
        read(Est[i].Edad);
        write('Documento: ');
        read(Est[i].Documento);
        readln;
        write('Por favor indique el grado (1-6): ');
        readln(aux);
        case aux of
        '1': Est[i].Grado:=primero;

        '2': Est[i].Grado:=segundo;

        '3': Est[i].Grado:=tercero;

        '4': Est[i].Grado:=cuarto;

        '5': Est[i].Grado:=quinto;

        '6': Est[i].Grado:=sexto;

        end;
        end;
       //BUSQUEDA DE DATOS DE ESTUDIANTES.

       write('Ingrese el número de documento del estudiante: ');
       readln(doc);

       clrscr;

       i:=0;

       Repeat

       i:=i+1;

       if Est[i].Documento=doc then
       Begin
       writeln('Datos del estudiante.');
       writeln;
       writeln('Nombre: ',Est[i].Nombre);
       writeln('Edad: ',Est[i].Edad);
       writeln('Documento: ',Est[i].Documento);
       case Est[i].Grado of
       primero:writeln('Grado: primero');
       segundo:writeln('Grado: segundo');
       tercero:writeln('Grado: tercero');
       cuarto:writeln('Grado: cuarto');
       quinto:writeln('Grado: quinto');
       sexto:writeln('Grado: sexto');
       end;
       end;

       until Est[i].Documento=doc;



end.



Me ha gustado mucho la parte del código de Sebastián Marcos

Código:
write('Grado (1 ... 6): ');
      readln(aux);
      est[i].grado:=grados(aux-1);
      writeln;


Mucho más elegante y ahorra espacio escribirla Ok .Creo haberla visto en la lección anterior en el programa de ejemplo, aunque no se me ocurrió mientras escribía este. De todas formas, es lo bueno que tiene que más gente postee sus códigos, uno siempre aprende de otras perspectivas.

Saludos

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Responder al Tema Ir a página 12Siguiente
Mostrar mensajes anteriores:   
Ir a:  
Todas las horas están en GMT + 1 Hora

Temas relacionados

Tema Autor Foros Respuestas Publicado
El foro no contiene ningún mensaje nuevo

Nuevo desde México!

MarioC Preséntate a la comunidad 1 Viernes 30 Dic 2016 18:39 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Control HTML (o Jquery) desde VBA

morfeoct Visual Basic y VBA 3 Jueves 24 Nov 2016 17:34 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Control HTML (o script) desde VBA

morfeoct Programación en general 0 Martes 22 Nov 2016 23:15 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Hola a todos, desde Venezuela!

silvialp Preséntate a la comunidad 2 Sábado 24 Sep 2016 13:51 Ver último mensaje
El foro no contiene ningún mensaje nuevo

como instalar entity framework desde el HDD local

Leonardo A. Nieblas Palau ASP, ASP.NET 0 Miércoles 07 Sep 2016 22:11 Ver último mensaje
Panel de Control
No puede crear mensajes, No puede responder temas, No puede editar sus mensajes, No puede borrar sus mensajes, No puede votar en encuestas,