宏和函数同名

发布于 2024-08-16 02:26:36 字数 657 浏览 2 评论 0原文

我有以下代码,

#define myfunc(a,b) myfunc(do_a(a), do_b(b))

void myfunc(int a, int b)
{
  do_blah(a,b);
}
int main()
{
    int x = 6, y = 7;
    myfunc(x,y);

    return 0;
}

我希望预处理器仅在调用时扩展函数 myfunc。预处理后所需的代码如下所示:

void myfunc(int a, int b)
{
  do_blah(a,b);
}
int main()
{
    int x = 6, y = 7;
    myfunc(do_a(x),do_b(y));

    return 0;
}

问题是函数定义也像这样展开

void myfunc(do_a(int a), do_b(int b))
{
  do_blah(a,b);
}

有没有办法使宏仅在我们展开函数调用时展开? 我尝试了很多解决方案,这似乎不可能,但我希望有人看到这样的情况..

注意:请不要告诉我重命名宏或函数名称:D

Update1: 谢谢你的帮助。但我只能改变宏的定义,不能改变它的位置,也不能改变函数的实现。

I have the following code

#define myfunc(a,b) myfunc(do_a(a), do_b(b))

void myfunc(int a, int b)
{
  do_blah(a,b);
}
int main()
{
    int x = 6, y = 7;
    myfunc(x,y);

    return 0;
}

I want the pre-processor to expand function myfunc only at calling. Required code after pre-processing looks like this:

void myfunc(int a, int b)
{
  do_blah(a,b);
}
int main()
{
    int x = 6, y = 7;
    myfunc(do_a(x),do_b(y));

    return 0;
}

The problem is that function definition is expanded also like this

void myfunc(do_a(int a), do_b(int b))
{
  do_blah(a,b);
}

Is there any way to make macro expands only if we are expanding a function call?
I tried many solutions, and it seems impossible but I hope that some one saw situation like this..

NOTE: please don't tell me to rename the macro or function names :D

Update1:
Thanks for you help. But I can only change the definition of the macro, I can't change its position and I can't change function implementation.

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

扫码二维码加入Web技术交流群

发布评论

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

评论(4

不回头走下去 2024-08-23 02:26:37

函数定义之后定义宏。

void myfunc(int a, int b)
{
  do_blah(a,b);
}

#define myfunc(a,b) myfunc(do_a(a), do_b(b))

int main()
{
    int x = 6, y = 7;
    myfunc(x,y);

    return 0;
}

Define the macro after the defintion of the function.

void myfunc(int a, int b)
{
  do_blah(a,b);
}

#define myfunc(a,b) myfunc(do_a(a), do_b(b))

int main()
{
    int x = 6, y = 7;
    myfunc(x,y);

    return 0;
}
沒落の蓅哖 2024-08-23 02:26:37

定义函数后定义宏。

或者,使用如下模式:

#define myfunc_macro(a,b) myfunc(do_a(a), do_b(b))
#define myfunc(a,b) myfunc_macro(a,b)

.
.

#undef myfunc
void myfunc(int a, int b)
{
  do_blah(a,b);
}
#define myfunc(a,b) myfunc_macro(a,b)

.
.

int main()
{
    int x = 6, y = 7;
    myfunc(x,y);

    return 0;
}

Define the macro after you define the function.

Alternatively, use a pattern like this:

#define myfunc_macro(a,b) myfunc(do_a(a), do_b(b))
#define myfunc(a,b) myfunc_macro(a,b)

.
.

#undef myfunc
void myfunc(int a, int b)
{
  do_blah(a,b);
}
#define myfunc(a,b) myfunc_macro(a,b)

.
.

int main()
{
    int x = 6, y = 7;
    myfunc(x,y);

    return 0;
}
你怎么敢 2024-08-23 02:26:36

使用 () 阻止预处理器扩展函数定义:

#include <stdio.h>

#define myfunc(a, b) myfunc(do_a(a), do_b(b))
/* if you have a preprocessor that may be non-standard
 * and enter a loop for the previous definition, define
 * myfunc with an extra set of parenthesis:
#define myfunc(a, b) (myfunc)(do_a(a), do_b(b))
 ******** */

int (myfunc)(int a, int b) /* myfunc does not get expanded here */
{
    printf("a=%d; b=%d\n", a, b);
    return 0;
}

int do_a(int a)
{
    return a * 2;
}

int do_b(int b)
{
    return b - 5;
}

int main(void)
{
    myfunc(4, 0);
    return 0;
}

Use () to stop the preprocessor from expanding the function definition:

#include <stdio.h>

#define myfunc(a, b) myfunc(do_a(a), do_b(b))
/* if you have a preprocessor that may be non-standard
 * and enter a loop for the previous definition, define
 * myfunc with an extra set of parenthesis:
#define myfunc(a, b) (myfunc)(do_a(a), do_b(b))
 ******** */

int (myfunc)(int a, int b) /* myfunc does not get expanded here */
{
    printf("a=%d; b=%d\n", a, b);
    return 0;
}

int do_a(int a)
{
    return a * 2;
}

int do_b(int b)
{
    return b - 5;
}

int main(void)
{
    myfunc(4, 0);
    return 0;
}
这样的小城市 2024-08-23 02:26:36

我看到三种可能的解决方案:

  • 在函数定义之后定义宏。

  • 在函数定义之前定义do_a()do_b(),以便它们返回它们的参数,并在函数定义之后根据您的意愿重新定义它们

  • 执行 <函数内的 code>do_a() 和 do_b()

    void myfunc(int a, int b)
    {
        do_blah(do_a(a),do_b(b));
    }
    

我非常倾向于后者。

I see three possible solutions:

  • define your macro after function definition.

  • define, before the function definition, do_a() and do_b() such that they return their argument, and redefine them at your will after function definition

  • perform do_a() and do_b() inside the function:

    void myfunc(int a, int b)
    {
        do_blah(do_a(a),do_b(b));
    }
    

I have a strong preference for the latter.

~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文