C 中的可移植嵌套函数

是否可以使用嵌套函数/块编写可移植的 C 代码？

我知道 gcc 仅支持嵌套函数作为非标准扩展，而 clang 仅支持块 - 但有没有办法编写可以使用标准 C 和 MACROS 来编译的代码？

如果不可能——最好的解决办法是什么？举个例子，如何实现以下带有参数的可移植版本？ GCC 中的简单示例：

int main(int argc, char*[] argv)
{
  char reverse = 0;

  int cmp_func(const void *a, const void *b)
  {
    const int* aa = (const int)a;
    const int* bb = (const int)b;
    return (reverse) ? aa - bb : bb - aa;
  }

  int list[8] = {1,2,3,4,5,20,100,200};
  qsort(list, 8, sizeof(int), &cmp_func);
}

可以使用 Clang 中的块来组合类似的示例。理想情况下，解决方案应该是线程安全的（因此避免全局变量）。

Edit:为了清楚起见，我们假设“标准”是指 C99。上面是一个简单的例子。我所追求的是 C99 方法来进行需要一些参数的排序。这里它只使用 char 作为布尔值，但我正在寻找一个需要多个整数等的解决方案。看起来如果没有全局变量，这可能是不可能的。

Edit 2:我意识到，将 void 指针与函数指针一起传递使您能够执行嵌套函数可以完成的所有操作。感谢@Quuxplusone 的建议qsort_r and qsort_s。我尝试将便携式包装纸放在一起qsort_r and qsort_s。它需要一个比较器函数和一个 void 指针来存储状态，从而消除了对复杂排序算法的嵌套函数的依赖——因此您可以使用 GCC 和 Clang 进行编译。

typedef struct
{
  void *arg;
  int (*compar)(const void *a1, const void *a2, void *aarg);
} SortStruct;

int cmp_switch(void *s, const void *aa, const void *bb)
{
  SortStruct *ss = (SortStruct*)s;
  return (ss->compar)(aa, bb, ss->arg);
}

void sort_r(void *base, size_t nel, size_t width,
            int (*compar)(const void *a1, const void *a2, void *aarg), void *arg)
{
  #if (defined _GNU_SOURCE || defined __GNU__ || defined __linux__)

    qsort_r(base, nel, width, compar, arg);

  #elif (defined __APPLE__ || defined __MACH__ || defined __DARWIN__ || \
         defined __FREEBSD__ || defined __BSD__ || \
         defined OpenBSD3_1 || defined OpenBSD3_9)

    SortStruct tmp = {arg, compar};
    qsort_r(base, nel, width, &tmp, &cmp_switch);

  #elif (defined _WIN32 || defined _WIN64 || defined __WINDOWS__)

    SortStruct tmp = {arg, compar};
    qsort_s(*base, nel, width, &cmp_switch, &tmp);

  #else
    #error Cannot detect operating system
  #endif
}

注意：我尚未在许多平台上对此进行测试，因此如果您发现错误/这在您的计算机上不起作用，请告诉我。

作为使用示例，我实现了与所选答案中相同的排序：

int sort_r_cmp(const void *aa, const void *bb, void *arg)
{
  const int *a = aa, *b = bb, *p = arg;
  int cmp = *a - *b;
  int inv_start = p[0], inv_end = p[1];
  char norm = (*a < inv_start || *a > inv_end || *b < inv_start || *b > inv_end);

  return norm ? cmp : -cmp;
}

int arr[18] = {1, 5, 28, 4, 3, 2, 10, 20, 18, 25, 21, 29, 34, 35, 14, 100, 27, 19};
int p[] = {20, 30};
sort_r(arr, 18, sizeof(int), sort_r_cmp, p);

只是为了好玩（并回答最初的问题），是的，完全可以使用宏系统在符合标准的 C99 中编写嵌套函数来“解开”代码的嵌套版本。这是一种可能的实现：https://github.com/Leushenko/C99-Lambda

有了它，你可以写出这样的令人厌恶的东西：

typedef int(* fptr)(int);
func(fptr, someFunc, (void) {
    return fn(int, (int a), {
        fptr f = fn(int, (int b), { return b * 6; });
        return a * f(a + 1);
    });
})

让我们成为very但清楚一些事情：这就是绝对最差如果您发现自己实际上需要使用宏库来编写这样的代码，请辞去程序员的工作并成为一名农民。在生产中使用它，你的同事可能会在睡梦中谋杀你。

另外，有趣的是，尽管它在技术上符合标准，但唯一具有可以处理如此多宏的预处理器的编译器是 GCC 和 Clang。