主页 / 问题 / 1578549
Accepted
borg
Asked:2024-05-01 23:07:28 +0000 UTC2024-05-01 23:07:28 +0000 UTC

如何将函数应用于每个宏参数？

  • 772

我想得到这种行为，以便每个宏参数都包含在一些代码中。例如，打印每个参数：

#define print_all(...) /* magic */

print_all(1, 2, "123"); // calls std::cout << 1; std::cout << 2; std::cout << "123";
c++

2 个回答

  1. 在 C++ 中，无需宏即可完成此操作：

    #include <iostream>

struct A {
    A(int x) : x(x) { std::cout << "cons a\n"; }
    A(const A& a) : x(a.x) { std::cout << "copy cons a\n"; }
    int x;
};

std::ostream &operator <<(std::ostream &os, const A &a) {
    return os << a.x;
}

void print_all() {}

template<typename Type, typename... Types>
void print_all(Type&& arg, Types&&... args) {
    std::cout << std::forward<Type>(arg);
    print_all(std::forward<Types>(args)...);
}

int main() {
    A a(42);
    print_all(1, 2, "123", a);
}

    不调用复制构造函数并且不存在递归：

    $ g++ -std=c++17 -pedantic -Wall -Wextra -Werror -Wwrite-strings -Wconversion temp.cpp 

$ ./a.out
cons a
1212342

        ...
    movl    $.LC0, %esi
    movl    $_ZSt4cout, %edi
    call    _ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc
    movl    $1, %esi
    movl    $_ZSt4cout, %edi
    call    _ZNSolsEi
    movl    $2, %esi
    movl    $_ZSt4cout, %edi
    call    _ZNSolsEi
    movl    $3, %edx
    movl    $.LC1, %esi
    movl    $_ZSt4cout, %edi
    call    _ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l
    leaq    4(%rsp), %rsi
    movl    $_ZSt4cout, %edi
    call    _ZlsRSoRK1A
    ...
    • 2
  2. Best Answer

    唷，我们走吧。像往常一样，我希望 MSVC 用户使用/std:c++latest /Zc:preprocessor（或20代替latest）（使用旧的预处理器是最后一件事）。

    有以下三种选择：

    1. 完全如您所愿，通过宏。为此，您需要生成 N 个相同类型的宏，其中 N 是参数的最大数量。这是必要的，因为宏中的递归不起作用。（似乎工匠们制作的宏比 N（N 的对数？）要少，但我不会详细讨论这一点。）

      #define LOOP(m, d, ...) __VA_OPT__(LOOP_0(m, d, __VA_ARGS__))
#define LOOP_0(m, d, x, ...) m(d, x) __VA_OPT__(LOOP_1(m, d, __VA_ARGS__))
#define LOOP_1(m, d, x, ...) m(d, x) __VA_OPT__(LOOP_2(m, d, __VA_ARGS__))
#define LOOP_2(m, d, x, ...) m(d, x) __VA_OPT__(LOOP_3(m, d, __VA_ARGS__))

// ---

#define STEP(d, x) (d,x)

LOOP(STEP, 42) // ничего
LOOP(STEP, 42, 1) // (42,1)
LOOP(STEP, 42, 1,2) // (42,1)(42,2)
LOOP(STEP, 42, 1,2,3) // (42,1)(42,2)(42,3)

      注意参数d- 如果需要的话，将附加信息携带到循环外部（或者可以留空）。

      这个选项很好地忽略了最后一个参数后面的逗号。

    2. 通过宏，但使用不同的语法：FOO((1)(2)(3)). 这可以让您避免生成 N 个相同类型的宏。

      有两个亚种：

      • 简单 - 不允许信息从外部传递到循环体中（如d上面的参数），但编写简单。（因此，这个选项不能像上面的例子一样一次抽象为“循环宏”，并且必须为每种单独的循环类型重新编写脚布。）

        #define END(...) END_(__VA_ARGS__)
#define END_(...) __VA_ARGS__##_END

#define BODY(...) std::cout << __VA_ARGS__;

#define LOOP_A(...) BODY(__VA_ARGS__) LOOP_B
#define LOOP_B(...) BODY(__VA_ARGS__) LOOP_A
#define LOOP_A_END
#define LOOP_B_END

#define LOOP(...) END(LOOP_A __VA_ARGS__)

LOOP() // Ничего
LOOP((1)(2)(3)) // std::cout << 1; std::cout << 2; std::cout << 3;

        这个技巧，两个宏互相调用，不被认为是递归，因此适用于任何列表大小（但对于语法（1）它不起作用）。

      • 复杂 - 允许您将信息带入循环体。首先通过转化(a)(b)(c)为序列的形式a)b)c)。坦率地说，这很复杂（这就是为什么我不给出完整的代码），但编写一次就足够了。

        我从某人那里看到了这个并将其以库的形式放入：https://github.com/HolyBlackCat/macro_sequence_for

      • 当然，您也可以像第 (1) 点那样为自己生成 N 个宏，但不清楚为什么在前一个选项可用的情况下要这样做。

    3. 好吧，第三种方法是使用模板而不是宏，如下一个答案中所建议的。但他们建议不是最好的方法：首先，不需要递归，其次（尤其是递归！）最好通过引用传递参数。（已经修复）

      一般来说是这样的：

      #include <iostream>

template <typename ...P>
void foo(P &&... params)
{
    (void(std::cout << std::forward<P>(params) << '\n'), ...);
}

int main()
{
    foo(1,2,"foo"); // 1 2 foo
}

      或者，如果参数是只读的，那么它会更简单、更好，如下所示：

      template <typename ...P>
void foo(const P &... params)
{
    (void(std::cout << params << '\n'), ...);
}
    • 0

相关问题