如何在 C 中的两个函数之间共享一个变量？

Question

在C语言中，假设var1是foo1()中的一个变量，foo2()想访问var1，但是foo1()没有调用foo2()，所以我们不能通过参数传递。同时，只有 foo1() 和 foo2() 会访问它，所以我不想将它声明为全局变量。与c++中的“朋友语义”类似，有什么方法可以在C中实现吗？

void foo1() {
  ... 
  var1;
  ....
}


void foo2() {
 ...
 how to access var1?
 ...
}

Answer 1

你将变量传递给两个函数....一般函数不应该保持状态。

很快你就会发现传递变量不是很好并且变得脆弱，所以你传递结构......然后函数开始处理结构的状态。

typedef struct 
{
    int var1;
} blah_t;

void foo1(blah_t* b)
{
    b->var1=0;
}

void foo2(blah_t* b)
{
    b->var1++;
}

这是做 OO C 背后非常简单的种子想法。

Answer 2

您需要在函数范围之外声明var1，然后将其作为参数发送给两者。或者，将其声明为全局变量。

Answer 3

通过引用是一种方式：（在此示例中，i 的内存是 caller() 的本地内存）

void caller()
{
    int i = 5;
    foo(&i);
    bar(&i);
    printf("\n final i is %d",i);
}

void foo(int *i)
{
    printf("%d",*i);
    *i += 5;
}

void bar (int *i)
{
    printf("%d",*i);
    *i += 5;
}

全局：（通常被认为是可怕的i 的名字更像GLOBAL_I 或其他东西）

int i = 0;

void caller()
{
   i=5;
   foo();
   bar();
   printf("\n final i is %d",i);
}

void foo()
{
   printf("%d",i);
   i += 5;
}

 void bar (int i)
 {
      printf("%d",i);
      i += 5;
 }

Answer 4

关于类似于c++中的“朋友语义”。 C 没有相同的能力。
关于所以我们不能通过参数传递它

C 中的唯一选项是在不作为函数参数传递的情况下从一个函数访问一个函数到另一个函数，即使用某种类型的全局范围变量。

如果void foo1() 和void foo2() 存在于不同的C 模块中...
但是您仍然希望能够访问相同的变量，并确保其值始终在项目中的所有位置都相同，然后考虑使用extern scope：

在两个（多个）模块通用的头文件中，项目范围全局可以如下实现。

file.h

void foo1(void);
void foo2(void);
extern int var1;  

file1.c

#include "file.h"
int var1 = 5; //in only 1 module, declare and initialize the 
              //extern defined in the common header -file.h-

int main(void)
{
    printf("value of var1 is %d\n", var1);//original value of var1
    foo1();
    printf("value of var1 is %d\n", var1);//var1 modified by foo1()
    foo2();
    printf("value of var1 is %d\n", var1);//var1 modified by foo2()
    return 0;
}

void foo1(void)
{
    var1 = 15;//Now that the project global variable
              //has already been declared and defined, it can simply
              //be used, in this file...   
}

file2.c

#include "file.h"

void foo2(void)
{
    var1 = 20;... and in this one
}

Answer 5

没有。该变量仅在 foo1() 运行时存在于函数堆栈中。离开函数时堆栈将消失。您可以将变量设置为静态以使其保持活动状态，但是如果没有 hack，您也无法从外部访问它。

Answer 6

这个答案的灵感来自许多其他语言中的“模块”概念，可以使用 gcc 的嵌套函数来近似。变量var1 在foo1() 和foo2() 的范围内，但不在其他所有范围内。该解决方案既不使用全局变量也不使用参数。

void foo(int fn)
{
    static int var1;

    void fn1(void)
    {
        var1 = 15;
    }

    void fn2(void)
    {
        var1 = 20;
    }

    (fn == 1)? fn1(): fn2();
    printf("Value of var1 is now %d\n", var1);
}

void foo1(void){foo(1);}
void foo2(void){foo(2);}

int main (void)
{
    foo1();
    // Expected stdout: Value of var1 is now 15

    foo2();
    // Expected stdout: Value of var1 is now 20
}