Quelle est la signification de * au début d'une expression C?

Question

Juste une question rapide pour les gens qui connaissent un peu de c. Quelle est la signification d'un * au début d'une expression. comme dans ...

If (this == thisThingOverHere) 
ThisThing = *((WORD *) &Array[withThisPosition]); 

Vous pouvez supposer WORD est un non signé et Array 16 bits est un tableau d'octets de 8 bits. Il est étonnamment difficile d'essayer de savoir ce qui se passe ici.

Vive

Answer 1

Il n'est pas si difficile de comprendre ce qui se passe. Brisons-le.

&Array[withThisPosition] 

Cela dit prendre l'adresse de l'élément withThisPosition dans Array. Équivalent à Array + withThisPosition.

(WORD *) 

Cela dit présument le pointeur retourné par &Array[withThisPosition] est en fait un pointeur à un mot. Ceci est connu comme un "cast" parce que vous dites au compilateur de traiter l'objet différemment du type Array était à l'origine.

Enfin:

*(...) 

Cela dit renvoyer l'objet qui est pointé. Donc, le mot à l'intérieur de l'objet pointé est retourné.

Si je devais réécrire pour vous, je pourrais suggérer:

If (this == thisThingOverHere) { 
    void *pointerToArrayELement; 
    WORD *pointerToWORD; 
    WORD result; 

    pointerToArrayElement = &Array[withThisPosition]; 
    pointerToWORD = (WORD *)pointerToArrayElement; 
    result = *pointerToWORD; 

    ThisThing = result; 
} 

Answer 2

déréférencer un pointeur et obtenir la valeur correspondante.

exemple:

#include <stdio.h> 

int main(int argc, char **argv) { 
    int *i_ptr; 
    int i, j; 

    i = 5; 
    i_ptr = &i; 

    j = *i_ptr; 

    printf("%d\n", j); 
    return 0; 
} 

impressions 5

En C, vous avez des emplacements de mémoire (pensez genre de "boîtes"), et les valeurs vont à l'intérieur. Chaque emplacement de mémoire a une adresse, et vous pouvez stocker cette adresse dans une "variable de pointeur", qui est déclarée avec le type, suivi d'un *. Par exemple, i_ptr est un pointeur sur un entier (int *), alors que i et j sont des entiers. Cela signifie qu'en mémoire, trois "boîtes" ont été allouées, deux seront prêtes à contenir des nombres réels (i et j) et un (i_ptr) sera prêt à contenir une adresse dans une autre boîte, et vous informerez le compilateur que le La boîte référencée contiendra un nombre.

avec & vous obtenez l'adresse de la boîte du nom de la boîte: &i vous donne l'adresse de i, et vous pouvez stocker dans i_ptr.

Lorsque vous avez l'adresse de la boîte et que vous voulez visiter la boîte et obtenir la valeur, utilisez *, par ex. *i_ptr vous donne la valeur contenue dans la boîte à l'adresse contenue dans i_ptr.

Answer 3

cette valeur est la même que * (this) .value c'est de déréférencer le pointeur.

Answer 4

C a un concept important et puissant de pointeurs. Vous devriez vraiment apprendre à leur sujet - un bon tutoriel est available here. Si ptr est un pointeur, alors *ptr est la valeur vers laquelle il pointe.

Answer 5

Vous avez des parenthèses sans correspondance dans votre expression. Je suppose que vous vouliez dire:

ThisThing = *((WORD *) &Array[withThisPosition]); 

le

(WORD *) &Array[withThisPosition] 

partie est de pointeur de type WORD. Le leader * déférent le pointeur. Ainsi,

*((WORD *) &Array[withThisPosition]) 

est de type WORD.

Answer 6

Il est probablement plus facile de regarder l'expression en morceaux, puis de les assembler.

&Array[withThisPosition] 

Ce bien a l'adresse de l'élément à withThisPosition dans le tableau Array. Si vous le souhaitez, vous pouvez l'écrire comme suit: Array+withThisPosition.

(WORD *) 

Ce qu'il dit de prendre tout ce qui vient après (le bit ci-dessus) et le traiter comme un pointeur vers un WORD.

L'initiale *, puis dit de déréférencer ce pointeur - c'est-à-dire regarder ce qu'il pointe.

Dans l'ensemble, c'est de trouver une position (withThisPosition) à Array, et en regardant un WORD à cette adresse, et en attribuant la valeur de ce mot à ThisThing.

Answer 7

L'utilisation de * dans C est un peu déroutant car il a deux significations différentes mais liées. Votre exemple est déroutant parce que les deux de ces significations sont utilisées dans la même ligne de code.

Lorsqu'il est immédiatement adjacent à un type, le * est un modificateur qui indique que vous faites référence à un pointeur vers ce type. Ceci est le plus souvent vu dans les déclarations de variables, mais peut également être utilisé dans les distributions, comme vous le voyez ici avec (WORD *).

Lorsqu'il n'est pas utilisé avec un type, * est un opérateur unaire qui déréférence un pointeur. En d'autres termes, il prend la valeur de l'opérande, le traite comme un emplacement de mémoire et renvoie le contenu de cet emplacement. L'opérateur détermine également le type de variable sur lequel pointe l'opérande et convertit la valeur de ce type à l'emplacement de la mémoire. Le compilateur effectuera généralement une vérification pour s'assurer que l'opérande est en fait un pointeur. Dans ce cas, le compilateur sait &Array[withThisPosition]) est un pointeur sur un octet, car Array est un tableau d'octets.

Pour revenir à votre question, généralement quand * est au début d'une instruction C, c'est l'opérateur de déréférencement, mais je ne garantis pas que c'est toujours le cas. Pointers m'a donné beaucoup moins de maux de tête une fois que j'ai séparé les deux significations de * dans mon cerveau.