Question

假设我有这样的功能：

static int init_processing(char *buf, FILE *stream, enum operationMode mode) {
    /* save index of `stream' in current operations */
    /* start processing */
    /* save some important variables for continue_processing */
    off_t position;
    enum operationMode _mode;
    return num_processing_operations_left;
}

..偶尔会打电话给我。我还有另一个函数来完成我想要的实际处理：

static int continue_processing(FILE *stream) {
    /* lookup the index of `stream' in current operations */
    /* do some stuff */
    /* save some static variables */
    static off_t left = position;
    static void *some_ptr;
    return --num_processing_operations_left;
}

我还有一个清洁功能，可以在完成某项操作时调用：

static int end_processing(FILE *stream) {
    /* check */
    if (num_processing_operations_left)
        return 1;
    /* clean everything */
    return 0;
}

正如您所看到的，这种相关的函数技术非常熟悉它被标准库本身使用（例如[ malloc ， free ， realloc < / i>]，[ fdopen ， fopen ， fclose ]）。

我想在这里实现的是如何在一堆函数中共享一些变量？我想到了两个解决方案：

将每组函数放在自己的文件中，提供仅对文件本身有效的静态变量。

只使用一个将额外的枚举参数作为模式的函数，并相应地构造函数。

但是这些解决方案实际上不是解决方案，它们只是解决问题的解决方法。那么，是否有任何标准技术可以在函数之间共享变量？

Answer 1

创建一个保持所需的上下文结构：

struct Context
{
  FILE * stream;
  off_t position;
  unsigned num_processing_operations_left;
  /* define some more important variables */
}

并将其传递给所有相关函数：

static int init_processing(struct Context * pctx, char *buf, enum operationMode mode);
static int continue_processing(struct Context * pctx);
static int end_processing(struct Context * pctx);

int main(void)
{
  struct Context ctx = {0};

  /* init ctx here */

  int result = init_processing(&ctx, ...);

  ...

  result = continue_processing(&ctx);

  ...

  result = end_processing(&ctx);

  ...
}

在函数内部共享变量

1 个答案: