como se puede mejorar este programa si alguien me puede ayudar

[matrixsystem]

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;
}

[MAFUS]

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 (c) [Seleccionar] Expandir

#include <string.h>
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>

// defino una estructura  llamada agenda
struct agenda {  
   int codigo;
   char nombre[10];
   char apellido[10];
   int telefono;
   int vacio;
} registros[10];

// funciones a utilizar
int ingresar(int codigo, int pos);
void consultar();
int verifica_pos();
void desmarcar_pos();
int verifica_cod(int cod);
int excluir();
void mostrar();

int main() {
   int op, retorno, codaux, posicion;
   
   desmarcar_pos();  // no entiendo para que sirve esta funcion  bien
   
   do {
       printf("\n\n\t\t\t\t** AGENDA **\n1 - Ingresar\n2 - Buscar\n3 - Borrar\n4 - Mostrar todo\n\nOpcion: ");
       scanf("%d", &op);
       while(getchar() != '\n');
       
       switch(op) {
           case 1:                
               posicion = verifica_pos();
               if (posicion != -1) {
                   printf("\nIngresar codigo: ");
                   scanf("%d", &codaux);
                   while(getchar() != '\n');
                   
                   retorno = verifica_cod(codaux);
                   if(retorno)
                       ingresar(codaux, posicion);
                   else
                       puts("\nIntenta de nuevo");
               }
               else
                   puts("\nLa agenda ya esta llena");
               break;
           case 2:              
               consultar();
               break;
           case 3:
               excluir();
               break;
           case 4:
               mostrar();
               break;
           case 5:
               puts("\nPresione INTRO para salir");
               getchar();
               break;
           default:
               printf ("\nEsa opcion no existe");
               break;
       }
   } while(op != 5);
}

void mostrar( )
{
   /* Aqui tengo que mostrar todo pero sin el dato eliminado ya que me
    * muestras todo  seria con registros[pos].vacio == 1 pero
    * no se como muy bien */
   int cont = 0;
   
   while (cont < 10) {
       printf ("\n\t ----------------");
       printf ("\n\t posicion %d",cont);
       printf ("\n\t codigo   %d",registros[cont].codigo);
       printf ("\n\t nombre   %s",registros[cont].nombre);
       printf ("\n\t apellido %s",registros[cont].apellido );
       cont++;
   }
}

int ingresar(int codigo, int pos) {
   int val_atomic;
   int val_atomic2;
   int estado;
   int estado2;
   int x, y;
   int i;
   
   if(pos > 10) {
       puts("\nTodo esta lleno");
   }
   else {      
       registros[pos].codigo=codigo;
       val_atomic = 0;
       val_atomic2 = 0;
       estado = 0;
       estado2 = 0;  
       do {
           if(!estado) {
               printf("\n Nombre: ");
               scanf ("%s", &registros[pos].nombre);  // utilizo scanf ya que no se utyilizar muy bien el gets creo que hice lo correcto
           }
           else {
               if(val_atomic == 1) {
                   puts("\nNombre correcto no es necesario modificar");  
                   x = 1;
               }
           }
           if(!estado2) {
               printf("\n Apellido ") ;
               scanf("%s", &registros[pos].apellido);  
           }
           else {
               if (val_atomic2 == 1) {      
                   puts("\nApellido correcto no es necesario 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;
           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
                   puts("\nLo siento demasiadas letras");
                   printf("El nombre %s", registros[pos].nombre);
                   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
                   puts("\nBien");
                   estado = 1;
                   break;
               }
               else {
                   puts("\nEl nombre es incorrecto nada de caracteres o numeros raros");
                   registros[pos].vacio = 0;  // aqui se supone que si lo que ingreso fue incorrecto le digo que me lo elimine de la estructura
                   estado = 0;
                   break;
               }
               i++;
           }
           i = 0;
           while(str2) {  
               if(strlen(registros[pos].apellido) > 10) {
                   puts("\nLo siento demasiadas letras");
                   printf("El apellido %s", registros[pos].apellido);
                   printf(" tiene %d letras",  strlen(registros[pos].apellido));
                   break;
               }
               if(isalpha(str2) != NULL) {
                   puts("\nBien");
                   estado2 = 1;
                   break;  
               }    
               else {
                   puts("\nApellido es incorrecto   nada de numeros o caractes raros");
                   registros[pos].vacio = 0;
                   estado2 = 0;
                   break;
               }
               i++;
           }
       } while (estado != 1  ||  estado2 != 1);  
       suma = x + y;
       registros[pos].vacio = 1;  // aqui valido y digo que se le pase el valor para poder ser registrado
       puts("\nEl registro a sido realizado\n");
       return suma;
   }
}

void consultar() {
   int cont = 0;
   int codigo;
   
   printf("\nIngresa el codigo: ");
   scanf("%d", &codigo);
   while(cont <= 10) {
       if(registros[cont].codigo == codigo) {  // igualo el codigo con el codigo de la estructura
           if(registros[cont].vacio == 1) {  // se supone que verifico si en determinada posicion vacio 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
       puts("\nCodigo no encontrado");
   }
}

int verifica_pos() {
   int cont = 0;

   while(cont <= 10) {
       if(registros[cont].vacio == 0)
           return(cont);
       cont++;
   }
   return -1;  // retorno -1 para comprobar que no este lleno
}

void desmarcar_pos() {
   int cont;
   
   for(cont = 0; cont <= 10; cont++)
       registros[cont].vacio = 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
           puts("\nLo 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;
   int cont = 0;
   
   printf("\nIngresa el codigo para ser eliminado: ");
   scanf("%d", &codigo);
   while(getchar() != '\n');
   while(cont <= 10) {
       if(registros[cont].codigo == codigo)  // compara como arriba
           if (registros[cont].vacio == 1) {  // verifico  que  el valor de la estrctura de determinada posicion  sea iguala  uno para eliminarlo con la linea sigueinte
               registros[cont].vacio = 0;
               puts("\nEliminado correctamente");
               break;
           }
           cont++;
           if(cont > 10)
               puts("\nCodigo no encontrado");
   }
   return codigo;
}

Vaya diferencia ¿eh?  

[D4RIO]

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 (c) [Seleccionar] Expandir

#include <string.h>
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>



/**
*  D4RIO: Usar enums en lugar de macros del preprocesador
*  ayuda a la hora de usar un debugger, ya que estos símbolos
*  forman parte de la tabla de símbolos del programa
*/
enum { MAX_LEN_STR_AGENDA = 10 };
enum { MAX_REG_AGENDA = 10 };



/* defino una estructura  llamada agenda */
struct agenda {
 int codigo;
 char nombre[MAX_LEN_STR_AGENDA];
 char apellido[MAX_LEN_STR_AGENDA];
 int telefono;
 int vacio;
} registros[MAX_REG_AGENDA];



/**
* funciones a utilizar
*
* D4RIO: A la hora de crear prototipos de funciones, notar que para
* C un parentesis vacio no significa precisamente que la funcion no
* recibe parametros. Usar (void) para ser específico sobre esto.
*/
int ingresar(int codigo, int pos);
void consultar(void);
int verifica_pos(void);
void desmarcar_pos(void);
int verifica_cod(int cod);
int excluir(void);
void mostrar(void);



int
main(void)
{
 int op, retorno, codaux, posicion;
   
 desmarcar_pos();  /* no entiendo bien para que sirve esta funcion */

 do {
printf("\n\n\t\t\t\t** AGENDA **\n1 - Ingresar\n2 - Buscar\n3 - Borrar\n4 - Mostrar todo\n\nOpcion: ");
scanf("%d", &op);

while(getchar() != '\n');
   
switch(op) {
case 1:                
 posicion = verifica_pos();
 if (posicion != -1) {
printf("\nIngresar codigo: ");
scanf("%d", &codaux);
while(getchar() != '\n');
   
retorno = verifica_cod(codaux);
if(retorno)
 ingresar(codaux, posicion);
else
 puts("\nIntenta de nuevo");
 }
 else
puts("\nLa agenda ya esta llena");
 break;
case 2:              
 consultar();
 break;
case 3:
 excluir();
 break;
case 4:
 mostrar();
 break;
case 5:
 puts("\nPresione INTRO para salir");
 getchar();
 break;
default:
 printf ("\nEsa opcion no existe");
 break;
}
 } while(op != 5);
}



/* adecuacion de la declaracion de funciones a lo usual */
void
mostrar()
{
 /**
  * Aqui tengo que mostrar todo pero sin el dato eliminado ya que me
  * muestras todo  seria con registros[pos].vacio == 1 pero
  * no se como muy bien
  */
 int cont = 0;
   
 while (cont < MAX_REG_AGENDA) {
printf ("\n\t ----------------");
printf ("\n\t posicion %d",cont);
printf ("\n\t codigo   %d",registros[cont].codigo);
printf ("\n\t nombre   %s",registros[cont].nombre);
printf ("\n\t apellido %s",registros[cont].apellido );
cont++;
 }
}



/**
* D4RIO:
* Notar que si ya habia un prototipo no es necesario declarar el tipo de datos de los parametros.
* De hecho es lo mismo si se ponen los tipos abajo de la declaracion de la funcion.
*
* adecuacion de la declaracion de funciones a lo usual
*/
int
ingresar(codigo, pos)
{
 int val_atomic;
 int val_atomic2;
 int estado;
 int estado2;
 /* D4RIO: faltaba declarar suma */
 int x, y, suma;
 int i;
   
 if(pos > MAX_REG_AGENDA) {
puts("\nTodo esta lleno");
 }
 else {      
registros[pos].codigo=codigo;
val_atomic = 0;
val_atomic2 = 0;
estado = 0;
estado2 = 0;  
do {
 if(!estado) {
printf("\n Nombre: ");
/**
* utilizo scanf ya que no se utyilizar muy bien el gets creo que hice lo correcto
*
* D4RIO: Tampoco deberias usar scanf, es posible que tengas buffer overflows,
* la mejor opcion es usar una biblioteca como GNU readline, otra opcion es fgets.
* ADEMAS, estabas usando &registros[pos].nombre, que es un puntero a un puntero,
* fijate que en otro comentario te lo explico, pero para C, las referencias a
* arrays son punteros cuando se pasan a funciones. La forma correcta de llamar es
* darle la direccion de memoria del primer caracter:
*
*    &registros[pos].nombre[0]
*
* o bien de esta forma, que es igual:
*
*    registros[pos].nombre
*/
scanf ("%s", registros[pos].nombre);
 }
 else {
if(val_atomic == 1) {
 /**
  * D4RIO:
  * Por favor, usar puntuacion, originalmente aqui decia:
  *
  *    Nombre correcto no es necesario modificar
  *
  * Es inaceptable que no se use puntuacion, afecta la semantica.
  * Les dejo un ejemplo:
  *
  *    El director, dice el maestro, es un burro
  *    El director dice: el maestro es un burro
  */
 puts("\nNombre correcto, no es necesario modificar");  
 x = 1;
}
 }
 if(!estado2) {
printf("\n Apellido ") ;
scanf("%s", registros[pos].apellido);  
 }
 else {
if (val_atomic2 == 1) {
 /**
  * D4RIO:
  * Mismo comentario sobre la puntuacion
  */
 puts("\nApellido correcto, no es necesario modificar") ;  
 y = 1;
}
 }
 /**
  * D4RIO:
  * Lo que haces en estas dos lineas que siguen es declarar dos punteros
  * a char (que se interpretan en C como strings), y apuntarlos al comienzo
  * de los strings nombre y apellido de la posicion 'pos' del array de
  * objetos del tipo estructurado 'struct agenda' (relee si no entiendes)
  */
 /* se supone que paso lo que esta en la estrctura d de nombre a un puntero */
 char *str = registros[pos].nombre;
 char *str2 = registros[pos].apellido;
 i = 0;
 /**
  * no entiendo bien pero se supone que un puntero es un array
  * pero  no se como funciona el while aqui
  *
  * D4RIO:
  * Un puntero es un puntero, punto. Cuando apunta al inicio de una cadena
  * de caracteres se usa como un manejador de esa cadena. No podemos andar
  * pasando arrays completos de aqui para alla, asi que se usa un puntero
  * porque ocupa menos espacio, basicamente. De hecho, C maneja a muchos fines
  * registros[pos].nombre como un puntero a &registros[pos].nombre[0]
  *
  * Y no, el while aqui NO funciona, no lo corregi para que lo veas, porque es mas
  * que evidente, el flujo del segundo 'if' va por el 'if' o por el 'else',
  * por uno de los dos seguro, y en cualquiera de los dos hay un break, con lo
  * que poner un while es inutil. Nunca pasara mas de una vez.
  */
 while(str) {
/**
* Digo que si cadena es mayor a 10 entonces que no se pueda exceder del tamaño del array
*
* D4RIO: Esto basicamente esta mal. Si hubieras leido mas de 10 caracteres
* ya deberias tener problemas, no porque la cadena tenga muchas letras, sino
* por la escritura del stack. Es probable que tu programa sufra un buffer
* overflow. Por otro lado, declaraste 'str' y 'str2'... ¿para que? aqui
* se vuelve a usar el mismo 'registros[pos].nombre' en lugar de 'str', que
* actualmente apunta al mismo lugar.
*/
if(strlen(registros[pos].nombre) > MAX_LEN_STR_AGENDA) {
 puts("\nLo siento demasiadas letras");
 printf("El nombre %s", registros[pos].nombre);
 /* imprimo el numero de letras contenidas */
 /**
  * D4RIO: El tipo de retorno de strlen NO es int, esta
  * clase de errores pueden llevar a buffer overflows, el formato
  * para esto es %lu
  */
 printf(" tiene %lu letras ", strlen(registros[pos].nombre));
 break;
}
/**
* D4RIO:
* Esto esta muy mal por diversos motivos. Primero desde lo semantico,
* es redundante:
*
*   - NULL evalua a false porque es un cero (concretamente (void*)0)
*   - Cualquier otro valor evaluaria a true
*
* Por lo tanto comparar con NULL es irrelevante, podria haber sido
*
*   if ( isalpha(str) )
*
* Claro, eso si isalpha() aceptase cadenas por parametro, pero la funcion
* evalua un caracter, y debemos pasarlo casteado a (int), que es el tipo
* que recibe por parametro. Asi que deben armar una funcion que evalue
* isalpha() para cada caracter de la cadena, o decidirse por algo mas
* rapido y escribir una uds mismos, decidan, pero esto esta mal.
*/
if(isalpha(str) != NULL) {  /* verifico si es o no un tipo de dato alfabetico */
 puts("\nBien");
 estado = 1;
 break;
}
else {
 puts("\nEl nombre es incorrecto nada de caracteres o numeros raros");
 /**
  * aqui se supone que si lo que ingreso fue incorrecto
  * le digo que me lo elimine de la estructura
  */
 registros[pos].vacio = 0;
 estado = 0;
 break;
}
i++;
 }
 i = 0;
 while(str2) {  
if(strlen(registros[pos].apellido) > MAX_LEN_STR_AGENDA) {
 puts("\nLo siento demasiadas letras");
 printf("El apellido %s", registros[pos].apellido);
 /**
  * D4RIO: El tipo de retorno de strlen NO es int, esta
  * clase de errores pueden llevar a buffer overflows, el formato
  * para esto es %lu
  */
 printf(" tiene %lu letras",  strlen(registros[pos].apellido));
 break;
}
if(isalpha(str2) != NULL) {
 puts("\nBien");
 estado2 = 1;
 break;  
}    
else {
 puts("\nApellido es incorrecto   nada de numeros o caractes raros");
 registros[pos].vacio = 0;
 estado2 = 0;
 break;
}
i++;
 }
} while (estado != 1  ||  estado2 != 1);  
suma = x + y;
/* aqui valido y digo que se le pase el valor para poder ser registrado */
registros[pos].vacio = 1;
puts("\nEl registro a sido realizado\n");
return suma;
 }
}



/* adecuacion de la declaracion de funciones a lo usual */
void
consultar()
{
 int cont = 0;
 int codigo = 0;

 printf("\nIngresa el codigo: ");
 scanf("%d", &codigo);
 while(cont <= MAX_REG_AGENDA) {
/**
* igualo el codigo con el codigo de la estructura
*
* D4RIO: se dice 'asigno', no 'igualo'
*/
if(registros[cont].codigo == codigo) {
 /**
  * se supone que verifico si en determinada posicion vacio vale uno
  * y si es asi que me lo imprima
  *
  * D4RIO: no se supone, es
  */
 if(registros[cont].vacio == 1) {
printf("\nNombre: %s", registros[cont].nombre);
printf("\nApelldio: %s", registros[cont].apellido);
break;
 }
}
cont++;
/* si es mayor a diez significa que no lo encontro */
if(cont > MAX_REG_AGENDA)
 puts("\nCodigo no encontrado");
 }
}
   


/* adecuacion de la declaracion de funciones a lo usual */
int
verifica_pos()
{
 int cont = 0;
   
 while(cont <= MAX_REG_AGENDA) {
if(registros[cont].vacio == 0)
 return(cont);
cont++;
 }
 /* retorno -1 para comprobar que no este lleno */
 return -1;
}




void
desmarcar_pos()
{
 int cont;

 /**
  * no entiendo muy bien
  *
  * D4RIO: parece que 'vacio' es una marca, la pone en cero
  * para todos los registros
  */
 for(cont = 0; cont <= MAX_REG_AGENDA; cont++)
registros[cont].vacio = 0;
}



/* adecuacion de la declaracion de funciones a lo usual */
int
verifica_cod(int codigo)
{
 int cont = 0;
   
 while(cont <= MAX_REG_AGENDA) {
/**
* comparo el codigo y si es el mismo que me imprima
* que no se puede tener el mismo codigo
*/
if(registros[cont].codigo == codigo) {
 puts("\nLo siento no puedes tener el mismo codigo");
 return 0;
}
cont++;
 }
 /* retorno 1 para decirle que pueda continuar si es que no es el mismo */
 return 1;
}



/* adecuacion de la declaracion de funciones a lo usual */
int
excluir()
{
 int codigo;
 int cont = 0;
   
 printf("\nIngresa el codigo para ser eliminado: ");
 scanf("%d", &codigo);
 while(getchar() != '\n');
 while(cont <= MAX_REG_AGENDA) {
/* compara como arriba */
if(registros[cont].codigo == codigo)
 /**
  * verifico  que  el valor de la estrctura de determinada posicion
  * sea iguala  uno para eliminarlo con la linea sigueinte
  *
  * D4RIO: cuando mencionas 'el valor de la estructura',
  * es el valor de 'vacio'
  */
 if (registros[cont].vacio == 1) {
registros[cont].vacio = 0;
puts("\nEliminado correctamente");
break;
 }
cont++;
/**
* D4RIO: Esta parte se merece un premio a la falta de logica.
* La condicion del bucle era mientras cont sea menor o igual
* que la cantidad de registros de la agenda, eso significa que
* JAMAS entraria al bucle si esta condicion se fuera a cumplir
*/
if(cont > MAX_REG_AGENDA)
 puts("\nCodigo no encontrado");
 }
 return codigo;
}