Menú

Mostrar Mensajes

Esta sección te permite ver todos los mensajes escritos por este usuario. Ten en cuenta que sólo puedes ver los mensajes escritos en zonas a las que tienes acceso en este momento.

Mostrar Mensajes Menú

Temas - Omar_2013

#1
Java / Arreglo de inmuebles
18 Febrero 2015, 21:30 PM
Hola, estoy haciendo un programa pero tengo un error en la implementación de mi código y no se cual es, lo que pasa es que escogiendo la opción 2(Mostrar Inmuebles), sale para cada inmueble el mismo propietario.

Estas son las Clases

Código (java) [Seleccionar]

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class TestPropietario {

private static Inmueble ArregloI[]=new Inmueble[5];

public static void Imprimir(int Pos) throws IOException{
System.out.println("\nPropietario " + ArregloI[Pos].getMiPropietario().getNombreCompleto() + ":\n");
System.out.println("Estado " + ArregloI[Pos].getEstado() + "\n");
}

public static int MenuPrincipal() throws IOException{
int Opcion=0;
BufferedReader Lector = new BufferedReader(new InputStreamReader(System.in));
String Capturar;

System.out.println("\n1. Ingresar un inmueble\n");
System.out.println("2. Mostrar Inmuebles\n");
System.out.println("3. Salir\n");

Capturar= Lector.readLine();
Opcion=Integer.parseInt(Capturar);
return Opcion;
}


public static void main(String[] args) throws IOException{

int OpcionM=0, Cont=0;
Propietario AuxProp= new Propietario(null, null);
String Estado = null;

BufferedReader Lector = new BufferedReader(new InputStreamReader(System.in));
String Capturar;

for(int i=0; i<5; i++)
ArregloI[i]= new Inmueble();

while(OpcionM!=3){

OpcionM=MenuPrincipal();

switch(OpcionM){
case 1:
System.out.println("Ingrese el Estado del Inmueble (Libre - Ocupado)");
Capturar= Lector.readLine();
Estado=Capturar;

System.out.println("Ingrese el Nombre del Propietario");
Capturar= Lector.readLine();
AuxProp.setNombreCompleto(Capturar);

System.out.println("Ingrese el numero de telefono del propietario");
Capturar= Lector.readLine();
AuxProp.setTelContac(Capturar);

if(Cont<5){
ArregloI[Cont].Llenar(Estado, AuxProp);
Cont+=1;
}
else
System.out.println("Ha llegado al límite máximo de Inmuebles");
break;
case 2:
for(int i=0; i<5; i++)
Imprimir(i);
break;
case 3:
break;
}
}


}




Código (java) [Seleccionar]


public class Propietario {
private String NombreCompleto;
private String TelContac;


public Propietario(String nombreCompleto, String telContac) {
NombreCompleto = nombreCompleto;
TelContac = telContac;
}


public String getNombreCompleto() {
return NombreCompleto;
}


public void setNombreCompleto(String nombreCompleto) {
NombreCompleto = nombreCompleto;
}


public String getTelContac() {
return TelContac;
}


public void setTelContac(String telContac) {
TelContac = telContac;
}

}




Código (java) [Seleccionar]


public class Inmueble {
private String Estado;
private Propietario MiPropietario=new Propietario(null, null);


public void Llenar(String Estado, Propietario MiPropietario){
setEstado(Estado);
setMiPropietario(MiPropietario);
}

public Inmueble() {
}

public String getEstado() {
return Estado;
}
public void setEstado(String estado) {
Estado = estado;
}
public Propietario getMiPropietario() {
return MiPropietario;
}
public void setMiPropietario(Propietario miPropietario) {
MiPropietario = miPropietario;
}
}


Verán, al momento ingresar a la opción 2 después de haber llenado 2 inmueble sale algo así:

#2
Hola gente, gracias por leer mi post, primero que todo tengo un archivo desensamblado en codigo ensamblador y quisiera que me guiaran por donde empiezo para interpretar y lograr descifrar que es lo que hace el programa



08048424 <_init>:
8048424: 53                    push   %ebx
8048425: 83 ec 08              sub     $0x8,%esp
8048428: e8 13 01 00 00        call     8048540 <__x86.get_pc_thunk.bx>
804842d: 81 c3 d3 1b 00 00    add     $0x1bd3,%ebx
8048433: 8b 83 fc ff ff ff    mov    -0x4(%ebx),%eax
8048439: 85 c0                test     %eax,%eax
804843b: 74 05                je       8048442 <_init+0x1e>
804843d: e8 6e 00 00 00        call    80484b0 <__gmon_start__@plt>
8048442: 83 c4 08              add    $0x8,%esp
8048445: 5b                    pop    %ebx
8048446: c3                    ret   

Desensamblado de la sección .plt:

08048450 <read@plt-0x10>:
8048450: ff 35 04 a0 04 08    pushl  0x804a004
8048456: ff 25 08 a0 04 08    jmp    *0x804a008
804845c: 00 00                add    %al,(%eax)
...

08048460 <read@plt>:
8048460: ff 25 0c a0 04 08    jmp    *0x804a00c
8048466: 68 00 00 00 00        push   $0x0
804846b: e9 e0 ff ff ff        jmp    8048450 <_init+0x2c>

08048470 <printf@plt>:
8048470: ff 25 10 a0 04 08    jmp    *0x804a010
8048476: 68 08 00 00 00        push   $0x8
804847b: e9 d0 ff ff ff        jmp    8048450 <_init+0x2c>

08048480 <inet_pton@plt>:
8048480: ff 25 14 a0 04 08    jmp    *0x804a014
8048486: 68 10 00 00 00        push   $0x10
804848b: e9 c0 ff ff ff        jmp    8048450 <_init+0x2c>

08048490 <htons@plt>:
8048490: ff 25 18 a0 04 08    jmp    *0x804a018
8048496: 68 18 00 00 00        push   $0x18
804849b: e9 b0 ff ff ff        jmp    8048450 <_init+0x2c>

080484a0 <puts@plt>:
80484a0: ff 25 1c a0 04 08    jmp    *0x804a01c
80484a6: 68 20 00 00 00        push   $0x20
80484ab: e9 a0 ff ff ff        jmp    8048450 <_init+0x2c>

080484b0 <__gmon_start__@plt>:
80484b0: ff 25 20 a0 04 08    jmp    *0x804a020
80484b6: 68 28 00 00 00        push   $0x28
80484bb: e9 90 ff ff ff        jmp    8048450 <_init+0x2c>

080484c0 <__libc_start_main@plt>:
80484c0: ff 25 24 a0 04 08    jmp    *0x804a024
80484c6: 68 30 00 00 00        push   $0x30
80484cb: e9 80 ff ff ff        jmp    8048450 <_init+0x2c>

080484d0 <memset@plt>:
80484d0: ff 25 28 a0 04 08    jmp    *0x804a028
80484d6: 68 38 00 00 00        push   $0x38
80484db: e9 70 ff ff ff        jmp    8048450 <_init+0x2c>

080484e0 <socket@plt>:
80484e0: ff 25 2c a0 04 08    jmp    *0x804a02c
80484e6: 68 40 00 00 00        push   $0x40
80484eb: e9 60 ff ff ff        jmp    8048450 <_init+0x2c>

080484f0 <fputs@plt>:
80484f0: ff 25 30 a0 04 08    jmp    *0x804a030
80484f6: 68 48 00 00 00        push   $0x48
80484fb: e9 50 ff ff ff        jmp    8048450 <_init+0x2c>

08048500 <connect@plt>:
8048500: ff 25 34 a0 04 08    jmp    *0x804a034
8048506: 68 50 00 00 00        push   $0x50
804850b: e9 40 ff ff ff        jmp    8048450 <_init+0x2c>

Desensamblado de la sección .text:

08048510 <_start>:
8048510: 31 ed                xor    %ebp,%ebp
8048512: 5e                    pop    %esi
8048513: 89 e1                mov    %esp,%ecx
8048515: 83 e4 f0              and    $0xfffffff0,%esp
8048518: 50                    push   %eax
8048519: 54                    push   %esp
804851a: 52                    push   %edx
804851b: 68 60 88 04 08        push   $0x8048860
8048520: 68 f0 87 04 08        push   $0x80487f0
8048525: 51                    push   %ecx
8048526: 56                    push   %esi
8048527: 68 10 86 04 08        push   $0x8048610
804852c: e8 8f ff ff ff        call   80484c0 <__libc_start_main@plt>
8048531: f4                    hlt   
8048532: 66 90                xchg   %ax,%ax
8048534: 66 90                xchg   %ax,%ax
8048536: 66 90                xchg   %ax,%ax
8048538: 66 90                xchg   %ax,%ax
804853a: 66 90                xchg   %ax,%ax
804853c: 66 90                xchg   %ax,%ax
804853e: 66 90                xchg   %ax,%ax

08048540 <__x86.get_pc_thunk.bx>:
8048540: 8b 1c 24              mov    (%esp),%ebx
8048543: c3                    ret   
8048544: 66 90                xchg   %ax,%ax
8048546: 66 90                xchg   %ax,%ax
8048548: 66 90                xchg   %ax,%ax
804854a: 66 90                xchg   %ax,%ax
804854c: 66 90                xchg   %ax,%ax
804854e: 66 90                xchg   %ax,%ax

08048550 <deregister_tm_clones>:
8048550: b8 43 a0 04 08        mov    $0x804a043,%eax
8048555: 2d 40 a0 04 08        sub    $0x804a040,%eax
804855a: 83 f8 06              cmp    $0x6,%eax
804855d: 77 01                ja     8048560 <deregister_tm_clones+0x10>
804855f: c3                    ret   
8048560: b8 00 00 00 00        mov    $0x0,%eax
8048565: 85 c0                test   %eax,%eax
8048567: 74 f6                je     804855f <deregister_tm_clones+0xf>
8048569: 55                    push   %ebp
804856a: 89 e5                mov    %esp,%ebp
804856c: 83 ec 18              sub    $0x18,%esp
804856f: c7 04 24 40 a0 04 08 movl   $0x804a040,(%esp)
8048576: ff d0                call   *%eax
8048578: c9                    leave 
8048579: c3                    ret   
804857a: 8d b6 00 00 00 00    lea    0x0(%esi),%esi

08048580 <register_tm_clones>:
8048580: b8 40 a0 04 08        mov    $0x804a040,%eax
8048585: 2d 40 a0 04 08        sub    $0x804a040,%eax
804858a: c1 f8 02              sar    $0x2,%eax
804858d: 89 c2                mov    %eax,%edx
804858f: c1 ea 1f              shr    $0x1f,%edx
8048592: 01 d0                add    %edx,%eax
8048594: d1 f8                sar    %eax
8048596: 75 01                jne    8048599 <register_tm_clones+0x19>
8048598: c3                    ret   
8048599: ba 00 00 00 00        mov    $0x0,%edx
804859e: 85 d2                test   %edx,%edx
80485a0: 74 f6                je     8048598 <register_tm_clones+0x18>
80485a2: 55                    push   %ebp
80485a3: 89 e5                mov    %esp,%ebp
80485a5: 83 ec 18              sub    $0x18,%esp
80485a8: 89 44 24 04          mov    %eax,0x4(%esp)
80485ac: c7 04 24 40 a0 04 08 movl   $0x804a040,(%esp)
80485b3: ff d2                call   *%edx
80485b5: c9                    leave 
80485b6: c3                    ret   
80485b7: 89 f6                mov    %esi,%esi
80485b9: 8d bc 27 00 00 00 00 lea    0x0(%edi,%eiz,1),%edi

080485c0 <__do_global_dtors_aux>:
80485c0: 80 3d 44 a0 04 08 00 cmpb   $0x0,0x804a044
80485c7: 75 13                jne    80485dc <__do_global_dtors_aux+0x1c>
80485c9: 55                    push   %ebp
80485ca: 89 e5                mov    %esp,%ebp
80485cc: 83 ec 08              sub    $0x8,%esp
80485cf: e8 7c ff ff ff        call   8048550 <deregister_tm_clones>
80485d4: c6 05 44 a0 04 08 01 movb   $0x1,0x804a044
80485db: c9                    leave 
80485dc: f3 c3                repz ret
80485de: 66 90                xchg   %ax,%ax

080485e0 <frame_dummy>:
80485e0: a1 08 9f 04 08        mov    0x8049f08,%eax
80485e5: 85 c0                test   %eax,%eax
80485e7: 74 1f                je     8048608 <frame_dummy+0x28>
80485e9: b8 00 00 00 00        mov    $0x0,%eax
80485ee: 85 c0                test   %eax,%eax
80485f0: 74 16                je     8048608 <frame_dummy+0x28>
80485f2: 55                    push   %ebp
80485f3: 89 e5                mov    %esp,%ebp
80485f5: 83 ec 18              sub    $0x18,%esp
80485f8: c7 04 24 08 9f 04 08 movl   $0x8049f08,(%esp)
80485ff: ff d0                call   *%eax
8048601: c9                    leave 
8048602: e9 79 ff ff ff        jmp    8048580 <register_tm_clones>
8048607: 90                    nop
8048608: e9 73 ff ff ff        jmp    8048580 <register_tm_clones>
804860d: 66 90                xchg   %ax,%ax
804860f: 90                    nop

08048610 <main>:
8048610: 55                    push   %ebp
8048611: 89 e5                mov    %esp,%ebp
8048613: 83 e4 f0              and    $0xfffffff0,%esp
8048616: 81 ec 30 04 00 00    sub    $0x430,%esp
804861c: c7 84 24 2c 04 00 00 movl   $0x0,0x42c(%esp)
8048623: 00 00 00 00
8048627: c7 84 24 28 04 00 00 movl   $0x0,0x428(%esp)
804862e: 00 00 00 00
8048632: 83 7d 08 02          cmpl   $0x2,0x8(%ebp)
8048636: 74 1f                je     8048657 <main+0x47>
8048638: 8b 45 0c              mov    0xc(%ebp),%eax
804863b: 8b 00                mov    (%eax),%eax
804863d: 89 44 24 04          mov    %eax,0x4(%esp)
8048641: c7 04 24 80 88 04 08 movl   $0x8048880,(%esp)
8048648: e8 23 fe ff ff        call   8048470 <printf@plt>
804864d: b8 01 00 00 00        mov    $0x1,%eax
8048652: e9 8c 01 00 00        jmp    80487e3 <main+0x1d3>
8048657: c7 44 24 08 00 04 00 movl   $0x400,0x8(%esp)
804865e: 00
804865f: c7 44 24 04 30 00 00 movl   $0x30,0x4(%esp)
8048666: 00
8048667: 8d 44 24 28          lea    0x28(%esp),%eax
804866b: 89 04 24              mov    %eax,(%esp)
804866e: e8 5d fe ff ff        call   80484d0 <memset@plt>
8048673: c7 44 24 08 00 00 00 movl   $0x0,0x8(%esp)
804867a: 00
804867b: c7 44 24 04 01 00 00 movl   $0x1,0x4(%esp)
8048682: 00
8048683: c7 04 24 02 00 00 00 movl   $0x2,(%esp)
804868a: e8 51 fe ff ff        call   80484e0 <socket@plt>
804868f: 89 84 24 2c 04 00 00 mov    %eax,0x42c(%esp)
8048696: 83 bc 24 2c 04 00 00 cmpl   $0x0,0x42c(%esp)
804869d: 00
804869e: 79 16                jns    80486b6 <main+0xa6>
80486a0: c7 04 24 a0 88 04 08 movl   $0x80488a0,(%esp)
80486a7: e8 f4 fd ff ff        call   80484a0 <puts@plt>
80486ac: b8 01 00 00 00        mov    $0x1,%eax
80486b1: e9 2d 01 00 00        jmp    80487e3 <main+0x1d3>
80486b6: c7 44 24 08 10 00 00 movl   $0x10,0x8(%esp)
80486bd: 00
80486be: c7 44 24 04 30 00 00 movl   $0x30,0x4(%esp)
80486c5: 00
80486c6: 8d 44 24 18          lea    0x18(%esp),%eax
80486ca: 89 04 24              mov    %eax,(%esp)
80486cd: e8 fe fd ff ff        call   80484d0 <memset@plt>
80486d2: 66 c7 44 24 18 02 00 movw   $0x2,0x18(%esp)
80486d9: c7 04 24 88 13 00 00 movl   $0x1388,(%esp)
80486e0: e8 ab fd ff ff        call   8048490 <htons@plt>
80486e5: 66 89 44 24 1a        mov    %ax,0x1a(%esp)
80486ea: 8b 45 0c              mov    0xc(%ebp),%eax
80486ed: 83 c0 04              add    $0x4,%eax
80486f0: 8b 00                mov    (%eax),%eax
80486f2: 8d 54 24 18          lea    0x18(%esp),%edx
80486f6: 83 c2 04              add    $0x4,%edx
80486f9: 89 54 24 08          mov    %edx,0x8(%esp)
80486fd: 89 44 24 04          mov    %eax,0x4(%esp)
8048701: c7 04 24 02 00 00 00 movl   $0x2,(%esp)
8048708: e8 73 fd ff ff        call   8048480 <inet_pton@plt>
804870d: 85 c0                test   %eax,%eax
804870f: 7f 16                jg     8048727 <main+0x117>
8048711: c7 04 24 c3 88 04 08 movl   $0x80488c3,(%esp)
8048718: e8 83 fd ff ff        call   80484a0 <puts@plt>
804871d: b8 01 00 00 00        mov    $0x1,%eax
8048722: e9 bc 00 00 00        jmp    80487e3 <main+0x1d3>
8048727: c7 44 24 08 10 00 00 movl   $0x10,0x8(%esp)
804872e: 00
804872f: 8d 44 24 18          lea    0x18(%esp),%eax
8048733: 89 44 24 04          mov    %eax,0x4(%esp)
8048737: 8b 84 24 2c 04 00 00 mov    0x42c(%esp),%eax
804873e: 89 04 24              mov    %eax,(%esp)
8048741: e8 ba fd ff ff        call   8048500 <connect@plt>
8048746: 85 c0                test   %eax,%eax
8048748: 79 16                jns    8048760 <main+0x150>
804874a: c7 04 24 dd 88 04 08 movl   $0x80488dd,(%esp)
8048751: e8 4a fd ff ff        call   80484a0 <puts@plt>
8048756: b8 01 00 00 00        mov    $0x1,%eax
804875b: e9 83 00 00 00        jmp    80487e3 <main+0x1d3>
8048760: eb 36                jmp    8048798 <main+0x188>
8048762: 8d 54 24 28          lea    0x28(%esp),%edx
8048766: 8b 84 24 28 04 00 00 mov    0x428(%esp),%eax
804876d: 01 d0                add    %edx,%eax
804876f: c6 00 00              movb   $0x0,(%eax)
8048772: a1 40 a0 04 08        mov    0x804a040,%eax
8048777: 89 44 24 04          mov    %eax,0x4(%esp)
804877b: 8d 44 24 28          lea    0x28(%esp),%eax
804877f: 89 04 24              mov    %eax,(%esp)
8048782: e8 69 fd ff ff        call   80484f0 <fputs@plt>
8048787: 83 f8 ff              cmp    $0xffffffff,%eax
804878a: 75 0c                jne    8048798 <main+0x188>
804878c: c7 04 24 f7 88 04 08 movl   $0x80488f7,(%esp)
8048793: e8 08 fd ff ff        call   80484a0 <puts@plt>
8048798: c7 44 24 08 ff 03 00 movl   $0x3ff,0x8(%esp)
804879f: 00
80487a0: 8d 44 24 28          lea    0x28(%esp),%eax
80487a4: 89 44 24 04          mov    %eax,0x4(%esp)
80487a8: 8b 84 24 2c 04 00 00 mov    0x42c(%esp),%eax
80487af: 89 04 24              mov    %eax,(%esp)
80487b2: e8 a9 fc ff ff        call   8048460 <read@plt>
80487b7: 89 84 24 28 04 00 00 mov    %eax,0x428(%esp)
80487be: 83 bc 24 28 04 00 00 cmpl   $0x0,0x428(%esp)
80487c5: 00
80487c6: 7f 9a                jg     8048762 <main+0x152>
80487c8: 83 bc 24 28 04 00 00 cmpl   $0x0,0x428(%esp)
80487cf: 00
80487d0: 79 0c                jns    80487de <main+0x1ce>
80487d2: c7 04 24 0d 89 04 08 movl   $0x804890d,(%esp)
80487d9: e8 c2 fc ff ff        call   80484a0 <puts@plt>
80487de: b8 00 00 00 00        mov    $0x0,%eax
80487e3: c9                    leave 
80487e4: c3                    ret   
80487e5: 66 90                xchg   %ax,%ax
80487e7: 66 90                xchg   %ax,%ax
80487e9: 66 90                xchg   %ax,%ax
80487eb: 66 90                xchg   %ax,%ax
80487ed: 66 90                xchg   %ax,%ax
80487ef: 90                    nop

080487f0 <__libc_csu_init>:
80487f0: 55                    push   %ebp
80487f1: 57                    push   %edi
80487f2: 31 ff                xor    %edi,%edi
80487f4: 56                    push   %esi
80487f5: 53                    push   %ebx
80487f6: e8 45 fd ff ff        call   8048540 <__x86.get_pc_thunk.bx>
80487fb: 81 c3 05 18 00 00    add    $0x1805,%ebx
8048801: 83 ec 1c              sub    $0x1c,%esp
8048804: 8b 6c 24 30          mov    0x30(%esp),%ebp
8048808: 8d b3 04 ff ff ff    lea    -0xfc(%ebx),%esi
804880e: e8 11 fc ff ff        call   8048424 <_init>
8048813: 8d 83 00 ff ff ff    lea    -0x100(%ebx),%eax
8048819: 29 c6                sub    %eax,%esi
804881b: c1 fe 02              sar    $0x2,%esi
804881e: 85 f6                test   %esi,%esi
8048820: 74 27                je     8048849 <__libc_csu_init+0x59>
8048822: 8d b6 00 00 00 00    lea    0x0(%esi),%esi
8048828: 8b 44 24 38          mov    0x38(%esp),%eax
804882c: 89 2c 24              mov    %ebp,(%esp)
804882f: 89 44 24 08          mov    %eax,0x8(%esp)
8048833: 8b 44 24 34          mov    0x34(%esp),%eax
8048837: 89 44 24 04          mov    %eax,0x4(%esp)
804883b: ff 94 bb 00 ff ff ff call   *-0x100(%ebx,%edi,4)
8048842: 83 c7 01              add    $0x1,%edi
8048845: 39 f7                cmp    %esi,%edi
8048847: 75 df                jne    8048828 <__libc_csu_init+0x38>
8048849: 83 c4 1c              add    $0x1c,%esp
804884c: 5b                    pop    %ebx
804884d: 5e                    pop    %esi
804884e: 5f                    pop    %edi
804884f: 5d                    pop    %ebp
8048850: c3                    ret   
8048851: eb 0d                jmp    8048860 <__libc_csu_fini>
8048853: 90                    nop
8048854: 90                    nop
8048855: 90                    nop
8048856: 90                    nop
8048857: 90                    nop
8048858: 90                  nop
8048859: 90                    nop
804885a: 90                    nop
804885b: 90                    nop
804885c: 90                    nop
804885d: 90                  nop
804885e: 90                    nop
804885f: 90                  nop

08048860 <__libc_csu_fini>:
8048860: f3 c3                repz ret
8048862: 66 90                xchg   %ax,%ax

Desensamblado de la sección .fini:

08048864 <_fini>:
8048864: 53                    push   %ebx
8048865: 83 ec 08              sub    $0x8,%esp
8048868: e8 d3 fc ff ff        call   8048540 <__x86.get_pc_thunk.bx>
804886d: 81 c3 93 17 00 00    add    $0x1793,%ebx
8048873: 83 c4 08              add    $0x8,%esp
8048876: 5b                    pop    %ebx
8048877: c3                    ret


Como pueden ver el codigo es algo extenso pero esta como que dividido en partes y además contiene estos subtítulos

Desensamblado de la sección .plt
Desensamblado de la sección .text
Desensamblado de la sección .fini

Tambien hay que analizar estos para entender el programa??
#3
Hola, ya estoy en la parte de \Run podria alguien explicarme que tengo que hacer en la parte de /vsyst32/tReg_SZ/d



http://www.subirimagenes.com/imagen-faltanunospasos-8917611.html


Gracias por leer, se que no es muy claro, pero no se como mas escribirlo...
#4
Buen Día, mi duda es acerca de la lectura de archivos Binarios, este es el código:

Código (cpp) [Seleccionar]

void CargarInformacion(struct TNodo<Usuarios> **Lista)
{
     struct Usuarios Load;
     
     ifstream Datos("Base De Datos.dat", ios::binary);
     
     if (Datos.good())
        while (!Datos.eof())
              if ( Datos.read((char*)&Load, sizeof(Load)) )
                 InsertarFinal(Lista, Load);
                 
     Datos.close();
}


La Funcion funciona!!! pero no se por que hay que colocar esto

Código (cpp) [Seleccionar]
Datos.read((char*)&Load, sizeof(Load))

dentro de un if, le pregunte a alguien pero me dice que es para que no lea 2 veces lo mismo, pero esa es la duda... por que????


Gracias por su tiempo.  ;)
#5
Hola Buenas, el problema es que en mi código en la LINEA 20,cin.getline pasa de largo y no ejecuta la instrucción de leer, ya he depurado el código con Dev C++ pero es realmente extraño.

El error ÚNICAMENTE SUCEDE al escoger primero la opción 2 y después intentar con la 1.

Aquí esta la porción de código.
Código (cpp) [Seleccionar]

   while (Opcion!=3)
   {
         cout<<"Menu Principal\n\n";
         
         cout<<"1. Ingresar a Facebook";
         cout<<"2. Crear una cuenta"<<endl;
         cout<<"3. Salir\n\n\n";
         
         CharOp=getch();//Lee un caracter sin presionar enter y sin mostrarlo en pantalla
         
         if (CharOp=='1')
         {
            Opcion=1;//Se Decrara para mantener la condicion while principal
            system("cls");
                         
            Intentos=0;
            while (Intentos!=3)
            {            
                  gotoxy(30,10);cout<<"Usuario: ";
                  cin.getline(User,10,'\n');
           
                  Validacion=BuscarLista(&ListaUsuarios, User, 1);//Validacion Se Encarga de ver si el Usuario Existe,
                  if ( Validacion==false )
                  {
                     gotoxy(39,12);cout<<"ID no encontrada!!!"<<endl;
                     Sleep(1500);
                     //Borra Los Espacios Incorrectos Para Un Nuevo Intento
                     gotoxy(39,10);cout<<"                         ";
                     gotoxy(39,12);cout<<"                         ";
                     gotoxy(28,10);textcolor(12);cout<<char(219);
                     Intentos+=1;
                  }
                  else
                      Intentos=3;
            }
             
         }
               
         if (CharOp=='2')
         {
            Opcion=2;//Se Decrara para mantener la condicion while principal

            cout<<"Nombre: ";
            cin.getline(CuentaNueva.Nombre, 20,'\n');
            cout<<"ID: ";
            cin.getline(CuentaNueva.ID, 10,'\n');
            cout<<"Contrase"<<char(164)<<"a: ";
            cin.getline(CuentaNueva.Contrasenia, 10,'\n');
            cout<<"Genero (M - F): ";//AQUI ESTA EL ERROR????
            cin>>CuentaNueva.Genero;
            cout<<"Edad: ";
            cin>>CuentaNueva.Edad;
            cout<<"Documento: ";
            cin>>CuentaNueva.Documento;
   
            InsertarFinal(&ListaUsuarios, CuentaNueva);
         }
             
         if (CharOp=='3')
            Opcion=3;//Se Decrara para mantener la condicion while principal
       
         system("cls");
   }


