C - Quand est-ce que le casting est nul?

J'ai été à la recherche à Advanced Linux Programmation par Mitchell, Oldham et Samuel. J'ai vu dans la section sur les pthreads quelque chose à propos de nulle pointeurs et de la coulée qui me confond.

Passage d'un argument à pthread_create(), ils ne jette pas le pointeur vers un pointeur void même si c'est ce que la fonction attend.

pthread_create( &thread, NULL, &compute_prime, &which_prime );

Ici, which_prime est de type int.

Mais en prenant une valeur de retour du thread à l'aide de pthread_join, ils NE jeter la variable pointeur void.

pthread_join( thread, (void*) &prime );

Ici, premier est de type int de nouveau.

Pourquoi est coulée dans le second exemple, et non pas dans la première?

source d'informationauteur Amoeba

  1. 8

    Le deuxième exemple est un bon exemple de pourquoi casting pour void* est généralement une erreur. Il devrait être

    void *primep = ′  //no cast needed
pthread_join(thread, &primep);

    parce que pthread_join prend un void** comme second argument. Le void* permet seulement de garantir le bug passe le compilateur parce que le void* est converti à void** automatiquement.

    Donc, quand ne vous avez besoin de jeter à void* ou à l'arrière:

    • lorsque l'on travaille avec des pointeurs stockés comme des entiers ((u)intptr_t);
    • lors du passage de pointeurs de fonctions qui ont un incomplètes prototype et de prendre void* (ou de prendre un autre type de pointeur et vous avez void*); ce qui signifie généralement des fonctions prenant un nombre variable d'arguments tels que printf.
  2. 7

    Pas besoin de cast ou à partir d'un pointeur vers void dans C:

    6.3.2.3 Pointeurs

    1
    Un pointeur vers vide peuvent être converties vers ou à partir d'un pointeur pour toute information incomplète ou de l'objet
    type. Un pointeur pour toute information incomplète ou un type d'objet peut être converti en un pointeur vers vide
    et de retour à nouveau, le résultat est à comparer égale à l'original pointeur.

    Les seules exceptions sont

    • lors de l'impression d'un pointeur à l'aide de la "%p" indicateur de conversion comme il est défini uniquement pour les void *.
    • lors de la copie d'une valeur de pointeur à partir d'un intptr_t ou uintptr_t retour à un void *.
  3. 2

    En C, la conversion de void* à partir de n'importe quel type de pointeur et vice-versa est fait implicitement.
    Il n'est pas nécessaire pour le casting dans le deuxième exemple.

    (À noter qu'en C++, casting un pointeur de type void* est également fait implicitement (sauf pour les pointeurs de fonction et de la fonction-membre /méthode des indicateurs qui ne peuvent pas être exprimées à void*), mais la coulée arrière nécessite un cast explicite.)

  4. 1

    Je crois que le même code a été référencé dans d'autres questions.

    La réponse dans le deuxième lien explique:

    Il n'est pas valide. Simplement, il arrive à travailler si sizeof(int) ==
    sizeof(void *), qui se trouve sur de nombreux systèmes.

    Un void * n'est garanti que pour être en mesure de tenir des pointeurs vers les données
    objets.

    Ici est un C FAQ sur le sujet.

    Et le texte cité:

    Comment sont des entiers convertis depuis des pointeurs? Je peux temporairement
    des trucs un entier à un pointeur, ou vice versa?

    Pointeur vers un entier et entier-à-pointeur de faire des conversions
    la mise en œuvre définies (voir la question 11.33), et il n'est plus
    aucune garantie que les pointeurs peuvent être convertis en nombres entiers et à l'arrière,
    sans changement

    Forçant des pointeurs vers des entiers ou des nombres entiers dans les pointeurs, n'a jamais
    été bonnes pratiques

  5. 1

    Que par la de la documentation,

    int pthread_join(pthread_t thread, void **retval);

    Donc, le pthread_join prend un pointer to void* comme second argument. C'est parce que,

    Dans pthread_join, vous recevez en retour l'adresse passée à pthread_exit par
    le fini de fil. Si vous passer juste un simple pointeur, il est passé par
    la valeur de sorte que vous ne pouvez pas changer de où il pointe. Pour être en mesure de
    modifier la valeur du pointeur est passé à pthread_join, il doit être
    passé comme un pointeur lui-même, qui est un pointeur vers un pointeur.

    Maintenant, à votre question, "Pourquoi est coulée dans le second exemple, et non pas dans la première?"
    Dans le premier cas, c'est à dire, pthread_create, il s'attend à un void* comme quatrième argument. Donc, en passant &which_prime serait implicitement converti à void*.

    Dans le deuxième exemple, c'est à dire, pthread_joinil s'attend à un void** et nous sommes en train de &prime. Ainsi, le compilateur va se plaindre. Donc, pour contourner le bug, l'auteur passe un casting de void* qui sera automatiquement convertie à void**.

    Mais ce n'est pas une bonne solution. Même l'auteur de devis::

    4.1.3 Fil Valeurs De Retour

    ...,si vous souhaitez passer une seule int ou autres petit nombre, vous
    pouvez le faire facilement par la coulée de la valeur void* et puis la coulée arrière
    pour le type approprié après l'appel de pthread_join. Notez que c'est
    pas de portable, et c'est à vous de faire en sorte que votre valeur peut être
    exprimés en toute sécurité à void* et de dos sans perdre de bits.

    La Solution::

    void* prime ; //make prime as void*
pthread_join( thread, &prime );
printf( "%d\n", (intptr_t)prime ) ; 
//intptr_t instead of int to get an integer type 
//that's the same size as a pointer

    Ou, si vous ne voulez pas changer la mise en œuvre de prime comme int
    Comme, @larsmans ont mis en œuvre,

    void *primep = ′
pthread_join(thread, &primep);