Question

如果我有一个功能

int foo() {
  /* stuff */
}

我想发送参数（尽管这是一个不好的做法）：

int main(void) {
    int arg1 = 3;
    int arg2 = 4;
    foo(arg1, arg2);
    return 0;
}

那么，我怎样才能引用arg1内的arg2和foo()参数？

Answer 1

int foo(int arg1, int arg2);出了什么问题？

如果您不确定要传递的参数数量，请查看variadic functions。

Answer 2

这不完全是您想要的，并且完全不可移植，但它说明了这一点原则。如果调用函数（在本例中为main）在堆栈上有其他变量，则可能必须调整偏移量并且偏移量将不同。当然，如果目标平台的堆栈朝另一个方向增长，则必须更改循环以倒数p。

#include <stdio.h>

int foo(void) {
        int *p;
        int a, b;
        int i;

        for (i = 0; i < 32; i++) {
                p = (&i + i);
                printf("i %d : p %p %d\n", i, p, *p);
        }
        a = *(&i + 11);
        b = *(&i + 10);
        printf("a %d\n", a);
        printf("b %d\n", b);
        return a + b;
}

int main(void) {
        int a = 8;
        int b = 2;

        foo();
        return 0;
}

为了记录，这种东西既有趣又有用。特别是，知道调试时间是非常宝贵的。所以我觉得问题很好。这并不意味着这种事情应该以任何“生产”代码结束。

Answer 3

您可以通过拥有全局状态和辅助函数来解决它：

static int foo_i, foo_j;
static void foo_setup(int i, int j) {
    foo_i = i; foo_j = j;
}

int foo() {
    return foo_i % foo_j;
}


int main() {
    foo_setup(10,40);
    printf("%d\n", foo());
}

要确定这是否适合您，您必须考虑此解决方案是不可重入的。如果您正在使用线程，则可能需要将调用同步到foo_setup和foo。同样，如果在调用foo_setup后不立即调用foo，则需要仔细设计代码，以便不使用代码调用foo_setup。

如果可以使用c ++，则可以通过构造函数传递参数，并为结构定义operator()方法。

Answer 4

感谢您的建议。我建议的解决方案的解决方案如下：

static int helper(int argc, ...) {
  unsigned *argv = (unsigned *) (void *)(&argc + 1);

  switch (argc) {
  case 0: /* do stuff */ 
  case 1: /* do stuff with argv[0] */
  case 2: /* do stuff with argv[0], argv[1] */
  ...
  case n: /* do stuff with argv[0], argv[1], ..., argv[n] */
  }
}

int goo(void) {
  return helper(0);
}

int bar(int arg1) {
  return helper(1, arg1);
}

int foo(int arg1, int arg2) {
  return helper(2, arg1, arg2);
}

int main(void) {
  int arg1 = 3;
  int arg2 = 4;
  return foo(arg1, arg2);
}

将参数发送到没有参数的函数

4 个答案: