avertissement: distribution de pointeur d'entier de taille différente

Je suis en train de travailler sur la programmation socket.. mon code s'exécute de la façon dont je le veux, je suis en mesure de l'utiliser. MAIS il me donne un avertissement à la compilation.

Je compiler à l'aide de

gcc server1.c -o server1 -lpthread

Et je reçois un avertissement

warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]

Cette erreur vient pour le code suivant

int newsockfd;
newsockfd = (int)newsockfdd; //this line

Et je suis en utilisant newsockfdd (qui est de type int) dans le bloc de code

if (pthread_create(&threadID[i++], NULL, serverThread, (void *)(intptr_t)newsockfdd) != 0)
    {
        perror("Thread create error");
    }

Comme vous pouvez sans doute dire, le code n'est pas écrit trop bien (je suis en train de faire mieux). Je sais que cet avertissement vient à cause de quelque chose à voir avec la taille d'un int. Mais vraiment, je ne sais pas comment le résoudre. Avant je l'ai mis dans (intptr_t) dans le pthread_create déclaration, il a été en montrant un avertissement sur cette ligne, mais que le temps de l'avertissement a été

warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]

Il semble qu'il devrait y avoir une solution simple à ce point? Mais je ne le trouve pas. Je suis sur Ubuntu 64 bits. Est qu'une des raisons de l'avertissement?

Hmm, compte tenu de l'avertissement que vous avez obtenu d' (void*)newsockfdd avant de vous interposés le casting de intptr_t, il semble peu probable que la cast from pointer to integer of different size avertissement est en fait à partir de la ligne indiquée.
À moins que... Est-ce que la ligne de serverThread et newsockfdd est l'argument que serverThread reçoit? Ensuite, il serait clair.
Oui.. je passe en argument à serverThread. Comme suit: void *serverThread(void *newsockfdd). Alors quel est le problème?
Ainsi, la fonction que vous êtes en cours d'exécution comme un pthread prend un void* comme argument. Si votre int est d'abord jeté à void* quand il est passé, puis dans serverThread, le void* est jeté en arrière pour int. C'est mauvais style, mauvais en sera probablement de travail. Mais, si possible, passer une pointeur pour newsockfdd et dans serverThread, cast le pointeur de int* et de déréférencement.

OriginalL'auteur user1825770 | 2012-11-25

6

Comme cela a été établi dans les commentaires, la situation est (modulo renommage d'éviter la confusion entre les occurrences de newsockfdd comme argument passé ou reçu paramètre)
```
void *serverThread(void *arg) {
    //...
    int newsockfd = (int)arg;
    //...
}
```
et dans main (ou une fonction appelée)
```
//...
int newsockfdd = whatever;
//...
if (pthread_create(&threadID[i++], NULL, serverThread, (void *)(intptr_t)newsockfdd) != 0)
//..
```
Ainsi, lorsque le int newsockfdd est passé comme argument à serverThread, il est moulé pour un void*. À l'origine, que le plâtre a été direct, mais l'intermédiaire de fonte à intptr_t a été inséré pour supprimer l'avertissement sur la cast to pointer from integer of different size.

Et dans serverThread, le reçu void* est jeté à l' int, résultant dans l'avertissement sur la cast from pointer to integer of different size.

De cette mise en garde pourrait également être retiré par l'insertion d'un intermédiaire en fonte à intptr_t.

Mais, alors que la norme permet la conversion en nombres entiers pour les pointeurs et vice versa, les résultats sont définis par l'implémentation et il n'y a aucune garantie que int -> void* -> int aller-retours (bien que, d'une note de bas de page dans la norme dit

Les fonctions de mappage pour la conversion d'un pointeur vers un entier ou un nombre entier à un pointeur sont destinés à
être compatible avec l'adressage de la structure de l'environnement d'exécution.

donc probablement il va aller-retour et fonctionne comme prévu dans ce cas - mais il serait susceptible de ne pas fonctionner [uniquement pour des valeurs assez petites, en valeur absolue,] si la taille d'un void* est plus petit que le type integer [examiner long long -> void* -> long long sur les systèmes 32 bits]).

La bonne solution est d'éviter la conversion entre les entiers et les pointeurs,
```
void *serverThread(void *arg) {
    //... check that arg isn't NULL
    int newsockfd = *(int *)arg;
    //...
}
```
dans severThread, la fonte de la réception de l'pointeur vers un pointeur de type approprié, et de lire de la pointe-de valeur, et dans main
```
if//...
int newsockfdd = whatever;
//...
if (pthread_create(&threadID[i++], NULL, serverThread, &newsockfdd) != 0)
```
passer l'adresse de newsockfdd.

Une mise en garde: si serverThread est appelé à partir de plusieurs endroits, les appels dans tous ces endroits ont besoin d'être fixe.

Dans main vous suggérons de passer l'adresse d'une variable locale en tant que paramètre. C'est un bug, si les sorties principales avant serverThread() s'exécute, et ce dernier tente de déréférencement de l'adresse (qui n'est plus une adresse valide, depuis newsockfdd sera libéré lorsque les sorties principales), votre programme va planter. Mieux vaut qu'elle soit intermédiaire de fonte, ou passer l'adresse d'une variable statique au lieu d'un local (local).
Hmm, j'ai eu l'impression que si main sorties, il faut de tout pthread_created filets avec elle (mais elle devrait rejoindre le fils engendré de toute façon).
Je ne pense pas que c'est garanti, mais je peux me tromper. En tout cas, si c'est mieux sécurisé que désolé; examiner si la création de thread est fait dans une fonction d'assistance appelé par la main. Alors le problème se produit même si le principal attend les enfants à la sortie. Comme une règle générale, il est préférable de ne pas passer des adresses locales à d'autres threads...

OriginalL'auteur Daniel Fischer

Vous devez vous connecter pour publier un commentaire.