Question

呼！很长的标题......这里有一些伪代码来解释这个词：

int main(){
int* ptr = function1(); //the data that ptr points to is correct here
function2(ptr);
}

int function2(int* ptr){
//the data that ptr points to is still correct
int i;
for(i=0;i<length;printf("%d\n", (*ptr)[i]), i++); //since ptr points to a contiguous block of memory
function3(ptr);
}

int function3(int* ptr){
//the data that ptr points to is INCORRECT!!!
}

为什么function3中的数据不正确？

注意：function1执行malloc（）并返回指向该内存的指针。

实际代码

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

//Structures
struct hash_table_data_
{
  int key, data;
  struct hash_table_data_ *next, *prev;
};

struct hash_table_
{
  int num_entries;
  struct hash_table_data_ **entries;
};

typedef struct hash_table_data_ hash_table_data;
typedef struct hash_table_ hash_table;

//Prototypes
hash_table *new_hash_table(int num_entries);
int hash_table_add(hash_table *ht, int key, int data);
int hash_table_loader(hash_table* ht);

//Main
int main()
{
  int num_entries = 8;//THIS MUST BE AUTOMATED

  hash_table* ht = new_hash_table(num_entries);
  hash_table_loader(ht);

  return 0;
}

//Function Definitions
hash_table *new_hash_table(int num_entries)
{
  hash_table* ht = (hash_table*) malloc(sizeof(hash_table));

  hash_table_data* array = malloc(num_entries * sizeof(hash_table_data));
  int i;
  for (i=0;i<num_entries;i++)
    {
      array[i].key = -1;
      array[i].data = -1;
      array[i].next = NULL;
      array[i].prev = NULL;
    }

  ht->entries = &array;
  ht->num_entries = num_entries;

  return ht;
}

int hash_table_add(hash_table *ht, int key, int data)
{
  //VERIFY THAT THE VALUE ISN'T ALREADY IN THE TABLE!!!!!!!!!!!
  int num_entries = ht->num_entries;
  hash_table_data* array = *(ht->entries); //array elements are the LL base
  int hash_val = key%num_entries;

  printf("adding an element now...\n");
  printf("current key: %d\n", array[hash_val].key);

  int i;
  for(i=0;i<num_entries;printf("%d\n", (*(ht->entries))[i].key),i++);//DATA IS INCORRECT!!!!

  if (array[hash_val].key == -1)//is this the base link?
    {
      printf("added a new base link!\n");
      array[hash_val].key = key;
      array[hash_val].data = data;
      array[hash_val].next = NULL;
      array[hash_val].prev = &(array[hash_val]);
    }
  else//since it's not the base link...do stuff
    {
      hash_table_data* new_link = malloc(sizeof(hash_table_data));
      new_link->key = key;//set the key value
      new_link->data = data;//set the data value
      if (array[hash_val].next == NULL)//we must have the second link
    {
      printf("added a new second link!\n");
      new_link->prev = &(array[hash_val]); //set the new link's previous to be the base link
      array[hash_val].next = new_link; //set the first link's next
    }
      else//we have the 3rd or greater link
    {
      printf("added a new 3rd or greater link!\n");
      hash_table_data next_link_val = *(array[hash_val].next);
      while (next_link_val.next != NULL)//follow the links until we reach the last link
        {
          next_link_val = *(next_link_val.next);//follow the current link to the next
        }
      //now that we've reached the last link, link it to the new_link
      next_link_val.next = new_link; //link the last link to the new link
      new_link->prev = &(next_link_val); //link the new link to the last link
    }
    }

  return 0;
}

int hash_table_loader(hash_table* ht)
{
  int i;
  for(i=0;i<(ht->num_entries);printf("%d\n", (*(ht->entries))[i].key),i++); //DATA IS STILL CORRECT HERE

  FILE *infile;
  infile = fopen("input.txt", "r");
  while(!feof(infile))
    {
      int key,data;
      fscanf(infile, "%d %d", &key, &data);
      hash_table_add(ht, key, data);
    }
  fclose(infile);
}

注意：第一次调用hash_table_add（）时会出现问题。

Answer 1

你的第一个问题是：

ht->entries = &array;

您使结构保持hash_table_data**，该hash_table_data* array指向函数本地的变量malloc();然后退出函数并返回指向结构的指针。结构仍然存在（它是通过array分配的，array指向的东西仍然存在，但hash_table_data*本身不存在。因此，结构中的这个指针现在无效。

据我所知，你没有理由在这里拿指针指针。只需使用array作为条目类型，并将{{1}}复制到该struct成员中。指针也是价值观。

Answer 2

我猜您迭代错误

for(i=0;i<length;printf("%d\n", (*ptr)[i]), i++);

这是胡说八道。

您应该将其重写为：

for(i=0;i<length;i++)
    printf("%d\n", ptr[i]);

(*ptr)[i]是错的，如果你考虑一下就没有意义。

*ptr是指向的int数组的第一个元素。 ptr[i]是i，这就是你需要的。

请仔细阅读Section 6。

基于这个问题的一些建议：

不要使用逗号运算符编写过于复杂的代码，例如此for语句，它只是很少需要并且不仅导致混淆，而且导致错误（尽管在此特定示例中没有错误）
仔细查看错误，不要责怪所有功能。如果您的代码不起作用，请尝试查找错误的确切位置并进行验证。在这个例子中，测试代码的人是对的：函数肯定不是错误的原因。

Answer 3

hash_table *new_hash_table(int num_entries)
{
    hash_table* ht = (hash_table*) malloc(sizeof(hash_table));

    hash_table_data* array = malloc(num_entries * sizeof(hash_table_data));

    // ....

    ht->entries = &array; // Problem

    // ...
    return ht;
} // Life time of array ends at this point.

您正在引用局部变量array并将其分配给ht->entries，该函数一旦返回就不再有效。

C - 将指针传递给函数，然后将函数内部的相同指针传递给另一个函数

3 个答案: