elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.


 


Tema destacado: Recuerda que debes registrarte en el foro para poder participar (preguntar y responder)


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  como se puede mejorar este programa si alguien me puede ayudar
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: como se puede mejorar este programa si alguien me puede ayudar  (Leído 1,039 veces)
matrixsystem

Desconectado Desconectado

Mensajes: 3


Ver Perfil
como se puede mejorar este programa si alguien me puede ayudar
« en: 14 Enero 2016, 00:12 »

es de funciones hash  tengo que mostrar el contenido pro al mostrarlo lo qeu ocurre es que me sae el dato elmiminado la funcion se llama mostrar     y si me pueden explicar para que sirve   if (registros[cont].codigo==codigo)
         if (registros[cont].vazio==1) {
            registros[cont].vazio=0;
            printf("\neliminado correctamente \n");
            break;
}
el programa completo es el siguiente:
y si alguien me pudiera explicar si esta bien implementarlo asi  o si tengo que cambiar algo con eso de los  "errores" se los agradeceria mucho  
 
#include<string.h>
#include<conio.h>
#include<stdio.h>
#include <ctype.h>
#include <cstdlib>
struct agenda {   // defino una estructura  llamada agenda
       int codigo;
       char nombre[10];
       char apellido[10];
       int telefono;
       int vazio;
} registros[10];
// funciones a utilizar
int ingresar(int codigo, int pos);
void consultar();
int verifica_pos();
void zerar();
int verifica_cod(int cod);
int  excluir();
void mostrar();



main() {
zerar();  // no entiendo para que sirve esta funcion  bien
int op=0,retorno,codaux,posicao;
while(op!=5){
   printf("\n\n\t\t\t\t** AGENDA ** \n1 - Ingresar\n2 - Buscar\n3 - Borrar\n4 - mostrar todo  \n\nOpcion:  ");
   scanf("%d",&op);
   fflush(stdin);
   switch(op) {
       case 1: {                
            posicao=verifica_pos();
            if (posicao!=-1) {
            printf("\nIngresar codigo\n");
            scanf("%d",&codaux);
         fflush(stdin);
               retorno=verifica_cod(codaux);
               if (retorno==1)
                  ingresar(codaux,posicao);
               if(retorno ==0)
               printf(" intenta de nuevo ");
            }
            else
              printf("\n La agenda ya esta llena\n");
       break;
       }
       case 2: {              
            consultar();
       break;
       }
       case 3: {
         excluir();
       break;
       }
       case 4: {
            mostrar();
         break;
        
       }
       case 5:
         {
            printf("presione una tecla para salir");
            break;
            }
       default:
{
      printf ("esa opcion no existe");
      break;
}      
   }
}

}
void mostrar( )
{
   
//aqui tengo que mostrar todo pero sin el dato eliminado ya que me muestras todo  seria con registros[pos].vazio== 1 pero   no se como muy bien


         int cont;
            cont=0;
            while (cont<10) {
         printf ("\n \t ----------------");
         printf ("\n \t posisicon %d",cont);
       printf (" \n \t codigo %d",registros[cont].codigo);
       fflush(stdin);
       printf ("\n\t nombre  %s",registros[cont].nombre);
       fflush(stdin);
       printf (" \n \t apellido %s",registros[cont].apellido );
       fflush(stdin);
   cont++;
}
      }
