Question

我有一个指向结构list* ptr的指针该struct包含一个char和一个指向下一个struct的指针，这些结构用于如下所示的结构数组：

list array[setSize]; //setSize is defined as 20

不使用malloc，我需要初始化list* ptr，以便它包含数组的所有元素。

我尝试过以下操作并遇到分段错误。我相信我完全误解了指针是如何工作的。（我很久没碰过C了）

int j = 0;
ptr = sizeof(array[j]);  //i was thinking this would allocate space     
for(j; j < setSize; j++)
    array[j].next = array[j+1].next;
ptr = array; //i thought this would point to the beginning of the array

我查看了很多关于C和链表的网站。我有书，但他们没有提供关于指针或结构的特定用法的足够细节。我已经尝试了一段时间，但我确信我错过了一些东西。

我只需要了解我出错的地方以及前进的方向。

感谢您的帮助。

以下是包含更多代码的重新发布内容：

//this should initialize array so that ptr contains all array elements
void initialize ( list array[] ) { 
int j;
for(j = 0; j < setSize - 1; j++){
array[j].next = array[j+1].next;  //using the & does not seem to work, so I don't use it
array[j].next = NULL;
}
ptr = &(array[0]);
}

后来我在我自己的malloc函数中使用它（这是发生seg错误的地方）

//this should allocate a new list cell in array
list* my_malloc () { 
list* temp; 
temp = ptr; 
if(ptr = 0) {printf("Empty!\n");  return;}
else{ //the next line creates the seg fault
ptr = (*ptr).next; 
}
return temp;
}

list* cell ( char n, list* next ) {
  list* x = my_malloc(); 
  x->value = n;
  return x;
  x->next = next;
  return x;
}

main ( void* argv, int argc ) {
  initialize(array);
  list* x = nil;
  char ch = a;
  int i;
  for ( i = 0; i < setSize; i++ )
    x = cell(ch,x); 
  for ( i = 0; i < 10; i++ ) {
    list* y = x->next;
    my_free(x);  //this is my own free function 
    x = y;
  };
  for ( i = 0; i < 10; i++ )
    x = cell(ch,x);
}

Answer 1

除了这一行之外，你所拥有的一切都非常接近：

ptr = sizeOf(buffer[j]);

我认为你的意思是sizeof？无论如何，该操作毫无意义（并且非法，因为您试图将整数分配给指针类型的变量）。您不需要分配任何内存，array的定义已经确实如此。

你的for循环确实存在问题 - 你将走到数组末尾的一个问题，这可能是造成你的分段错误的原因。它或者是你没有初始化j的事实，所以它可能正在访问它不应该访问的内存。我想你可能想要这样的东西：

for (j = 0; j < setSize - 1; j++) 
{
    array[j].next = &array[j+1];
}

编辑：您的段错误的原因是这一行：

if(ptr = 0) {printf("Empty!\n");  return;}

将 ptr设置为0。我想你想要==。另一点 - 你说“使用&似乎不起作用，所以我不使用它”。这可能意味着您的list结构声明不正确，或者至少以非标准方式声明。您应该展示更多的程序 - 似乎您对指针的工作方式有一些非常基本的误解。

Answer 2

sizeof不分配空间。如果您不想使用malloc，则必须在堆栈或存储全局变量的位置（可能是bss）分配空间。由于您可能会使用数组定义执行此操作，因此ptr = &buffer[j]将为您提供指向缓冲区的j元素的指针。我认为你的意思是“地址”而不是“sizeof”，在C中拼写为&。当然，buffer不是array。这可能是一个错字或非常错误。

无论如何，你的代码有点不正常。您可能想要做的是将指针初始化为array，然后遍历元素，然后设置：

ptr = array;
for (j = 0; j < setSize; j++)
    array[j].next = &array[j+1];
array[setSize - 1] = NULL; // The last element was set to a lie.

Answer 3

array[j].next = array[j+1].next;

由于数组[j + 1] .next未定义，因此无法正常工作。根据{{1}}的定义方式，您应该能够这样做：

buffer[i].next

Answer 4

我认为这就是你想要的：

#define ARRAY_LENGTH (20)

struct list
{
    char ch;
    struct list* next;
};

struct list array[ARRAY_LENGTH];   // array's memory is allocated with this, no need to use malloc
struct list* ptr = &(array[0]);    // ptr now points to the 1st item in the array
int j;                             // I'm declaring 'j' outside of the for loop just in case you are using c and not c++

for(j=0 ; j < ARRAY_LENGTH-1 ; j++)
    array[j].next = &(array[j+1]); // .next of jth item in array now points to the following item

array[j].next = NULL;              // assign .next of last item to NULL, so you know when you have reached the end of the array when traversing it.

请注意，for循环是针对（ARRAY_LENGTH - 1）项执行的，而不是ARRAY_LENGTH项，因为数组[j + 1]在最后一次迭代中将超出范围。

既然你有ptr指向数组中的第一项，你可以用以下内容遍历它：

struct list* curItem;  // this will be your iterator to traverse the array
curItem = ptr;         // initialize your iterator to point to the 1st item
while(curItem != NULL) // note that with this, you don't need to know the length of the array
{
    printf("Current item's .ch is %c\r\n", curItem->ch); // don't forget to include the header for printf
    curItem = curItem->next;
}

在不使用malloc的情况下将固定大小的对象分配给指针（指向结构）

4 个答案: