Comment puis-je utiliser correctement un pointeur void en C?

Une chose à garder à l'esprit: C ne garantit pas que int sera assez grande pour contenir un pointeur (y compris void*). Ce moulage est pas un portable chose/une bonne idée. Utilisation %p à printf un pointeur.

De même, vous êtes en train de faire un "mauvais casting" ici: void* res = (int*) a est de dire au compilateur: "je suis sûr que la valeur de a est valide int*, de sorte que vous devez le traiter comme tel". Sauf si vous savez pour un fait qu'il est un int stockées en mémoire à l'adresse 30, ce qui est faux.

Heureusement, vous avez immédiatement remplacer res avec l'adresse de la autres a. (Vous avez deux vars nommé a et deux nommés res, celles main et ceux dans func. Ceux func sont des copies de la valeur de l'un dans main, lorsque vous appelez). Généralement parlant, l'écrasement de la valeur d'un paramètre à une fonction est "mauvais", mais il est techniquement légal. Personnellement, je vous recommande de déclarer l'ensemble de vos fonctions de paramètres comme const 99% du temps (par exemple,void func (const int a, const void* res))

Puis, vous lancez res à un unsigned short. Je ne pense pas que quelqu'un est encore en cours d'exécution sur la 16 bits de l'espace d'adressage du PROCESSEUR (bien, votre Apple II, peut-être), donc, ça va certainement corrompre la valeur de res en tronquant.

En général, dans C, typecasts sont dangereux. Vous êtes à prendre en compte le compilateur du type de système, et en disant: "regardez ici, Monsieur le Compilateur, je suis le programmeur, et je sais mieux que vous ce que j'ai ici. Donc, vous venez d'être tranquille et que cela se produise." La conversion d'un pointeur à un non-type de pointeur est presque universellement mal. La conversion entre les types de pointeur est le plus souvent mauvais que ne pas.

Je vous suggère de vérifier certains de la "Relative" des liens en bas de cette page afin de trouver un bon aperçu de la façon dont C types de pointeurs de travail, en général. Parfois, il faut lire plus de quelques pour vraiment avoir une compréhension sur la façon dont ce genre de choses va de pair.

OriginalL'auteur BRPocock

Un pointeur void est utilisé dans C comme une sorte de pointeur générique. Un vide pointeur de variable peut être utilisé pour contenir l'adresse d'une variable de type. Le problème avec un pointeur void est une fois que vous avez attribué une adresse du pointeur, les informations sur le type de la variable n'est plus disponible pour le compilateur pour vérifier.

En général, nulle pointeurs devrait être évitée, car le type de la variable dont l'adresse est dans le vide pointeur n'est plus disponible pour le compilateur. D'autre part, il existe des cas où un vide pointeur qui est très pratique. Toutefois, c'est au programmeur de connaître le type de la variable dont l'adresse est dans le vide pointeur de variable et de l'utiliser correctement.

Beaucoup de anciennes de source C a C de style jette entre le type des pointeurs et non avenue des pointeurs. Ce n'est pas nécessaire avec les compilateurs modernes et devrait être évitée.

De la taille d'un pointeur void variable est connue. Ce qui n'est pas connu, c'est la taille de la variable dont le pointeur est dans le vide pointeur de variable. Par exemple, voici quelques exemples de sources.

//create several different kinds of variables
int iValue;
char aszString[6];
float  fValue;

int  *pIvalue = &iValue;
void *pVoid = 0;

int iSize = sizeof(*pIvalue);   //get size of what int pointer points to, an int

int vSize = sizeof(*pVoid);     //compile error, size of what void pointer points to is unknown
int vSizeVar = sizeof(pVoid);   //compiles fine size of void pointer is known

pVoid = &iValue;        //put the address of iValue into the void pointer variable
pVoid = &aszString[0];  //put the address of char string into the void pointer variable
pVoid = &fValue;        //put the address of float into the void pointer variable

pIvalue = &fValue;      //compiler error, address of float into int pointer not allowed