int suma =0;
int ingresar(int codigo, int pos) {
if(pos>10)
{
   printf("todo esta lleno");
}
else
{      
registros[pos].codigo=codigo;
   int  val_atomic=0;
             int val_atomic2=0;   
               int x,y;
bool estado2 =false ;
bool estado=false ;            
          do{
             if (estado== false )
             {
                printf ("\n Nombre");
             scanf ("%s",&registros[pos].nombre);  // utilizo scanf  ya que no se utyilizar muy bienel gets creo que hice lo correcto
             } else
             {
               if (val_atomic == 1)
               {
                  printf ("\n nombre correcto no es necesario modificar ") ;   
                x=1;
   
                  }      
             }
             if (estado2 == false )
             {
             printf ("\n Apellido ") ;
       scanf (" %s", & registros[pos].apellido) ;   
             }
             else
             {
                  if (val_atomic2 == 1)
               {      
                printf( "\n apellido correcto no es necesaeio modificar") ;   
             y=1;
                
         }
             }        
                char  *str =registros[pos].nombre;  // se supone que paso  lo que esta enla estrctura   d de nombre   a un puntero  
               char *str2=registros [pos].apellido;
int i=0;
   while (str  )  // no entiendo bien pero se supone que un puntero es un array  pero  no se como funciona el while aqui
  {
     if (strlen(registros[pos].nombre) >10) // digo que si cadena es mayor a 10 entonces    que no se pueda exceder del tamaño del array
   {
      printf ("\n lo siento demasiadas letras ") ;
      printf ("\n el nombre %s", registros[pos].nombre) ;
      fflush(stdin) ;
          printf (    "      tiene %d letras ",  strlen(registros[pos].nombre)) ; // imprimo el numero de letras contenidas
      break;
   }
      if (isalpha(str )!= NULL   )   // verifico si es  o no un tipo de dato alfabetico
       {
      printf ("\n  bien ");
       estado=true ;
       break;
       }else
       {
          printf ("\n el nombre es incorrecto nada de caracteres o numeros raros \n " ) ;
            registros[pos].vazio=0;  // aqui se supone que si lo que ingreso fue incorrecto  le digo  que   me lo eliimine de la estructura
          estado=false;
          break;
       }
       i++;
  }
  i=0;
  while (str2)
  {   
     if (strlen(registros[pos].apellido) >10)
   {
      printf ("\n lo siento demasiadas letras ") ;
      printf ("\n el apellido %s", registros[pos].apellido) ;
      fflush(stdin) ;
          printf (    "     tiene %d letras ",  strlen(registros[pos].apellido)) ;
      break;
   }
       if (isalpha (str2)!= NULL)
       {
         printf ("\n  bien ");
       estado2 =true ;
       break;   
       }   
    else
    {
    printf ("\n apellido es incorrecto   nada de numeros o caractes raros \n");
      registros[pos].vazio=0;
    estado2=false;
    break;
    }
    i++;
  }
}while (estado !=true  ||  estado2!=true ) ;   
   suma =x+y;
    registros[pos].vazio=1;  // aqui valido y digo que se le pase el valor para poder ser rgistrado
printf("\nEl registro a sido realizado\n\n");
  return suma ;
}

}
void consultar() {
int cont=0, codigo;
printf("\nIngresa el codigo\n");
scanf("%d",&codigo);
while(cont<=10) {
    if (registros[cont].codigo==codigo) { // igualo el codigo con el codigo de la estructura
       if (registros[cont].vazio==1) {   // se supone que   verifico si  en determinada posicion  vazio vale uno   y si es  asi que me lo imprima
          printf("\nNombre: %s",registros[cont].nombre);
          printf("\nApelldio %s",registros[cont].apellido);
          break;
       }
    }
    cont++;
    if (cont>10)  // si es mayor a diez significa que no lo encontro
       printf("\nCodigo no encontrado\n");
}
}
int verifica_pos() {
int cont=0;
while (cont<=10) {
      if (registros[cont].vazio==0)
         return(cont);
      cont++;
}
return(-1);  /// retorno  -1 para comprobar que  no este lleno
}
void zerar() {
int cont;
for (cont=0;cont<=10;cont++)
    registros[cont].vazio=0;  // no entiendo muy bien
}
int verifica_cod(int codigo) {
int cont=0;
while (cont<=10) {
   if (registros[cont].codigo==codigo)  // comparo el codigo   y si es el mismo   que me imprima que no se puede tener el mismo codigo
   {
       printf ("lo siento no puedes tener el mismo codigo ");
     return(0);
      }
   cont++;
}
return(1);  // retorno 1 para decirle que pueda continuar  si es que no es el mismo
}

int excluir() {
int codigo, cont=0;
printf("\nIngresa el codigo para ser eliminado\n");
scanf("%d",&codigo);
while (cont<=10) {
      if (registros[cont].codigo==codigo)  // compara como arriba
         if (registros[cont].vazio==1) {    // verifico  que  el valor de la estrctura de determinada posicion  sea iguala  uno para eliminarlo con la linea sigueinte
            registros[cont].vazio=0;
            printf("\neliminado correctamente \n");
            break;
         }
      cont++;
      if (cont>10)
         printf("\nCodigo nao encontrado\n");
}
return codigo;
}



En línea

MAFUS


Desconectado Desconectado

Mensajes: 1.478



Ver Perfil
Re: como se puede mejorar este programa si alguien me puede ayudar
« Respuesta #1 en: 14 Enero 2016, 19:59 »

Ahí va un código más bonito y adaptado totalmente a C, ya que había batiburrillo de mucho C y algo de C++.

Aviso que el código no compila. Los errores originales siguen estando. Tan solo se ha aclarado y se han quitado problemas dialectales.

A ver si así la gente se anima con este post.