Si no me hago entender por favor descarguen el ejecutable
https://mega.co.nz/#!Btx2URJb!Dsr7oOEZx5RfvQkVlEAAv5gSw40uD2FEw-Uxh1mQJ9I

Aqui el link del codigo
https://mega.co.nz/#!owZQHZjB!QLbJo-EUYFfucYX2Mnn2GoBqzA56PLwqa1BYo4996Fs
#6
La duda es que tengo un archivo de texto asi:

Lucas Gnneco
Omar Rodriguez
Laura Monroy


y lo que quiero es que atravez del manejo de archivos sin sobreescribir nada meter un nombre por ejemplo entre Omar y Laura.


Lucas Gnneco
Omar Rodriguez
Pepito Perez
Laura Monroy


con acceso secuencial no me funciono, asi que creo que es con acceso aleatorio con seekg y seekp pero la verdad no he podido, podria alguien orientarme por favor.
#7
Hola, estoy haciendo un programa para contar el numero de palabras que tenga una frase, el problema es que por supuesto siempre el numero de palabras varia, por lo que segun pienso yo, hay que usar memoria dinamica

Código (cpp) [Seleccionar]

int main(int argc, char *argv[])
{
    char Lectura[200], *PTok, **Palabras=NULL;
    int i=0, j=0, ContPal=1;
   
    cin.getline(Lectura, sizeof(Lectura));
   
    PTok=strtok(Lectura," ");
   
    while ( PTok!= NULL )
    {
          AgrEspacio(Palabras, ContPal);//AgrEspacio Agrega Una Fila De Mas A Palabras
          strcpy( Palabras[i], PTok );
          PTok=strtok(NULL," ");
          i+=1;
          ContPal+=1;
    }
   
    for ( j=0; j<i; j++ )
        cout<<Palabras[j]<<endl;
   
    system("PAUSE");
    return EXIT_SUCCESS;
}



