在 C/C++ 中将一个函数的当前状态传递给另一个函数

发布于 2024-08-20 10:04:31 字数 475 浏览 8 评论 0原文

在 C/C++ 中，有没有办法将一个函数的当前状态传递给另一个函数？我的意思是当前状态的所有参数和局部变量。例如：

void funcA (int a, int b)
{
    char c;
    int d, e;
    // Do something with the variables.
    // ...
    funcB();
    // Do something more.
}

void funcB()
{
    // funcB() should be able to access variables a,b,c,d & e
    // and any change in these variables reflect into funcA().
}

如果需要 funcB() 类型的函数，则代码的形状很糟糕。但能实现吗？

如果有人开始重构具有多个参数的长方法，这会有所帮助。

原文

Is there a way to pass the current state of a function into another function in C/C++? I mean all the parameters and local variables by current state. For example:

void funcA (int a, int b)
{
    char c;
    int d, e;
    // Do something with the variables.
    // ...
    funcB();
    // Do something more.
}

void funcB()
{
    // funcB() should be able to access variables a,b,c,d & e
    // and any change in these variables reflect into funcA().
}

The code is in bad shape if there is a need for funcB() kind of functions. But can it be achieved?

This can help if someone is starting to re-factor a long method with multiple parameters.

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

云淡月浅 2024-08-27 10:04:31

引入一个通用的结构体。

struct State {
    char c;
    int d,e;
};

void funcA(int a, int b){
    State s;
    s.d = 1234; // ...
    // ...
    funcB(s);
}

void funcB(State& s)
{
    //...
}

Introduce a common struct.

struct State {
    char c;
    int d,e;
};

void funcA(int a, int b){
    State s;
    s.d = 1234; // ...
    // ...
    funcB(s);
}

void funcB(State& s)
{
    //...
}

回复收藏 0 原文

余生共白头 2024-08-27 10:04:31

gcc 支持类似 Pascal 的 C 扩展，即嵌套函数，例如

#include <stdio.h>

int main(void)
{
    int a = 1, b = 2;

    void foo(void)
    {
        printf("%s: a = %d, b = %d\n", __FUNCTION__, a, b);
    }

    printf("%s: a = %d, b = %d\n", __FUNCTION__, a, b);

    foo();

    return 0;
}

使用 --nested-functions 编译它：

$ gcc -Wall --nested-functions nested.c -o nested

然后运行它：

$./nested
main: a = 1, b = 2
foo: a = 1, b = 2

当然这是不可移植的，但如果您只使用 gcc 并且您有太多遗留代码重写的话这可能是一个很好的解决方案。

gcc supports a Pascal-like extension to C, namely nested functions, e.g.

#include <stdio.h>

int main(void)
{
    int a = 1, b = 2;

    void foo(void)
    {
        printf("%s: a = %d, b = %d\n", __FUNCTION__, a, b);
    }

    printf("%s: a = %d, b = %d\n", __FUNCTION__, a, b);

    foo();

    return 0;
}

Compile this with --nested-functions:

$ gcc -Wall --nested-functions nested.c -o nested

and then run it:

$./nested
main: a = 1, b = 2
foo: a = 1, b = 2

Of course this is non-portable but if you are only using gcc and you have too much legacy code to re-write then this might be a good solution.

回复收藏 0 原文

你如我软肋 2024-08-27 10:04:31

另一种可能比第一种更优雅。它使用带有静态成员的结构。

struct SomeAlgo {
    SomeAlgo()
    : c(0), d(0), e(0) // Initialize common variables
    { }
    void funcA(int a,int b)
    {
        c = 1234; //...
        // ...
        funcB();

    }
    void funcB() // You may put it in the private section.
    {
        // Simply use c,d,e here.
    }
private:
    char c;
    int d,e;
};

用法

SomeAlgo alg;
alg.funcA(3,4);

编辑：使成员不是静态的。这样更好。

Another one that may be more elegant than the first. It uses a struct with static members.

struct SomeAlgo {
    SomeAlgo()
    : c(0), d(0), e(0) // Initialize common variables
    { }
    void funcA(int a,int b)
    {
        c = 1234; //...
        // ...
        funcB();

    }
    void funcB() // You may put it in the private section.
    {
        // Simply use c,d,e here.
    }
private:
    char c;
    int d,e;
};

Usage

SomeAlgo alg;
alg.funcA(3,4);

EDITED: Made members not static. Better that way.

回复收藏 0 原文

女皇必胜 2024-08-27 10:04:31

创建一个结构来保存您关心的所有状态。

根据结构体编写这两个函数；也就是说，它们将结构体的实例作为唯一参数，并且所有状态都保存在结构体中。

struct foo {  int d; int e; char c ; } fooinstance;

void afunc( struct foo fi);
void bfunc( struct foo fi);

void afunc( struct foo fi ) {
  // do stuff with fi
  f1.d += fi.e ;
  fi.c++;
  // call b
  b(fi);
}

然后将结构实例从 a 传递到 b。更有效的方法是将指针传递给结构体，但传递结构体也可以。

Create a struct to hold all the state you care about.

Write both functions in in terms of the struct; that is, they take as their only parameter an instance of the struct, and all state is saved in the struct.

struct foo {  int d; int e; char c ; } fooinstance;

void afunc( struct foo fi);
void bfunc( struct foo fi);

void afunc( struct foo fi ) {
  // do stuff with fi
  f1.d += fi.e ;
  fi.c++;
  // call b
  b(fi);
}

Then pass the struct instance from a to b. More efficient would be to pass a pointer to the struct, but passing the struct will work.

回复收藏 0 原文