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_findout()之前

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

我建议原型，即：

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

...就在你上一个#include

之下

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

以下是使用这两种方法的代码（已更正）。方法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//
}

在某些圈子中，它被认为是 art ，不需要静态函数的原型，它表明程序是在代码编写之前计划在某个人的头脑中的。除了向那些仍然在学习C的基本要素的人推荐静态函数原型之外，我没有太多可说的方法。

如果要公开buddy_*以供其他模块使用，那么您确实需要原型。很难说你是否打算这些是静态的。

修改

如果要将原型放在外部头文件中，则需要使用 include guards 来确保每个模块只包含一次（并且不会将它们重新定义为精确的）同样的事情）。

以下是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;
// ...
}

冲突的退货类型

3 个答案: