c 赋值中的类型不兼容，指针有问题吗？

您好，我正在使用 C，我有一个关于分配指针的问题。

struct foo
{
   int _bar;
   char * _car[SOME_NUMBER]; // this is meant to be an array of char * so that it can hold pointers to names of cars
}

int foofunc (void * arg)
{
   int bar;
   char * car[SOME_NUMBER];

   struct foo * thing = (struct foo *) arg;

   bar = thing->_bar; // this works fine
   car = thing->_car; // this gives compiler errors of incompatible types in assignment
}

car 和 _car 具有相同的声明，那么为什么我会收到有关不兼容类型的错误？我的猜测是，这与它们是指针有关（因为它们是指向 char * 数组的指针，对吧？），但我不明白为什么这是一个问题。

当我宣布char * car;代替char * car[MAXINT];它编译得很好。但我不知道当我需要使用索引访问某些信息时这对我有什么用处，稍后访问该信息会非常烦人。事实上，我什至不确定我是否采用正确的方法，也许有更好的方法来存储一堆字符串而不是使用 char * 数组？

编辑：我并不是想使用 INT_MAX （int 的最大值），它只是其他一些 int，大约是 20。

car and _car都是数组，并且不能在 C 中分配数组（除非数组嵌入到结构（或联合）中并且执行结构分配）。

它们也是指向 char 的指针数组，而不是指向 char 数组的指针。您在代码中编写的内容可能就是您想要的 - 您可以在数组中存储最多 MAXINT 名称的指针。但是，您应该正确地描述类型 - 作为指向 char 或 char 指针的指针数组。

指向字符数组的指针如下所示：

char (*car)[MAXINT];

指向字符指针数组的点（谢谢，Brian）看起来像：

char *(*car)[MAXINT];

Be careful of MAXINT; that could be a very large array (on Linux, <values.h> defines MAXINT as INT_MAX, which is at least 2³¹-1).

代码如下：

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
}

对 bar 和 car 的分配根本不应该编译 -arg is a void *。你可能想使用thing以某种形状或形式。正如布莱恩指出的，那里也存在问题：

您要么想要：

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...
}

或者你想要：

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...
}

或者，确实：

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...
}

最后，处理数组赋值，在C中你可以合理地使用memmove()去做这个：

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...
}

类似的功能memcpy()如果要复制的区域重叠，则不具有可靠的语义，而memmove()做;总是使用更简单memmove()因为它总是能正常工作。在 C++ 中，使用时需要小心memmove() (or memcpy()）。在这段代码中，它足够安全，但理解其中的原因并非易事。

您确实需要注意，您只是在此处复制指针 - 您没有复制指针指向的字符串。如果其他东西改变了这些字符串，它会影响通过看到的两个值car以及调用代码中的变量。

最后一点 - 现在：您确定需要将函数的参数作为void *？它使代码容易遭受各种滥用，如果函数被声明为采用 'struct foo *' 代替（或者甚至是 'const struct foo *').