car et _car sont les deux tableaux, et vous ne pouvez pas affecter des tableaux en C (sauf lorsque le tableau est incorporé dans une structure (ou union) et que vous faites une affectation de structure).
Ce sont également des tableaux de pointeurs vers char, plutôt que des pointeurs vers des tableaux de char. Ce que vous avez écrit dans le code est probablement ce que vous voulez - vous pouvez stocker des pointeurs jusqu'à des noms MAXINT dans le tableau. Cependant, vous devez décrire le type correctement - comme un tableau de pointeurs vers des pointeurs char ou char.
Un pointeur sur un tableau de caractères ressemblerait à ceci:
char (*car)[MAXINT];
Et un point à un tableau de pointeurs de caractères (merci, Brian) ressemblerait à ceci:
char *(*car)[MAXINT];
Méfiez-vous des MAXINT; cela pourrait être un très grand tableau (sur Linux, <values.h> définit MAXINT comme INT_MAX, qui est au moins 2 -1).
Le code ressemble à:
struct foo
{
int _bar;
char * _car[MAXINT];
}
int foofunc (void * arg)
{
int bar;
char * car[MAXINT];
struct foo thing = (struct foo *) arg;
bar = arg->_bar; // this works fine
car = arg->_car; // this gives compiler errors of incompatible types in assignment
}
Ni l'affectation à la barre, ni voiture devrait compiler du tout - arg est un void *. Vous vouliez probablement utiliser thing dans une certaine forme ou forme.Comme Brian a noté, il y a des problèmes là aussi:
Soit vous voulez:
int foofunc(void *arg)
{
int bar;
char *car[MAXINT];
struct foo thing = *(struct foo *)arg;
bar = thing._bar; // this works fine
car = thing._car; // this is still an array assignment
...other code using bar and car...
}
Ou vous voulez:
int foofunc(void *arg)
{
int bar;
char *car[MAXINT];
struct foo *thing = (struct foo *) arg;
bar = thing->_bar; // this works fine
car = thing->_car; // this is still an array assignment
...other code using bar and car...
}
Ou bien:
int foofunc(void *arg)
{
struct foo *thing = (struct foo *) arg;
int bar = thing->_bar; // this works fine
char *car[MAXINT] = thing->_car; // this is still an array assignment
...other code using bar and car...
}
Enfin, en traitant l'assignation de tableau, en C, vous pouvez utiliser raisonnablement memmove() pour ce faire:
int foofunc(void *arg)
{
struct foo *thing = (struct foo *) arg;
int bar = thing->_bar; // this works fine
char *car[MAXINT];
memmove(car, thing->_car, sizeof(car));
...other code using bar and car...
}
La fonction similaire memcpy() ne pas sémantique fiable si les zones à copier se chevauchent, alors que memmove() fait; il est plus simple de toujours utiliser memmove() car cela fonctionne toujours correctement. En C++, vous devez être prudent sur l'utilisation de memmove() (ou memcpy()). Dans ce code, il serait assez sûr, mais comprendre pourquoi est non-trivial.
Vous devez savoir que vous ne faites que copier des pointeurs ici - vous ne copiez pas les chaînes pointant vers. Si quelque chose d'autre change ces chaînes, cela affecte à la fois les valeurs vues via car et la variable dans le code appelant.
Un dernier point - pour l'instant: êtes-vous sûr que vous avez besoin de l'argument de la fonction en tant que void *? Il ouvre le code à toutes sortes d'abus qui peuvent être évités si la fonction est déclarée prendre un 'struct foo *' à la place (ou même un 'const struct foo *').
Merci, ce dont j'avais besoin, c'était un pointeur sur le tableau de char *. Je pense que c'est ce dont j'avais besoin (croise le doigt) –
@Fantastic Fourier: D'accord, vous avez besoin d'un pointeur vers un tableau, dont les éléments sont char *. d'autres réponses ont mentionné un pointeur vers un tableau char * qui n'est pas le même. –