El problema como tal es esa funcion para agregar una fila a la matriz, ya que si compila, pero estoy violando el acceso a la memoria en una parte del codigo de esa funcion

Código (cpp) [Seleccionar]

void AgrEspacio ( char **Palabras, int NumPal)
{
     char **TemFilas=new char*[NumPal];
     
     for ( int i=0; i<NumPal; i++ )
     {
         TemFilas[i]=new char[200]; 
         TemFilas[i]=Palabras[i];
     }
         
     Palabras=TemFilas;   
}

La verdad este tema de memoria dinamica se me hace un poco dificil de entender, ya que no se bien cuando es correcto usarla, por ejemplo en este ejercicio podria haber creado una matriz estatica como
Código (cpp) [Seleccionar]
char Palabras[100][200]; en vez de pensar en memoria dinamica, pero la ventaja es que con esta voy agregando filas a mi matriz cuando lo voy necesitando en vez de declarar una estatica y ocupar memoria que tal vez no usare

Gracias por su tiempo.
#8
El codigo compila pero el ejecutable no funciona tal como la imagen de el link

Código (cpp) [Seleccionar]
#include <cstdlib>
#include <iostream>

using namespace std;

struct Item{
      int Peso;
      int Volumen;
      string Nombre;
};

struct Maleta{
      int Peso;
      int Volumen;
      int Cantidad_Items;
      Item *Items;
};

