Tableau de POINTEURS vers Plusieurs Types de C

Vous ne pouvez pas avoir un éventail de différents types, exactement. Mais vous pouvez obtenir un effet similaire (pour certaines fins, au moins) dans un certain nombre de façons différentes.

Si vous voulez juste un peu de valeurs de types différents, assemblés, mais le nombre et les types de valeurs ne changent pas, vous avez juste besoin d'un struct et peuvent y accéder par le nom:

struct s_item {
  int     number;
  char    str[100];
} item;
item.number = 5;
strcpy(item.str,"String less than 100 chars");

---

Si vous savez quels sont les types que vous pourriez utiliser, vous pouvez créer un syndicat ou d'une structure contenant une union de sorte que vous pouvez marquer avec le type. Vous pouvez ensuite créer un tableau de ceux-ci. Le type membre vous permet de vérifier pour voir ce que vous avez stocké dans chaque élément du tableau plus tard.

enum ElementType { et_str, et_int, et_dbl };
struct Element {
  ElementType type;
  union {
    char      *str;
    int       i;
    double    d;
  }
};

struct Element *arr = malloc(sizeof(struct Element) * 3);
arr[0].type = et_str;
arr[0].str = strdup("String value"); /* remember to free arr[0].str */
arr[1].type = et_int;
arr[1].i = 5;
arr[2].type = et_dbl;
arr[2].d = 27.3;

/* access the values.. */
for (int i = 0; i < 3; i++) {
  switch(arr[i].type) {
    case et_str: printf("String: %s\n",arr[i].str); break;
    case et_int: printf("Integer: %d\n",arr[i].i); break;
    case et_dbl: printf("Double: %f\n",arr[i].d); break;
  }
}

/* The strings are dynamically allocated, so free the strings */
for (int i = 0; i < 3; i++)
  if (arr[0].type == et_str) free(arr[0].str);
/* free the malloc'ed array */
free(arr);
/* etc., etc. */

Cette approche peut faire perdre de l'espace parce que:

• Chaque élément a une valeur supplémentaire pour garder une trace du type de données qu'elle détient
• La structure peut avoir un rembourrage supplémentaire entre ses membres
• Les types dans l'union peuvent être de tailles différentes, auquel cas l'union sera aussi grand que le plus grand type

Si vous avez un autre moyen de savoir quel type vous avez stockées dans chaque élément, vous pouvez utiliser juste le strict de l'union sans la structure d'emballage. C'est un peu plus compact, mais chaque élément sera toujours au moins aussi grand que le plus grand type dans l'union.

---

Vous pouvez également créer un tableau de void * valeurs. Si vous faites cela, vous aurez à répartir les éléments d'une certaine manière et de leur assigner des adresses pour les éléments du tableau. Ensuite, vous aurez besoin de les jeter à la appropriée de type pointeur pour accéder aux articles. C ne propose pas de runtime type d'information, donc il n'y a aucun moyen de savoir quel type de données de chaque élément de points à partir du pointeur de lui-même-vous devez garder une trace de ce sur votre propre. Cette approche est beaucoup plus compact que les autres quand les types que vous stockez sont grandes et leurs tailles varient beaucoup, puisque chacun est attribué séparément à partir du tableau et ne peut être donnée que l'espace nécessaire pour ce type. Pour les types simples, vous n'avez pas vraiment le gain de quelque chose de plus à l'aide d'un syndicat.

void **arr = malloc(3 * sizeof(void *));
arr[0] = strdup("Some string"); /* is a pointer already */
arr[1] = malloc(sizeof(int));
*((int *)(arr[1])) = 5;
arr[2] = malloc(sizeof(double));
*((double *)(arr[2])) = 27.3;

/* access the values.. */
printf( "String: %s\n", (char *)(arr[0]) );
printf( "Integer: %d\n", *((int *)(arr[1])) );
printf( "Double: %f\n", *((double *)(arr[2])) );

/* ALL values were dynamically allocated, so we free every one */
for (int i = 0; i < 3; i++)
  free(arr[i]);
/* free the malloc'ed array */
free(arr);

Si vous avez besoin de garder une trace du type dans le tableau, vous pouvez également utiliser une structure pour stocker le type avec le pointeur, similaire à l'exemple précédent avec l'union. Une fois encore, ce n'est vraiment utile lorsque les types conservées sont grandes et varient beaucoup en taille.

enum ElementType { et_str, et_int, et_dbl };
struct Element {
  ElementType type;
  void        *data;
};

struct Element *arr = malloc(sizeof(struct Element) * 3);
arr[0].type = et_str;
arr[0].data = strdup("String value");
arr[1].type = et_int;
arr[1].data = malloc(sizeof(int));
*((int *)(arr[1].data)) = 5;
arr[2].type = et_dbl;
arr[2].data = malloc(sizeof(double));
*((double *)(arr[2].data)) = 27.3;

/* access the values.. */
for (int i = 0; i < 3; i++) {
  switch(arr[i].type) {
    case et_str: printf( "String: %s\n", (char *)(arr[0].data) ); break;
    case et_int: printf( "Integer: %d\n", *((int *)(arr[1].data)) ); break;
    case et_dbl: printf( "Double: %f\n", *((double *)(arr[2].data)) ); break;
  }
}

/* again, ALL data was dynamically allocated, so free each item's data */
for (int i = 0; i < 3; i++)
  free(arr[i].data);
/* then free the malloc'ed array */
free(arr);

OriginalL'auteur Dmitri

Vous pouvez facilement avoir un tableau de pointeurs qui pointent vers différents types. Bien sûr que cela soit très utile, vous devez avoir un moyen de l'enregistrement ou de la détermination de ce type est actuellement référencé par chaque élément.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main() {

    //This implicitly allocates memory to store 10 pointers
    void *a[10];

    //The first element will be a pointer to an int
    //Allocate the memory it points to, then assign it a value.
    a[0] = malloc(sizeof(int));
    *( (int *)a[0] ) = 4;

    //The second element will be a pointer to char; for simplicity,
    //I'm hardcoding the length of the string + 1 for the null byte.
    a[1] = malloc( 6*sizeof(char) );
    strncpy( a[1], "hello", 5 );

    printf( "%d\n", *( (int *)a[0] ) );
    printf( "%s\n", a[1] );

}

OriginalL'auteur Dave Costa

C'est parce que vous essayez de stocker une valeur dans une fente qui attend un pointeur. Essayez les solutions suivantes (vérification des erreurs omis par souci de concision)

int* pIntTemp = malloc(sizeof(int));
*pIntTemp = 4;
a[0] = pIntTemp;

OriginalL'auteur JaredPar