返回类型冲突

Question

我正在做一个递归程序，并且收到有关冲突类型的错误：

void* buddyMalloc(int req_size)
{ 
     // Do something here
     return buddy_findout(original_index,req_size); // This is the recursive call
}

void *buddy_findout(int current_index,int req_size)
{
    char *selected = NULL;

    if(front!=NULL)
    {
        if(current_index==original_index)
        {
            // Do something here
            return selected;
        }
        else
        {
            // Do Something here
            return buddy_findout(current_index+1,req_size);
        }
    }
    else
    {
        return buddy_findout(current_index-1,req_size);
    }
}

错误：

buddy.c: At top level:
buddy.c:76: error: conflicting types for ‘buddy_findout’
buddy.c:72: note: previous implicit declaration of ‘buddy_findout’ was here

请注意我在其中定义的文件 buddy.c 不包含 main 并与其他几个 .c 文件链接。

Answer 1

如果没有原型，则无法在正确定义之前使用函数。 buddy_malloc() 在原型化或定义之前使用 buddy_findout()，编译器会将其视为定义。

在定义 buddy_Malloc() 之前创建 buddy_findout() 原型，或在定义 buddy_Malloc() 之前定义 buddy_findout() 。

我建议使用原型，即：

void *buddy_Malloc(int);
void *buddy_findout(int, int);

... 就在最后一个 #include 下面，

这可以避免您定义事物的顺序出现任何混乱。另外，在指定大小时，请考虑使用 size_t （架构上可用的最大无符号整数类型）而不是有符号整数。

这是使用这两种方法的代码（已更正）。方法 1 - 使用原型：

void *buddy_Malloc(int);
void *buddy_findout(int, int);

void* buddyMalloc(int req_size)
{ 
          //Do something here//
         return buddy_findout(original_index,req_size); //This is the recursive fn I call//
}

void *buddy_findout(int current_index,int req_size)
{
     char *selected = NULL;

     if(front!=NULL)
      {
            if(current_index==original_index)
            {
                    //Do something here//
                     return selected ; // 
             }
             else
             {
                 //Do Something here//
                 return buddy_findout(current_index+1,req_size);
              }
        }
       else
        {
                  return buddy_findout(current_index-1,req_size);
         }
}

而方法 2，只是重新排序：

void *buddy_findout(int current_index,int req_size)
{
     char *selected = NULL;

     if(front!=NULL)
      {
            if(current_index==original_index)
            {
                    //Do something here//
                     return selected ; // 
             }
             else
             {
                 //Do Something here//
                 return buddy_findout(current_index+1,req_size);
              }
        }
       else
        {
                  return buddy_findout(current_index-1,req_size);
         }
}

void* buddyMalloc(int req_size)
{ 
          //Do something here//
         return buddy_findout(original_index,req_size); //This is the recursive fn I call//
}

在某些圈子里，静态函数不需要原型被认为是一种艺术，这表明该程序是在在编写代码之前某人的头脑。无论哪种方式，我都没什么可说的，除了向那些仍在学习 C 的具体细节的人推荐静态函数的原型之外。

如果 buddy_* 将被暴露要使用其他模块，您确实需要原型。很难判断您是否希望这些是静态的。

编辑：

如果您将原型放入外部头文件中，则需要使用包含防护来确保每个模块仅包含它们一次（并且不会重新包含它们）将它们定义为完全相同的东西）。

下面是一个示例 buddy.h：

#ifndef BUDDY_H
#define BUDDY_H

void *buddy_Malloc(int);
void *buddy_findout(int, int);

#endif /* BUDDY_H */

然后，预处理器将阻止您的模块抛出该错误。

Answer 2

我想这一定是因为缺少原型。

添加函数原型

void *buddy_findout(int current_index,int req_size);

在函数buddyMalloc前

Answer 3

buddy_findout 被声明为返回一个指向 void 的指针，但在一个地方您试图返回 selected，它是一个指向 char 的指针。正如其他人已经指出的那样，您还需要 buddy_findout 的原型：

void *buddy_findout(int, int);

void *buddy_malloc(int req_size) { 
    return buddy_findout(original_index,req_size);
}

void *buddy_findout(int current_index, int req_size) {
// ...
    if (current_index == original_index)
        return (void *)selected;
// ...
}