Une façon qui vide les pointeurs ont été utilisés, c'est d'avoir plusieurs différents types de structures qui sont fournis en argument à une fonction, généralement une sorte de dispatching de la fonction. Depuis l'interface de la fonction qui permet différents types de pointeur, un vide pointeur doit être utilisé dans la liste d'arguments. Ensuite, le type de la variable pointée est déterminé soit par un argument supplémentaire ou de l'inspection de la variable pointée. Un exemple de ce type d'utilisation d'une fonction serait quelque chose comme ce qui suit. Dans ce cas, nous inclure un indicateur comme le type de la structure dans le premier membre de diverses permutations de la struct. Tant que toutes les structures qui sont utilisés avec cette fonction ayant comme premier membre d'une int indiquant le type de structure, cela fonctionnera.

struct struct_1 {
    int iClass;  //struct type indicator.  must always be first member of struct
    int iValue;
};

struct struct_2 {
    int   iClass;  //struct type indicator.  must always be first member of struct
    float fValue;
};

void func2 (void *pStruct)
{
    struct struct_1 *pStruct_1 = pStruct;
    struct struct_2 *pStruct_2 = pStruct;

    switch (pStruct_1->iClass)  //this works because a struct is a kind of template or pattern for a memory location
    {
    case 1:
        //do things with pStruct_1
        break;
    case 2:
        //do things with pStruct_2
        break;
    default:
        break;
    }
}

void xfunc (void)
{
    struct struct_1 myStruct_1 = {1, 37};
    struct struct_2 myStruct_2 = {2, 755.37f};

    func2 (&myStruct_1);
    func2 (&myStruct_2);
}

Quelque chose comme ci-dessus a un certain nombre de problèmes de conception logicielle avec le couplage et la cohésion de sorte que si vous avez de bonnes raisons pour l'utilisation de cette approche, il est préférable de repenser la conception de votre. Cependant, le langage de programmation C vous permet de faire cela.

Il y a certains cas où le vide pointeur est nécessaire. Par exemple, le malloc() fonction qui alloue de la mémoire renvoie un void pointeur contenant l'adresse de la zone qui leur a été attribué (ou la valeur NULL si l'allocation a échoué). Le vide pointeur dans ce cas permet à un malloc() fonction qui permet de retourner l'adresse de la mémoire pour n'importe quel type de variable. Le tableau suivant montre l'utilisation de malloc() avec différents types de variables.

void yfunc (void)
{
    int *pIvalue = malloc(sizeof(int));
    char *paszStr = malloc(sizeof(char)*32);

    struct struct_1 *pStruct_1 = malloc (sizeof(*pStruct_1));
    struct struct_2 *pStruct_2Array = malloc (sizeof(*pStruct_2Array)*21);

    pStruct_1->iClass = 1; pStruct_1->iValue = 23;

    func2(pStruct_1);  //pStruct_1 is already a pointer so address of is not used

    {
        int i;
        for (i = 0; i < 21; i++) {
            pStruct_2Array[i].iClass = 2;
            pStruct_2Array[i].fValue = 123.33f;
            func2 (&pStruct_2Array[i]);  //address of particular array element.  could also use func2 (pStruct_2Array + i)
        }
    }
    free(pStruct_1);
    free(pStruct_2Array);   //free the entire array which was allocated with single malloc()
    free(pIvalue);
    free(paszStr);
}

OriginalL'auteur Richard Chambers

printf("result = %d\n", (int)res); est l'impression de la valeur de res (un pointeur) comme un nombre.
Rappelez-vous qu'un pointeur est une adresse en mémoire, ce qui permettra d'imprimer certains aléatoire de 32 bits en nombre.

Si vous voulez imprimer la valeur stockée à cette adresse, alors vous avez besoin (int)*res - bien que l' (int) est inutile.

edit: si vous voulez imprimer la valeur (c'est à dire l'adresse) d'un pointeur, alors vous devriez utiliser %p c'est essentiellement le même, mais les formats de mieux et comprend si la taille d'un int et un poitner sont différentes sur votre plate-forme

OriginalL'auteur Martin Beckett

void *res = (int *)a;

un est un int, mais pas un ptr, peut-être qu'il devrait être:

void *res = &a;

OriginalL'auteur zchenah