Saludos.
Una duda que me ha surgido y no consigo resolver, quiero que una función devuelva un 1 en caso de que se haya hecho todo correctamente o un 0 en caso de error, pero a su vez esa función devolverá un puntero de estructura, ¿como puedo solucionar esto? ya que si pongo "return 1" por ejemplo me da error en la conversión de datos.

Un saludo.

Muchas gracias, ¿como es eso  ? ¿Podrías ponerme un ejemplo por favor?
Mas o menos me situó pero no se como picar el código xD

Quieres decir una estructura con un enum dentro que contendría dos elementos, médicos y pacientes, ¿no? ¿Pero como hago para saber el tipo?

Muchas gracias, no estoy seguro de haberlo entendido bien, pero creo que es algo así como que lo puedo usar para punteros que apunten a un dato el cual yo no voy a modificar desde una función, si no solo a comprobar su valor, como en mi caso, pero no podría usarlo por ejemplo para punteros que apuntaran a otro puntero con el fin de modificar el valor de este ultimo.

¿Lo he entendido bien?

Un saludo.

Hola, tengo la siguiente duda:

En una funcion convierto los punteros void según lo necesite, es decir según el que le pase, lo que no se si es esto es una practica aceptada en C, compilar y funcionar funciona pero no se si debe hacer o no, o hacer esto puede acarrear fallos en algunos programas.
Me gustaría saber si es algo así como una practica que se puede hacer pero que debe evitarse en el mayor de los casos.

Esta es la función, lo que hago es convertir al tipo "medicos" o "pacientes" dependiendo de si "opc" es 0 u 1.
Al hacer la llamada solo el puntero que le pase a la función puede ser tanto del tipo
"medicos" como del "pacientes".

bool val_dni(void *primero,int dni,bool opc){
    medicos *auxM;
    pacientes *auxP;
    int m = 0;
    int p = 0;
    /* 0 para medicos, 1 para pacientes.
       0 si no existe, 1 si existe.   
    */
 
    if(opc == 1){
 
           auxP = (pacientes *)primero;
           while(auxP != NULL){
                        if(auxP->dni == dni){ return 1; }
                        auxP = auxP->next;
                     }
           return 0; 
    }else{
          auxM = (medicos *)primero;
          while(auxM != NULL){
                        if(auxM->dni == dni){return 1; }
                        auxM = auxM->next;
                     }
          return 0;
    }
}

Un saludo.

Solucionado. Disculpen las molestias.

Muchas gracias por la respuesta
Al final he hecho lo que dices, ya que era con la función fread y retornando el valor es mas seguro que lo que quería hacer.

Muchas gracias, eso si lo leí que traía de cabezas a los programados antes de la programación estructurada.

Un saludo.

Gracias Ya veo que no lo esta, pues no lo recuerdo, creo que lo leí en un  blog que el go to y el break estaban obsoletos.

Un saludo.

Hola buenas.

Tengo una duda, según tengo entendido el uso del break en C esta obsoleto, pero sin embargo tengo un while donde lo tengo que usar por fuerza, quiero saber si el problema es mio, es decir que estoy haciendo algo mal y ese break se puede sustituir por otra cosa, o es que en realidad hay casos donde el uso del break es esencial.

La estructura que uso ahora es esta:

while(1) {
 if(feof(fp)){break;}
 ...
}

Ya que si uso esto:

while(!feof(fp)){
....
}

me lee una vez de mas el archivo, es decir es como si se ejecutara el bucle una vez mas a lo que quiero..

Un saludo.

Hola buenas.

Tengo el siguiente problema que no consigo resolver y por mas que busco en el foro y en Internet no encuentro la forma de solucionarlo.

Tengo una lista en un fichero que previamente he insertado con fwrite, lo que quiero hacer es leer la lista de ese fichero con fseek y cargarla en una lista auxiliar para que el programa trabaje con ella (por ejemplo insertar datos) luego volvere a escribir el fichero entero y cada vez que quiera escribir en esa lista, la cargare en una auxiliar y trabajare con ella para volverla a guardar en el programa.

La función que he hecho para esto, es la siguiente:

medicos * read_fic(void){
 FILE *fp;
 medicos *aux,aux2,*first;
 fp = fopen("medicos.bin","r+b");
 fseek (fp, 0L, SEEK_SET);
 first = NULL;
 
 do{ 
   fread(&aux2,sizeof(medicos),1,fp);
   aux = (medicos *)malloc(sizeof(medicos));
 
   if(first == NULL){first = aux;}
   aux->dni = aux2.dni;
   aux->fecha = aux2.fecha;
   strcpy(aux->nombre,aux2.nombre);
   strcpy(aux->apellidos,aux2.apellidos);
 
   /* sacar datos de una estructura dentro de una lista dentro de un fichero */
 
   strcpy(aux->direccion.calle,aux2.direccion.calle);
   aux->direccion.bloque = aux2.direccion.bloque;
   aux->direccion.numero = aux2.direccion.numero;
 
   aux->next = aux2.next;
   /*
   printf("#%d \t Fecha: %d",aux->dni, aux->fecha);
   printf("\t#N: %s \t A: %s\t",aux->nombre, aux->apellidos);
   printf("Calle: %s\n",aux->direccion.calle);
   
   
   */
   aux = aux->next; 
  }while(!feof(fp)); // (aux2.next != NULL);
 
 fclose(fp);
 return first;
}

El main quedaría así:

int main(){
    medicos *primero;
    primero = NULL;
 
   primero = read_fic();
}

Pero esta función me da fallos de segmentación por todos lados, a parte de que estoy usando un puntero local a la función, por lo tanto el valor de aux se debería perder cuando retorne first que es un puntero al primer elemento de dicha lista, como resolvería este problema sin usar variables globales (por ejemplo haciendo que aux2 sea global).
De todas formas puede que tenga mas fallos a parte de ese, la función con la que cargo los datos del fichero en la lista.

Un saludo.