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

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到该struct成员中.指针也是价值观.