Question

我正在尝试从函数返回一个Tuple结构，但它似乎没有更新指向它的指针。

例如，如果我在返回之前查看Tuple的值，我会发现它已正确分配：

342        Tuple *t = create_tuple();
(gdb) 
345        memcpy(t->part1, cwd, i + 1);
(gdb) p t
$5 = (Tuple *) 0x605010
(gdb) n
346        memcpy(t->part2, &cwd[i + 1], cwd_len - i - 1);
(gdb) 
348        return t;

但是在分配之后它看起来像我分配给它的元组指针仍为NULL：

291              if ((partitioned = split_prefix(cwd, strlen(cwd))) == NULL)
(gdb) p partitioned
$11 = (Tuple *) 0x0
(gdb) n
296              memcpy(name_field, partitioned->part1, strlen(partitioned- 
>part1));
(gdb) p partitioned
$12 = (Tuple *) 0x0

我认为，因为我返回的指针不是NULL，所以应该没问题，所以我对如何在调用之前和之后使用NULL指针感到困惑。也许我错误地初始化了指针？

这是struct指针返回的函数：

// gets name field and returns TRUE if successful, otherwise FALSE
int get_name_field(Tuple *partitioned, char name_field[], char *fname, char *cwd, int cwd_len)
{
   // fname cannot be broken up
   if (strlen(fname) > 155)
   {
      perror(fname);
      return FALSE;
   }
   // there is a path (prefix)
   else if (cwd)
   {
      // fname field isn't long enough
      if (strlen(cwd) + 1 + strlen(fname) > 100)
      {
         // ***********assignment here**************
         if ((partitioned = split_prefix(cwd, strlen(cwd))) == NULL)
         {
            perror("partition failed");
            return FALSE;
         }
         memcpy(name_field, partitioned->part1, strlen(partitioned->part1));
      }
...

返回Tuple指针的函数：

// return a the part of prefix that fits in name field, and the remainder
// if no delimiter is found, returns null
Tuple *split_prefix(char *cwd, int cwd_len)
{
   // find last '/' delimiter that is within NAME_LEN range 
   int found = 0;
   int i = cwd_len <= 100 ? cwd_len - 1: NAME_LEN;
   for (; i > -1; i--)
   {
      if (cwd[i] == '/')
      {
         found = TRUE;
         break;
      }
   }

   // no delimiter found 
   if (!found)
   {
      return NULL;
   }
   // too long to be stored in overflow
   else if (cwd_len - i > PREFIX_LEN)
   {
      return NULL;
   }

   // **********Tuple created here************
   Tuple *t = create_tuple();

   // make partitions
   memcpy(t->part1, cwd, i + 1);
   memcpy(t->part2, &cwd[i + 1], cwd_len - i - 1);

   return t;
}

Tuple的定义：

#define NAME_LEN 100
#define PREFIX_LEN 155

// holds partioned strings of prefix
typedef struct Tuple
{
   char part1[NAME_LEN];
   char part2[PREFIX_LEN];
} Tuple;

创建元组：

// create a tuple with default values
Tuple *create_tuple(void)
{
   Tuple *t = malloc(sizeof(Tuple));
   memset(t->part1, '\0', NAME_LEN);
   memset(t->part2, '\0', PREFIX_LEN);

   return t;
}

编辑：调用get_name_field的函数：

void test_get_name_field3(void)
{
   Tuple *partitioned = NULL;
   char name_field[NAME_LEN] = {'\0'};
   char *fname = "hellobutunfortunatelythiswon'tfit.txt";
   char *cwd = "user/bin/arafian/ratherlongdirectorynameandwillnot/fitin"
               "thenamefieldonlysoitwilloverflowtotheprefixfield";
   int cwd_len = strlen(cwd);

   get_name_field(partitioned, name_field, fname, cwd, cwd_len);
   char *result = "user/bin/arafian/ratherlongdirectorynameandwillnot/";
   checkit_string(name_field, result);
   free(partitioned);
}

Answer 1

如果要通过参数向函数返回指针，则该函数必须为参数采用双指针。即int get_name_field(Tuple **partition, ...) {并调用get_name_field(&partition, ...)。

这与我最近在这里回答的https://stackoverflow.com/a/50261485/982257以及其他几个问题完全相同。

即使在赋值

1 个答案: