C 返回无相关参数的条件函数的函数

我想在C中定义一个函数master返回一个函数slave，其中slave受master的一些参数制约，这些参数不是slave的参数。。。这样的构造在C语言中可能吗

尽管以下代码无法工作（并且包含一个可怕的嵌套函数），但我还是希望本着以下精神做一些事情：

typedef int(*First_elem)(void*);

First_elem Master(type1* arg1, type2* arg2){

  int new_first(void* data){
     if (test1(arg1)){
       /* ... some code ... */
     }
     return some_integer_built_from_data_arg1_and_arg2;
  }

  return new_first;
}

我可以理解，我应该彻底反思我的算法方法，但有人知道这样的事情是否可能发生，否则，是什么让C不能处理这样的构造

---

对于希望了解完整背景的人，这里是：

typedef int(*First_elem)(void*);
typedef int(*Next_elem)(void*, void*);
typedef void(*Print_elem)(void*);
typedef int(*Filter)(void*);

typedef struct{
  void* current;
  void* previous;
  size_t size;
  int index;
  First_elem first;
  Next_elem next;
  Print_elem print;
}Iterator;

int initialize_iterator(Iterator* it, size_t size, First_elem first, Next_elem next, Print_elem print){
  it->size = size;
  if ((it->current=malloc(size)) == NULL){
    perror("Memory allocation error\n");
    return 0;
  }
  if ((it->previous=malloc(size)) == NULL){
    perror("Memory allocation error\n");
    return 0;
  }
  it->index=0;
  it->first=first;
  it->next=next;
  it->print=print;
  return 1;
}

void print_current_element(Iterator* it){
  it->print(it->current);
}

int iterator_next(Iterator* it){
  int ans;
  if (it->index == 0){
    if ((ans=it->first(it->current)))
      it->index++;
    return ans;
  }
  /* copy of current into previous */
  int i;
  for (i=0 ; i<it->size ; i++)
    ((char *)it->previous)[i] = ((char *)it->current)[i];
  if ((ans=it->next(it->previous, it->current)))
    it->index++;
  return ans;
}

void iterator_reroll(Iterator* it){
  it->index=0;
}

int iterator_cardinality(Iterator* it){
  int i, ans, last=it->index;
  iterator_reroll(it);
  while (iterator_next(it));
  ans = it->index;
  if (last != ans){
    iterator_reroll(it);
    for (i=0 ; i<last ; i++)
      iterator_next(it);
  }
  return ans;
}

First_elem first_cartesian_two(Iterator* it1, Iterator* it2){
  int new_first(void* first){
    int i;

    iterator_reroll(it1);
    iterator_reroll(it2);
    if ((iterator_next(it1)) && (iterator_next(it2))){
      /* Copy the concat of the two firsts into first */
      for (i=0 ; i<it1->size ; i++)
    ((char *)first)[i] = ((char *)it1->current)[i];
      for (i=0 ; i<it2->size ; i++)
    ((char *)first)[i+it1->size] = ((char *)it2->current)[i];
      return 1;
    }
    return 0;
  }
  return &new_first;
}

Next_elem next_cartesian_two(Iterator* it1, Iterator* it2){
  int new_next(void* previous, void* next){
    int i;
    /* copy of previous in previous of both iterator */
    for (i=0 ; i<it1->size ; i++)
      ((char *)it1->previous)[i] = ((char *)previous)[i];
    for (i=0 ; i<it2->size ; i++)
      ((char *)it2->previous)[i] = ((char *)previous)[i+it1->size];

    /* if we can iterate over the second iterator */
    if (iterator_next(it2)){
      for (i=0 ; i<it1->size ; i++)
    ((char *)next)[i] = ((char *)it1->current)[i];
      for (i=0 ; i<it2->size ; i++)
    ((char *)next)[i+it1->size] = ((char *)it2->current)[i];
      return 1;
    }
    /* We reroll the second, and we try to iterate over the first one */
    iterator_reroll(it2);
    if ((iterator_next(it2)) && (iterator_next(it1))){
      for (i=0 ; i<it1->size ; i++)
    ((char *)next)[i] = ((char *)it1->current)[i];
      for (i=0 ; i<it2->size ; i++)
    ((char *)next)[i+it1->size] = ((char *)it2->current)[i];    
      return 1;
    }
    /* The cartesian product is now over... */
    return 0;
  }
  return &new_next;
}

Print_elem print_cartesian_two(Iterator* it1, Iterator* it2){
  void new_print(void* elem){
    int i;

    /* Split elem and copy into the atoms */
    for (i=0 ; i<it1->size ; i++)
      ((char *)it1->current)[i] = ((char *)elem)[i];
    for (i=0 ; i<it2->size ; i++)
      ((char *)it2->current)[i] = ((char *)elem)[i+it1->size];
    print_current_element(it1);
    printf(" ");
    print_current_element(it2);    
  }
  return &new_print;
}

int iterator_cartesian_product_two(Iterator* result, Iterator* it1, Iterator* it2){
  size_t size=it1->size+it2->size;
  Next_elem next=next_cartesian_two(it1, it2);
  First_elem first=first_cartesian_two(it1, it2);
  Print_elem print=print_cartesian_two(it1, it2);
  /* void* test=malloc(sizeof(char)+sizeof(int)); */
  /* int a=12; */
  /* char c='a'; */
  /* int i; */
  /* /\* Copy the concat of the two firsts into first *\/ */
  /* for (i=0 ; i<it1->size ; i++) */
  /*   ((char *)test)[i] = ((char *)(&a))[i]; */
  /* for (i=0 ; i<it2->size ; i++) */
  /*   ((char *)test)[i+it1->size] = ((char *)(&c))[i]; */
  /* printf("foo"); printf("\n"); */
  /* print(test); printf("\n"); */
  iterator_reroll(it1);
  iterator_reroll(it2);  
  return initialize_iterator(result, size, first, next, print);
}