int main(int argc, char *argv[])
{
   Maleta *Mi_Maleta=new Maleta[10];
   Mi_Maleta->Items=new Item[10];
   
   Mi_Maleta[1].Items[0].Nombre="Peras";
   Mi_Maleta[1].Items[0].Volumen=12;
   Mi_Maleta[1].Items[0].Peso=16;

     
   system("PAUSE");
   return EXIT_SUCCESS;
}

http://www.subirimagenes.com/imagen-imagen1-8658261.html
#9
En el main tengo un arreglo de tamaño 1 pero necesito que este incremente su tamaño a medida que el usuario digite mas y mas datos...


#include <cstdlib>
#include <iostream>
#include <string>
#include <conio.h>

using namespace std;

struct Datos {
       string Nombre;
       int Edad;
};

struct Categorias {
       string Deporte;
       int Atletas;
       Datos Informacion;
};

void Ingresar_Deportista ( Categorias *Deportes, int Cant_Deportes );

int main(int argc, char *argv[])
{   
    int Num_Deportes=1; //Tamaño Variable - Cambia En Tiempo De Ejecucion
    Categorias *Deportes= new Categorias[Num_Deportes];

    Ingresar_Deportista( Deportes, Num_Deportes );
   
    system("PAUSE");
    return EXIT_SUCCESS;
}


Ese incremento de tamaño lo implemente en la funcion Ingresar_Deportista justo al final


void Ingresar_Deportista ( Categorias *Deportes, int Cant_Deportes ){
     
     int i=0, Aux=0;
     char Opcion='s';
     
     while(Opcion=='s'){
     cout<<"Deporte: ";
     cin>>Deportes[i].Deporte;
     cout<<"\nNombre: ";
     cin>>Deportes[i].Informacion.Nombre;
     cout<<"Edad: ";
     cin>>Deportes[i].Informacion.Edad;
     cout<<"\nIngresar Mas? Si(s) ";
     Opcion=getch();
     i+=1;
     system("cls");
     
//Si Supera El Tamaño Maximo (Darle Mas Memoria Al Arreglo Dinamico)

     if( i>=Cant_Deportes ){
         Categorias *Agrandar= new Categorias[Cant_Deportes+1];
         for(Aux=0; Aux<Cant_Deportes; Aux++)
         Agrandar[Aux]=Deportes[Aux];
         Deportes=Agrandar;}
     }
}


El codigo compila pero despues de ingresar el tercer deporte el ejecutable se totea, a que se debe esto?
#10
#include <cstdlib>
#include <iostream>


using namespace std;

struct Datos {
      char *Nombre;
      int Edad;
};

struct Categorias {
      char *Deporte;
      int Atletas;
      Datos *Informacion;
};

int main(int argc, char *argv[])
{  
   Categorias *Otro= new Categorias[10];
   
   Otro[0].Informacion->Nombre="Oscar";
       
   system("PAUSE");
   return EXIT_SUCCESS;
}


Pordrian por favor ayudarme .. el codigo compila pero el ejecutable se totea