Código
  1. #include <string.h>
  2. #include <stdio.h>
  3. #include <ctype.h>
  4. #include <stdlib.h>
  5.  
  6. // defino una estructura  llamada agenda
  7. struct agenda {  
  8.    int codigo;
  9.    char nombre[10];
  10.    char apellido[10];
  11.    int telefono;
  12.    int vacio;
  13. } registros[10];
  14.  
  15. // funciones a utilizar
  16. int ingresar(int codigo, int pos);
  17. void consultar();
  18. int verifica_pos();
  19. void desmarcar_pos();
  20. int verifica_cod(int cod);
  21. int excluir();
  22. void mostrar();
  23.  
  24. int main() {
  25.    int op, retorno, codaux, posicion;
  26.  
  27.    desmarcar_pos();  // no entiendo para que sirve esta funcion  bien
  28.  
  29.    do {
  30.        printf("\n\n\t\t\t\t** AGENDA **\n1 - Ingresar\n2 - Buscar\n3 - Borrar\n4 - Mostrar todo\n\nOpcion: ");
  31.        scanf("%d", &op);
  32.        while(getchar() != '\n');
  33.  
  34.        switch(op) {
  35.            case 1:                
  36.                posicion = verifica_pos();
  37.                if (posicion != -1) {
  38.                    printf("\nIngresar codigo: ");
  39.                    scanf("%d", &codaux);
  40.                    while(getchar() != '\n');
  41.  
  42.                    retorno = verifica_cod(codaux);
  43.                    if(retorno)
  44.                        ingresar(codaux, posicion);
  45.                    else
  46.                        puts("\nIntenta de nuevo");
  47.                }
  48.                else
  49.                    puts("\nLa agenda ya esta llena");
  50.                break;
  51.            case 2:              
  52.                consultar();
  53.                break;
  54.            case 3:
  55.                excluir();
  56.                break;
  57.            case 4:
  58.                mostrar();
  59.                break;
  60.            case 5:
  61.                puts("\nPresione INTRO para salir");
  62.                getchar();
  63.                break;
  64.            default:
  65.                printf ("\nEsa opcion no existe");
  66.                break;
  67.        }
  68.    } while(op != 5);
  69. }
  70.  
  71. void mostrar( )
  72. {
  73.    /* Aqui tengo que mostrar todo pero sin el dato eliminado ya que me
  74.      * muestras todo  seria con registros[pos].vacio == 1 pero
  75.      * no se como muy bien */
  76.    int cont = 0;
  77.  
  78.    while (cont < 10) {
  79.        printf ("\n\t ----------------");
  80.        printf ("\n\t posicion %d",cont);
  81.        printf ("\n\t codigo   %d",registros[cont].codigo);
  82.        printf ("\n\t nombre   %s",registros[cont].nombre);
  83.        printf ("\n\t apellido %s",registros[cont].apellido );
  84.        cont++;
  85.    }
  86. }
  87.  
  88. int ingresar(int codigo, int pos) {
  89.    int val_atomic;
  90.    int val_atomic2;
  91.    int estado;
  92.    int estado2;
  93.    int x, y;
  94.    int i;
  95.  
  96.    if(pos > 10) {
  97.        puts("\nTodo esta lleno");
  98.    }
  99.    else {      
  100.        registros[pos].codigo=codigo;
  101.        val_atomic = 0;
  102.        val_atomic2 = 0;
  103.        estado = 0;
  104.        estado2 = 0;  
  105.        do {
  106.            if(!estado) {
  107.                printf("\n Nombre: ");
  108.                scanf ("%s", &registros[pos].nombre);  // utilizo scanf ya que no se utyilizar muy bien el gets creo que hice lo correcto
  109.            }
  110.            else {
  111.                if(val_atomic == 1) {
  112.                    puts("\nNombre correcto no es necesario modificar");  
  113.                    x = 1;
  114.                }
  115.            }
  116.            if(!estado2) {
  117.                printf("\n Apellido ") ;
  118.                scanf("%s", &registros[pos].apellido);  
  119.            }
  120.            else {
  121.                if (val_atomic2 == 1) {      
  122.                    puts("\nApellido correcto no es necesario modificar") ;  
  123.                    y = 1;
  124.                }
  125.            }        
  126.            char *str = registros[pos].nombre;  // se supone que paso  lo que esta enla estrctura   d de nombre   a un puntero  
  127.            char *str2 = registros[pos].apellido;
  128.            i = 0;
  129.            while(str) {  // no entiendo bien pero se supone que un puntero es un array  pero  no se como funciona el while aqui
  130.                if(strlen(registros[pos].nombre) > 10) {  // digo que si cadena es mayor a 10 entonces que no se pueda exceder del tamaño del array
  131.                    puts("\nLo siento demasiadas letras");
  132.                    printf("El nombre %s", registros[pos].nombre);
  133.                    printf(" tiene %d letras ", strlen(registros[pos].nombre));  // imprimo el numero de letras contenidas
  134.                    break;
  135.                }
  136.                if(isalpha(str) != NULL) {  // verifico si es  o no un tipo de dato alfabetico
  137.                    puts("\nBien");
  138.                    estado = 1;
  139.                    break;
  140.                }
  141.                else {
  142.                    puts("\nEl nombre es incorrecto nada de caracteres o numeros raros");
  143.                    registros[pos].vacio = 0;  // aqui se supone que si lo que ingreso fue incorrecto le digo que me lo elimine de la estructura
  144.                    estado = 0;
  145.                    break;
  146.                }
  147.                i++;
  148.            }
  149.            i = 0;
  150.            while(str2) {  
  151.                if(strlen(registros[pos].apellido) > 10) {
  152.                    puts("\nLo siento demasiadas letras");
  153.                    printf("El apellido %s", registros[pos].apellido);
  154.                    printf(" tiene %d letras",  strlen(registros[pos].apellido));
  155.                    break;
  156.                }
  157.                if(isalpha(str2) != NULL) {
  158.                    puts("\nBien");
  159.                    estado2 = 1;
  160.                    break;  
  161.                }    
  162.                else {
  163.                    puts("\nApellido es incorrecto   nada de numeros o caractes raros");
  164.                    registros[pos].vacio = 0;
  165.                    estado2 = 0;
  166.                    break;
  167.                }
  168.                i++;
  169.            }
  170.        } while (estado != 1  ||  estado2 != 1);  
  171.        suma = x + y;
  172.        registros[pos].vacio = 1;  // aqui valido y digo que se le pase el valor para poder ser registrado
  173.        puts("\nEl registro a sido realizado\n");
  174.        return suma;
  175.    }
  176. }
  177.  
  178. void consultar() {
  179.    int cont = 0;
  180.    int codigo;
  181.  
  182.    printf("\nIngresa el codigo: ");
  183.    scanf("%d", &codigo);
  184.    while(cont <= 10) {
  185.        if(registros[cont].codigo == codigo) {  // igualo el codigo con el codigo de la estructura
  186.            if(registros[cont].vacio == 1) {  // se supone que verifico si en determinada posicion vacio vale uno y si es asi que me lo imprima
  187.                printf("\nNombre: %s", registros[cont].nombre);
  188.                printf("\nApelldio: %s", registros[cont].apellido);
  189.                break;
  190.            }
  191.        }
  192.        cont++;
  193.        if(cont > 10)  // si es mayor a diez significa que no lo encontro
  194.        puts("\nCodigo no encontrado");
  195.    }
  196. }
  197.  
  198. int verifica_pos() {
  199.    int cont = 0;
  200.  
  201.    while(cont <= 10) {
  202.        if(registros[cont].vacio == 0)
  203.            return(cont);
  204.        cont++;
  205.    }
  206.    return -1;  // retorno -1 para comprobar que no este lleno
  207. }
  208.  
  209. void desmarcar_pos() {
  210.    int cont;
  211.  
  212.    for(cont = 0; cont <= 10; cont++)
  213.        registros[cont].vacio = 0;  // no entiendo muy bien
  214. }
  215.  
  216. int verifica_cod(int codigo) {
  217.    int cont = 0;
  218.  
  219.    while(cont <= 10) {
  220.        if(registros[cont].codigo == codigo) {  // comparo el codigo y si es el mismo que me imprima que no se puede tener el mismo codigo
  221.            puts("\nLo siento no puedes tener el mismo codigo");
  222.            return 0;
  223.        }
  224.        cont++;
  225.    }
  226.    return 1;  // retorno 1 para decirle que pueda continuar si es que no es el mismo
  227. }
  228.  
  229. int excluir() {
  230.    int codigo;
  231.    int cont = 0;
  232.  
  233.    printf("\nIngresa el codigo para ser eliminado: ");
  234.    scanf("%d", &codigo);
  235.    while(getchar() != '\n');
  236.    while(cont <= 10) {
  237.        if(registros[cont].codigo == codigo)  // compara como arriba
  238.            if (registros[cont].vacio == 1) {  // verifico  que  el valor de la estrctura de determinada posicion  sea iguala  uno para eliminarlo con la linea sigueinte
  239.                registros[cont].vacio = 0;
  240.                puts("\nEliminado correctamente");
  241.                break;
  242.            }
  243.            cont++;
  244.            if(cont > 10)
  245.                puts("\nCodigo no encontrado");
  246.    }
  247.    return codigo;
  248. }