typedef int（*First_elem）（void*）；
typedef int（*下一个元素）（无效*，无效*）；
typedef void（*打印元素）（void*）；
typedef int（*过滤器）（无效*）；
类型定义结构{
无效*当前；
无效*先前；
大小；
整数指数；
第一要素优先；
下一个元素下一个；
打印元素打印；
}迭代器；
int initialize_iterator（iterator*it，size_t size，First_elem First，Next_elem Next，Print_elem Print）{
它->大小=大小；
如果（（it->current=malloc（size））==NULL）{
perror（“内存分配错误”）；
返回0；
}
如果（（it->previous=malloc（size））==NULL）{
perror（“内存分配错误”）；
返回0；
}
它->索引=0；
它->第一个=第一个；
it->next=next；
它->打印=打印；
返回1；
}
无效打印当前元素（迭代器*it）{
it->打印（it->当前）；
}
int迭代器_next（迭代器*it）{
INTANS；
如果（它->索引==0）{
如果（（ans=it->first（it->current）））
it->index++；
返回ans；
}
/*将当前文件复制到上一个文件中*/
int i；
对于（i=0；isize；i++）
（（char*）it->previous）[i]=（（char*）it->current）[i]；
如果（（ans=it->next（it->previous，it->current）））
it->index++；
返回ans；
}
无效迭代器_reroll（迭代器*it）{
它->索引=0；
}
int迭代器_基数（迭代器*it）{
int i，ans，last=it->index；
迭代器（it）；
while（迭代器_next（it））；
ans=它->索引；
如果（最后一个！=ans）{
迭代器（it）；
对于（i=0；i电流）[i]；
对于（i=0；isize；i++）
（（char*）first）[i+it1->size]=（（char*）it2->current）[i]；
返回1；
}
返回0；
}
首先返回和新建；
}
下一个元素下一个笛卡尔二（迭代器*it1，迭代器*it2）{
int new_next（void*previous，void*next）{
int i；
/*两个迭代器的previous中previous的副本*/
对于（i=0；isize；i++）
（（char*）it1->previous）[i]=（（char*）previous）[i]；
对于（i=0；isize；i++）
（（char*）it2->previous）[i]=（（char*）previous）[i+it1->size]；
/*如果我们可以迭代第二个迭代器*/
if（迭代器_next（it2））{
对于（i=0；isize；i++）
（（char*）next）[i]=（（char*）it1->current）[i]；
对于（i=0；isize；i++）
（（char*）next）[i+it1->size]=（（char*）it2->current）[i]；
返回1；
}
/*我们重新滚动第二个，并尝试迭代第一个*/
迭代器（it2）；
if（（迭代器下一步（it2））和&（迭代器下一步（it1）））{
对于（i=0；isize；i++）
（（char*）next）[i]=（（char*）it1->current）[i]；
对于（i=0；isize；i++）
（（char*）next）[i+it1->size]=（（char*）it2->current）[i]；
返回1；
}
/*笛卡尔积现在结束了*/
返回0；
}
返回并新建下一个；
}
Print_elem Print_cartesian_two（迭代器*it1，迭代器*it2）{
作废新打印（作废*元素）{
int i；
/*分裂元素并复制成原子*/
对于（i=0；isize；i++）
（（字符*）it1->current）[i]=（（字符*）元素）[i]；
对于（i=0；isize；i++）
（（字符*）it2->current）[i]=（（字符*）元素）[i+it1->size]；
打印当前元素（it1）；
printf（“”）；
打印当前元素（it2）；
}
返回并重新打印；
}
int迭代器笛卡尔积（迭代器*result，迭代器*it1，迭代器*it2）{
尺寸\u t尺寸=it1->尺寸+it2->尺寸；
Next_elem Next=Next_笛卡尔_two（it1，it2）；
第一元素第一=第一笛卡尔二（it1，it2）；
Print_elem Print=Print_cartesian_two（it1，it2）；
/*void*test=malloc（sizeof（char）+sizeof（int））*/
/*INTA=12*/
/*char c='a'*/
/*int i*/
/*/\*将两个first的concat复制到first*\/*/
/*对于（i=0；isize；i++）*/
/*（（字符*）测试）[i]=（（字符*）（&a））[i]*/
/*对于（i=0；isize；i++）*/
/*（（char*）测试）[i+it1->size]=（（char*）（&c））[i]*/
/*printf（“foo”）；printf（“n”）*/
/*打印（测试）；打印F（“\n”）*/
迭代器（it1）；
迭代器（it2）；
返回initialize_迭代器（结果、大小、第一个、下一个、打印）；
}

---

对不起，我的英语不好，提前谢谢你的建议/评论…

否；这是不可能的。C不允许函数嵌套，并且在调用函数时没有隐藏上下文（如C++中的

this

）

您可以通过将泛型迭代器混合到私有结构中来解决问题。例如

/* public header */
struct Iterator {
    ...
};

/* private implementation */
struct foo_iterator {
    struct Iterator it;
    size_t size;
    ...
}

struct Iterator* iterator_create(size_t size, ...)
{
    struct foo_iterator *it = calloc(1, sizeof *it);

    it->size = size;
    return &it->it;
}

Iterator* iterator_next(struct Iterator *it)
{
    struct foo_iterator *it = container_of(it, struct Iterator, it);

    ...
}

---

有关

container\u of（）

的实现，请参见例如以获取参考，这种类型的函数称为a，而C不支持闭包。还感谢这个指针，它允许我修正我的想法。我不知道这个结构有什么理论。