当内联函数在C中作为参数传递时会发生什么？

今天我写了一些C代码，使用带有自定义比较器函数的快速排序对结构数组进行排序，以确定它们的顺序

起初，我编写它时调用了硬编码到quicksort函数中的comparator函数。然后我想也许将该函数作为参数传递给通用快速排序函数会更好

在我的原始代码中，我声明了comparator函数

inline

。在我的新代码中，我保留了

inline

声明，尽管这对我来说没有多大意义，因为函数是作为参数传递的。然而，编译器没有抱怨

我的问题是：

inline

声明在这里是否有任何影响，或者它仅仅是对编译器的一个被忽略的建议

原始代码：

typedef struct _CGRect {
    CGPoint origin;
    CGSize size;
} CGRect;

typedef enum _NSComparisonResult {
     NSOrderedAscending = -1,
     NSOrderedSame,
     NSOrderedDescending
} NSComparisonResult;

static inline NSComparisonResult CGRectCompareRowsFirst(CGRect r1, CGRect r2)
{
    if (r1.origin.y < r2.origin.y)
        return NSOrderedAscending;
    else if (r1.origin.y > r2.origin.y)
        return NSOrderedDescending;
    else
    {
        if (r1.origin.x < r2.origin.x)
            return NSOrderedAscending;
        else if (r1.origin.x > r2.origin.x)
            return NSOrderedDescending;
        else
            return NSOrderedSame;
    }
}

static void CGRectQuicksortRowsFirst(CGRect *left, CGRect *right)
{
    if (right > left) {
        CGRect pivot = left[(right-left)/2];
        CGRect *r = right, *l = left;
        do {
            while (CGRectCompareRowsFirst(*l, pivot) == NSOrderedAscending) l++;
            while (CGRectCompareRowsFirst(*r, pivot) == NSOrderedDescending) r--;
            if (l <= r) {
                CGRect t = *l;
                *l++ = *r;
                *r-- = t;
            }
        } while (l <= r);
        CGRectQuicksortRowsFirst(left, r);
        CGRectQuicksortRowsFirst(l, right);
    }
}

static void CGRectSortRowsFirst(CGRect *array, int length)
{
    CGRectQuicksortRowsFirst(array, array+length-1);
}

static inline NSComparisonResult CGRectCompareRowsFirst(const void *s1, const void *s2)
{
    CGRect r1 = *(CGRect *)s1, r2 = *(CGRect *)s2;

    if (r1.origin.y < r2.origin.y)
        return NSOrderedAscending;
    else if (r1.origin.y > r2.origin.y)
        return NSOrderedDescending;
    else
    {
        if (r1.origin.x < r2.origin.x)
            return NSOrderedAscending;
        else if (r1.origin.x > r2.origin.x)
            return NSOrderedDescending;
        else
            return NSOrderedSame;
    }
}

static void quick(CGRect *left, CGRect *right, NSComparisonResult(*f)(const void *, const void *))
{
    if (right > left) {
        CGRect pivot = left[(right-left)/2];
        CGRect *r = right, *l = left;
        do {
            while (f(&*l, &pivot) == NSOrderedAscending) l++;
            while (f(&*r, &pivot) == NSOrderedDescending) r--;
            if (l <= r) {
                CGRect t = *l;
                *l++ = *r;
                *r-- = t;
            }
        } while (l <= r);
        quick(left, r, f);
        quick(l, right, f);
    }
}

static void CGRectSortRowsFirst(CGRect *array, int length)
{
    quick(array, array+length-1, CGRectCompareRowsFirst);
}

typedef结构\u CGRect{
点源；
cg大小；
}CGRect；
typedef枚举\u比较结果{
去感知=-1，
删除名称，
下移
}比较结果；
静态内联NSComparisonResult CGRectCompareRowsFirst（CGRect r1，CGRect r2）
{
if（r1.原点yr2.origin.y）
退而求其次；
其他的
{
if（r1.origin.xr2.origin.x）
退而求其次；
其他的
返回指定名称；
}
}
静态无效CGRect QuickSortRowsFirst（CGRect*左，CGRect*右）
{
如果（右>左）{
CGRect轴=左[（右-左）/2]；
CGRect*r=右，*l=左；
做{
而（CGRectCompareRowsFirst（*l，pivot）=传感器去感知）l++；
而（CGRectCompareRowsFirst（*r，pivot）=传感器下移）r--；
如果（l r2.origin.x）
退而求其次；
其他的
返回指定名称；
}
}
静态void quick（CGRect*左，CGRect*右，NSComparisonResult（*f）（const void*，const void*））
{
如果（右>左）{
CGRect轴=左[（右-左）/2]；
CGRect*r=右，*l=左；
做{
而（f（&*l，&pivot）==sensorderescending）l++；
而（f（&*r，&pivot）==r下移）r--；
if（lInline）只是对编译器的建议，可以忽略。发生这种情况的原因有几个，例如函数太复杂，无法安全内联。如果将其作为参数传递给上述函数，编译器将创建非内联版本，其地址将传递给函数

编译器可能仍然可以内联函数——例如，在代码生成过程中，编译器可以利用内联函数提示，通过一个只指向扩展函数的函数指针替换调用；我不确定当前的编译器是否会这样做

内联版本和非内联版本可以并且经常在一个编译程序中共存。
内联关键字只是一个编译器标志，告诉它以不同的方式处理它，因为它将复制函数体并用实际的函数调用替换它。如果您有一个可重用的小函数，这将提高性能在代码中的许多位置。与访问器和修饰符一起使用是一件很好的事情。在您的情况下，我认为您可以保持原样。您没有做任何繁重的事情。差异很可能不会明显。
为什么不使用标准库
qsort（）
function？它可能与手工编写的函数一样快，如果不是更快的话，尤其是如果你将比较器函数传递给你的函数。它也更可能没有bug。你是对的，至少可能比我的新代码快。我想我的问题应该是“如果我将一个内联函数传递给qsort（），会发生什么情况？”再看看我的问题。我知道
inline
的作用——我只是想知道将一个内联函数作为参数传递给另一个函数有多大意义。