Comment imprimer errno tout en sauvant la valeur de la fonction?

Question

Je ne suis pas en mesure d'ouvrir/créer un fichier correctement en utilisant la fonction open(), donc j'ai pensé que l'utilisation de messages errno m'aidera à comprendre la raison. Cependant, je ne sais pas comment définir le if(), donc il m'imprime l'erreur. Je sais que le code comme cela devrait fonctionner:

if(open(handle,O_RDWR | O_CREAT) == -1){ 
     printf("%s\n",strerror(errno)); 
} 

mais si je veux sauver la valeur de l'open() à ma variable et si elle est -1 puis imprimer l'erreur aussi bien? Je ne veux pas appeler open() deux fois pour cela et je ne sais pas comment l'assigner si c'est ok et comment imprimer une erreur sinon.

#include <stdio.h> 
    #include <stdlib.h> 
    #include <fcntl.h> 
    #include <ctype.h> 
    #include <sys/types.h> 
    #include <sys/stat.h> 
    #include <string.h> 
    #include <errno.h> 


    int main(int argc, char **argv){ 
     int handle,i,help; 
     int *array = malloc(5*sizeof(int)); 
     float *red = malloc(5*sizeof(int)); 

     array[0]=5; 
     array[1]=4; 
     array[2]=3; 
     array[3]=2; 
     array[4]=1; 

     handle = open(argv[1], O_RDWR | O_CREAT); 
     if(handle == -1){ 
      printf("%s\n",strerror(errno)); 
     } 

     printf("handle 1 %d\n",handle); 
     write(handle,array,20); 
     close(handle); 

     handle = open(argv[1], O_RDONLY); 
     lseek(handle,0,SEEK_SET); 
     printf("handle %d\n",handle); 
     help=read(handle,&red,20); 
     printf("pomoc %d\n",help); 
     for(i=0; i<5; i++){ 
      printf("%d\n",(int)red[i]); 
     } 
     close(handle); 
     return 0; 
    } 

Answer 1

Il semble que vous le fassiez correctement; il suffit d'enregistrer la valeur de retour de open() dans une variable, puis comparez cela à -1. Bien.

Notez que ceci est cassé:

float *red = malloc(5*sizeof(int)); 

car il n'y a aucune garantie qu'un float est la même taille que l'int, cela est faux et très confus. Il est préférable de ne pas répéter le type dans le malloc() car cela risque d'introduire cette erreur. , Faire au lieu:

float * const red = malloc(5 * sizeof *red); 

Il utilise sizeof *red pour calculer sizeof (float), tout en vous assurant que le type est celui d'un pointeur réel dans votre programme. Notez également l'utilisation de const pour protéger contre red étant réattribuée plus tard, ce qui peut créer une fuite de mémoire.

Answer 2

La bonne façon de le faire est la suivante:

if((handle=open(argv[1], O_RDWR|O_CREAT, 0666)) == -1){ 

Notez que l'argument pmode est nécessaire pour O_CREAT.

Answer 3

Le problème n'est pas assigner à une variable, c'est la façon que vous appelez open:

handle = open(argv[1], O_RDWR|O_CREAT); // wrong number of arguments 
if (handle == -1) { 
    printf("%s\n",strerror(errno)); 
} 

Lorsque vous utilisez O_CREAT, vous devez donner opentrois arguments. Si vous ne le faites pas, le comportement n'est pas défini. Par accident, vous obteniez un retour d'erreur − 1 lorsque l'appel open se trouvait à l'intérieur du if, et une valeur de retour non négative lorsque vous l'avez affecté à une variable.

Sauf si vous avez une raison concrète de faire autrement, le troisième argument à open devrait être le nombre magique 0666. (La raison concrète la plus courante de faire autrement est que vous créez un fichier qui contiendra information secrète, alors vous utilisez 0600.) (Le zéro de début est requis.) Il sont des constantes symboliques qui peuvent être utilisées pour le troisième argument à open mais, une fois que vous savez ce que signifient les «modes» numériques, les constantes symboliques sont en réalité plus difficiles à lire.Here is a detailed explanation of "modes" in both symbolic and numeric forms.

Soit dit en passant, lorsqu'un appel système échoue, vous devez toujours imprimer les deuxstrerror(errno)et le nom du fichier incriminé (le cas échéant):

handle = open(argv[1], O_RDWR|O_CREAT, 0666); 
if (handle == -1) { 
    printf("%s: %s\n", argv[1], strerror(errno)); 
    exit(1); 
} 

Et vous devriez penser à si vous devriez être en utilisant O_EXCL ou O_TRUNC.