Vaya diferencia ¿eh?  ;-) ;-)


« Última modificación: 14 Enero 2016, 20:10 por MAFUS » En línea

while(is_alive(yourself)) {
    make_true(yourself, yourdreams);
}
D4RIO


Desconectado Desconectado

Mensajes: 1.004


U N I X


Ver Perfil WWW
Re: como se puede mejorar este programa si alguien me puede ayudar
« Respuesta #2 en: 16 Enero 2016, 19:19 »

Le di una repasada, quedan unos warnings que es VITAL corregir para algún lado, porque el uso de isalpha() es muy incorrecto.

Por favor ver los comentarios que hice al código. Traté de adaptar los comentarios a un estilo C más purista, corregí algunas cosas sencillas, pero hice muchos comentarios de cosas que quedan por corregir, si las hubiera corregido todas no hubieran reconocido el código que había.

Revisar y mejorar, por favor. Con gusto vuelvo a verlo cuando esté corregido. Muy importante lo de los isalpha().

Código
  1. #include <string.h>
  2. #include <stdio.h>
  3. #include <ctype.h>
  4. #include <stdlib.h>
  5.  
  6.  
  7.  
  8. /**
  9.  *  D4RIO: Usar enums en lugar de macros del preprocesador
  10.  *  ayuda a la hora de usar un debugger, ya que estos símbolos
  11.  *  forman parte de la tabla de símbolos del programa
  12.  */
  13. enum { MAX_LEN_STR_AGENDA = 10 };
  14. enum { MAX_REG_AGENDA = 10 };
  15.  
  16.  
  17.  
  18. /* defino una estructura  llamada agenda */
  19. struct agenda {
  20.  int codigo;
  21.  char nombre[MAX_LEN_STR_AGENDA];
  22.  char apellido[MAX_LEN_STR_AGENDA];
  23.  int telefono;
  24.  int vacio;
  25. } registros[MAX_REG_AGENDA];
  26.  
  27.  
  28.  
  29. /**
  30.  * funciones a utilizar
  31.  *
  32.  * D4RIO: A la hora de crear prototipos de funciones, notar que para
  33.  * C un parentesis vacio no significa precisamente que la funcion no
  34.  * recibe parametros. Usar (void) para ser específico sobre esto.
  35.  */
  36. int ingresar(int codigo, int pos);
  37. void consultar(void);
  38. int verifica_pos(void);
  39. void desmarcar_pos(void);
  40. int verifica_cod(int cod);
  41. int excluir(void);
  42. void mostrar(void);
  43.  
  44.  
  45.  
  46. int
  47. main(void)
  48. {
  49.  int op, retorno, codaux, posicion;
  50.  
  51.  desmarcar_pos();  /* no entiendo bien para que sirve esta funcion */
  52.  
  53.  do {
  54. printf("\n\n\t\t\t\t** AGENDA **\n1 - Ingresar\n2 - Buscar\n3 - Borrar\n4 - Mostrar todo\n\nOpcion: ");
  55. scanf("%d", &op);
  56.  
  57. while(getchar() != '\n');
  58.  
  59. switch(op) {
  60. case 1:                
  61.  posicion = verifica_pos();
  62.  if (posicion != -1) {
  63. printf("\nIngresar codigo: ");
  64. scanf("%d", &codaux);
  65. while(getchar() != '\n');
  66.  
  67. retorno = verifica_cod(codaux);
  68. if(retorno)
  69.  ingresar(codaux, posicion);
  70. else
  71.  puts("\nIntenta de nuevo");
  72.  }
  73.  else
  74. puts("\nLa agenda ya esta llena");
  75.  break;
  76. case 2:              
  77.  consultar();
  78.  break;
  79. case 3:
  80.  excluir();
  81.  break;
  82. case 4:
  83.  mostrar();
  84.  break;
  85. case 5:
  86.  puts("\nPresione INTRO para salir");
  87.  getchar();
  88.  break;
  89. default:
  90.  printf ("\nEsa opcion no existe");
  91.  break;
  92. }
  93.  } while(op != 5);
  94. }
  95.  
  96.  
  97.  
  98. /* adecuacion de la declaracion de funciones a lo usual */
  99. void
  100. mostrar()
  101. {
  102.  /**
  103.    * Aqui tengo que mostrar todo pero sin el dato eliminado ya que me
  104.    * muestras todo  seria con registros[pos].vacio == 1 pero
  105.    * no se como muy bien
  106.    */
  107.  int cont = 0;
  108.  
  109.  while (cont < MAX_REG_AGENDA) {
  110. printf ("\n\t ----------------");
  111. printf ("\n\t posicion %d",cont);
  112. printf ("\n\t codigo   %d",registros[cont].codigo);
  113. printf ("\n\t nombre   %s",registros[cont].nombre);
  114. printf ("\n\t apellido %s",registros[cont].apellido );
  115. cont++;
  116.  }
  117. }
  118.  
  119.  
  120.  
  121. /**
  122. * D4RIO:
  123. * Notar que si ya habia un prototipo no es necesario declarar el tipo de datos de los parametros.
  124. * De hecho es lo mismo si se ponen los tipos abajo de la declaracion de la funcion.
  125. *
  126. * adecuacion de la declaracion de funciones a lo usual
  127. */
  128. int
  129. ingresar(codigo, pos)
  130. {
  131.  int val_atomic;
  132.  int val_atomic2;
  133.  int estado;
  134.  int estado2;
  135.  /* D4RIO: faltaba declarar suma */
  136.  int x, y, suma;
  137.  int i;
  138.  
  139.  if(pos > MAX_REG_AGENDA) {
  140. puts("\nTodo esta lleno");
  141.  }
  142.  else {      
  143. registros[pos].codigo=codigo;
  144. val_atomic = 0;
  145. val_atomic2 = 0;
  146. estado = 0;
  147. estado2 = 0;  
  148. do {
  149.  if(!estado) {
  150. printf("\n Nombre: ");
  151. /**
  152. * utilizo scanf ya que no se utyilizar muy bien el gets creo que hice lo correcto
  153. *
  154. * D4RIO: Tampoco deberias usar scanf, es posible que tengas buffer overflows,
  155. * la mejor opcion es usar una biblioteca como GNU readline, otra opcion es fgets.
  156. * ADEMAS, estabas usando &registros[pos].nombre, que es un puntero a un puntero,
  157. * fijate que en otro comentario te lo explico, pero para C, las referencias a
  158. * arrays son punteros cuando se pasan a funciones. La forma correcta de llamar es
  159. * darle la direccion de memoria del primer caracter:
  160. *
  161. *    &registros[pos].nombre[0]
  162. *
  163. * o bien de esta forma, que es igual:
  164. *
  165. *    registros[pos].nombre
  166. */
  167. scanf ("%s", registros[pos].nombre);
  168.  }
  169.  else {
  170. if(val_atomic == 1) {
  171.  /**
  172.   * D4RIO:
  173.   * Por favor, usar puntuacion, originalmente aqui decia:
  174.   *
  175.   *    Nombre correcto no es necesario modificar
  176.   *
  177.   * Es inaceptable que no se use puntuacion, afecta la semantica.
  178.   * Les dejo un ejemplo:
  179.   *
  180.   *    El director, dice el maestro, es un burro
  181.   *    El director dice: el maestro es un burro
  182.   */
  183.  puts("\nNombre correcto, no es necesario modificar");  
  184.  x = 1;
  185. }
  186.  }
  187.  if(!estado2) {
  188. printf("\n Apellido ") ;
  189. scanf("%s", registros[pos].apellido);  
  190.  }
  191.  else {
  192. if (val_atomic2 == 1) {
  193.  /**
  194.   * D4RIO:
  195.   * Mismo comentario sobre la puntuacion
  196.   */
  197.  puts("\nApellido correcto, no es necesario modificar") ;  
  198.  y = 1;
  199. }
  200.  }
  201.  /**
  202.   * D4RIO:
  203.   * Lo que haces en estas dos lineas que siguen es declarar dos punteros
  204.   * a char (que se interpretan en C como strings), y apuntarlos al comienzo
  205.   * de los strings nombre y apellido de la posicion 'pos' del array de
  206.   * objetos del tipo estructurado 'struct agenda' (relee si no entiendes)
  207.   */
  208.  /* se supone que paso lo que esta en la estrctura d de nombre a un puntero */
  209.  char *str = registros[pos].nombre;
  210.  char *str2 = registros[pos].apellido;
  211.  i = 0;
  212.  /**
  213.   * no entiendo bien pero se supone que un puntero es un array
  214.   * pero  no se como funciona el while aqui
  215.   *
  216.   * D4RIO:
  217.   * Un puntero es un puntero, punto. Cuando apunta al inicio de una cadena
  218.   * de caracteres se usa como un manejador de esa cadena. No podemos andar
  219.   * pasando arrays completos de aqui para alla, asi que se usa un puntero
  220.   * porque ocupa menos espacio, basicamente. De hecho, C maneja a muchos fines
  221.   * registros[pos].nombre como un puntero a &registros[pos].nombre[0]
  222.   *
  223.   * Y no, el while aqui NO funciona, no lo corregi para que lo veas, porque es mas
  224.   * que evidente, el flujo del segundo 'if' va por el 'if' o por el 'else',
  225.   * por uno de los dos seguro, y en cualquiera de los dos hay un break, con lo
  226.   * que poner un while es inutil. Nunca pasara mas de una vez.
  227.   */
  228.  while(str) {
  229. /**
  230. * Digo que si cadena es mayor a 10 entonces que no se pueda exceder del tamaño del array
  231. *
  232. * D4RIO: Esto basicamente esta mal. Si hubieras leido mas de 10 caracteres
  233. * ya deberias tener problemas, no porque la cadena tenga muchas letras, sino
  234. * por la escritura del stack. Es probable que tu programa sufra un buffer
  235. * overflow. Por otro lado, declaraste 'str' y 'str2'... ¿para que? aqui
  236. * se vuelve a usar el mismo 'registros[pos].nombre' en lugar de 'str', que
  237. * actualmente apunta al mismo lugar.
  238. */
  239. if(strlen(registros[pos].nombre) > MAX_LEN_STR_AGENDA) {
  240.  puts("\nLo siento demasiadas letras");
  241.  printf("El nombre %s", registros[pos].nombre);
  242.  /* imprimo el numero de letras contenidas */
  243.  /**
  244.   * D4RIO: El tipo de retorno de strlen NO es int, esta
  245.   * clase de errores pueden llevar a buffer overflows, el formato
  246.   * para esto es %lu
  247.   */
  248.  printf(" tiene %lu letras ", strlen(registros[pos].nombre));
  249.  break;
  250. }
  251. /**
  252. * D4RIO:
  253. * Esto esta muy mal por diversos motivos. Primero desde lo semantico,
  254. * es redundante:
  255. *
  256. *   - NULL evalua a false porque es un cero (concretamente (void*)0)
  257. *   - Cualquier otro valor evaluaria a true
  258. *
  259. * Por lo tanto comparar con NULL es irrelevante, podria haber sido
  260. *
  261. *   if ( isalpha(str) )
  262. *
  263. * Claro, eso si isalpha() aceptase cadenas por parametro, pero la funcion
  264. * evalua un caracter, y debemos pasarlo casteado a (int), que es el tipo
  265. * que recibe por parametro. Asi que deben armar una funcion que evalue
  266. * isalpha() para cada caracter de la cadena, o decidirse por algo mas
  267. * rapido y escribir una uds mismos, decidan, pero esto esta mal.
  268. */
  269. if(isalpha(str) != NULL) {  /* verifico si es o no un tipo de dato alfabetico */
  270.  puts("\nBien");
  271.  estado = 1;
  272.  break;
  273. }
  274. else {
  275.  puts("\nEl nombre es incorrecto nada de caracteres o numeros raros");
  276.  /**
  277.   * aqui se supone que si lo que ingreso fue incorrecto
  278.   * le digo que me lo elimine de la estructura
  279.   */
  280.  registros[pos].vacio = 0;
  281.  estado = 0;
  282.  break;
  283. }
  284. i++;
  285.  }
  286.  i = 0;
  287.  while(str2) {  
  288. if(strlen(registros[pos].apellido) > MAX_LEN_STR_AGENDA) {
  289.  puts("\nLo siento demasiadas letras");
  290.  printf("El apellido %s", registros[pos].apellido);
  291.  /**
  292.   * D4RIO: El tipo de retorno de strlen NO es int, esta
  293.   * clase de errores pueden llevar a buffer overflows, el formato
  294.   * para esto es %lu
  295.   */
  296.  printf(" tiene %lu letras",  strlen(registros[pos].apellido));
  297.  break;
  298. }
  299. if(isalpha(str2) != NULL) {
  300.  puts("\nBien");
  301.  estado2 = 1;
  302.  break;  
  303. }    
  304. else {
  305.  puts("\nApellido es incorrecto   nada de numeros o caractes raros");
  306.  registros[pos].vacio = 0;
  307.  estado2 = 0;
  308.  break;
  309. }
  310. i++;
  311.  }
  312. } while (estado != 1  ||  estado2 != 1);  
  313. suma = x + y;
  314. /* aqui valido y digo que se le pase el valor para poder ser registrado */
  315. registros[pos].vacio = 1;
  316. puts("\nEl registro a sido realizado\n");
  317. return suma;
  318.  }
  319. }
  320.  
  321.  
  322.  
  323. /* adecuacion de la declaracion de funciones a lo usual */
  324. void
  325. consultar()
  326. {
  327.  int cont = 0;
  328.  int codigo = 0;
  329.  
  330.  printf("\nIngresa el codigo: ");
  331.  scanf("%d", &codigo);
  332.  while(cont <= MAX_REG_AGENDA) {
  333. /**
  334. * igualo el codigo con el codigo de la estructura
  335. *
  336. * D4RIO: se dice 'asigno', no 'igualo'
  337. */
  338. if(registros[cont].codigo == codigo) {
  339.  /**
  340.   * se supone que verifico si en determinada posicion vacio vale uno
  341.   * y si es asi que me lo imprima
  342.   *
  343.   * D4RIO: no se supone, es
  344.   */
  345.  if(registros[cont].vacio == 1) {
  346. printf("\nNombre: %s", registros[cont].nombre);
  347. printf("\nApelldio: %s", registros[cont].apellido);
  348. break;
  349.  }
  350. }
  351. cont++;
  352. /* si es mayor a diez significa que no lo encontro */
  353. if(cont > MAX_REG_AGENDA)
  354.  puts("\nCodigo no encontrado");
  355.  }
  356. }
  357.  
  358.  
  359.  
  360. /* adecuacion de la declaracion de funciones a lo usual */
  361. int
  362. verifica_pos()
  363. {
  364.  int cont = 0;
  365.  
  366.  while(cont <= MAX_REG_AGENDA) {
  367. if(registros[cont].vacio == 0)
  368.  return(cont);
  369. cont++;
  370.  }
  371.  /* retorno -1 para comprobar que no este lleno */
  372.  return -1;
  373. }
  374.  
  375.  
  376.  
  377.  
  378. void
  379. desmarcar_pos()
  380. {
  381.  int cont;
  382.  
  383.  /**
  384.    * no entiendo muy bien
  385.    *
  386.    * D4RIO: parece que 'vacio' es una marca, la pone en cero
  387.    * para todos los registros
  388.    */
  389.  for(cont = 0; cont <= MAX_REG_AGENDA; cont++)
  390. registros[cont].vacio = 0;
  391. }
  392.  
  393.  
  394.  
  395. /* adecuacion de la declaracion de funciones a lo usual */
  396. int
  397. verifica_cod(int codigo)
  398. {
  399.  int cont = 0;
  400.  
  401.  while(cont <= MAX_REG_AGENDA) {
  402. /**
  403. * comparo el codigo y si es el mismo que me imprima
  404. * que no se puede tener el mismo codigo
  405. */
  406. if(registros[cont].codigo == codigo) {
  407.  puts("\nLo siento no puedes tener el mismo codigo");
  408.  return 0;
  409. }
  410. cont++;
  411.  }
  412.  /* retorno 1 para decirle que pueda continuar si es que no es el mismo */
  413.  return 1;
  414. }
  415.  
  416.  
  417.  
  418. /* adecuacion de la declaracion de funciones a lo usual */
  419. int
  420. excluir()
  421. {
  422.  int codigo;
  423.  int cont = 0;
  424.  
  425.  printf("\nIngresa el codigo para ser eliminado: ");
  426.  scanf("%d", &codigo);
  427.  while(getchar() != '\n');
  428.  while(cont <= MAX_REG_AGENDA) {
  429. /* compara como arriba */
  430. if(registros[cont].codigo == codigo)
  431.  /**
  432.   * verifico  que  el valor de la estrctura de determinada posicion
  433.   * sea iguala  uno para eliminarlo con la linea sigueinte
  434.   *
  435.   * D4RIO: cuando mencionas 'el valor de la estructura',
  436.   * es el valor de 'vacio'
  437.   */
  438.  if (registros[cont].vacio == 1) {
  439. registros[cont].vacio = 0;
  440. puts("\nEliminado correctamente");
  441. break;
  442.  }
  443. cont++;
  444. /**
  445. * D4RIO: Esta parte se merece un premio a la falta de logica.
  446. * La condicion del bucle era mientras cont sea menor o igual
  447. * que la cantidad de registros de la agenda, eso significa que
  448. * JAMAS entraria al bucle si esta condicion se fuera a cumplir
  449. */
  450. if(cont > MAX_REG_AGENDA)
  451.  puts("\nCodigo no encontrado");
  452.  }
  453.  return codigo;
  454. }
« Última modificación: 16 Enero 2016, 19:26 por D4RIO » En línea

OpenBSDFreeBSD
Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
alguien me puede ayudar con este programa
Java
MrC4RL4NG4S 8 4,455 Último mensaje 5 Mayo 2010, 01:40
por Leyer
alguien me puede ayudar con como hallar este quinto superior?
Programación General
XpandyX 1 3,338 Último mensaje 24 Enero 2011, 10:03
por Sauruxum
alguien me puede ayudar con como hallar este quinto superior?
Ejercicios
XpandyX 2 4,662 Último mensaje 2 Febrero 2011, 14:09
por Fenix-Hack
alguien me puede ayudar con este problema ;)
Programación C/C++
andres199 1 1,600 Último mensaje 5 Junio 2012, 01:45
por x64core
¿Alguien me puede ayudar con este programa? « 1 2 »
Programación C/C++
ivorybom 10 5,847 Último mensaje 4 Noviembre 2012, 17:39
por flony
Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines