car y _car son ambas matrices, y no se puede asignar matrices en C (excepto cuando la matriz está incrustada en una estructura (o unión) y usted hace una asignación de estructura).
También son matrices de punteros a char, en lugar de punteros a matrices de char. Probablemente, lo que ha escrito en el código es lo que desea, puede almacenar punteros hasta nombres MAXINT en la matriz. Sin embargo, debe describir el tipo correctamente, como una matriz de punteros a char o char punteros.
Un puntero a una matriz de caracteres se vería así:
char (*car)[MAXINT];
Y un punto a una matriz de punteros a carácter (gracias, Brian) se vería así:
char *(*car)[MAXINT];
Tenga cuidado de MAXINT; que podría ser una matriz muy grande (en Linux, <values.h> define MAXINT como INT_MAX, que es al menos 2 -1).
El código es el siguiente:
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 la asignación a la barra, ni coche, se recomienda compilar en absoluto - es una argvoid *. Presumiblemente, pretendía usar thing en alguna forma o forma.Como se ha señalado Brian, hay problemas allí, también:
O lo quieren:
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...
}
o si desea:
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...
}
O, en efecto:
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...
}
Finalmente, tratando con la asignación de matriz, en C puedes utilizar razonablemente memmove() para hacer esto:
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 función similar memcpy() no tiene la semántica fiables si las áreas a ser copiados solapamiento, mientras que memmove() hace; es más simple usar siempre memmove() porque siempre funciona correctamente. En C++, debe tener precaución al usar memmove() (o memcpy()). En este código, sería lo suficientemente seguro, pero entender por qué no es trivial.
Debe tener en cuenta que solo está copiando punteros aquí; no está copiando las cadenas que señalan los punteros. Si algo más cambia esas cadenas, afecta tanto a los valores vistos a través de car como a la variable en el código de llamada.
Un último punto - por ahora: ¿está seguro de que necesita el argumento para la función como void *? Abre el código para todo tipo de abuso que se puede evitar si se declara que la función toma un 'struct foo *' en su lugar (o incluso un 'const struct foo *').
Gracias, lo que necesitaba era un puntero a la matriz de char *. Creo que esto es lo que necesitaba (cruza el dedo) –
@Fantastic Fourier: estoy de acuerdo en que necesitas un puntero a una matriz, cuyos elementos son char *. algunas otras respuestas mencionaron un puntero a una matriz char * que no es la misma. –