迭代预处理器定义并处理它们

Question

我正在尝试构建一个宏

#define F(...) ???

会展开下面的构造

#define A 1
#define B 2
#define C 3
#define D 4
F(A, B, C, D)

进入以下代码：

1, "A", 2, "B", 3, "C", 4, "D"

我尝试使用 Boost.Preprocessor，但它似乎缺少所需的功能：

#define Q(r, data, elem) elem, BOOST_PP_STRINGIZE(elem),
#define F(...) BOOST_PP_SEQ_FOR_EACH(Q,,BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__))
F(A, B, C, D)

扩展为 1、“1”、2、“2”、3、“3”、4、“4”，这不是我想要实现的。这发生在 BOOST_PP_VARIADIC_TO_SEQ 内部，所以我无法真正控制它。

有没有什么简单的方法可以在不使用重载宏或使用重载宏但在现有库中做到这一点？

编辑：我正在使用 C++，所以 C 和 C++ 解决方案都很好

编辑 2：

这是一个纯 C++17 解决方案

#include <iostream>
#include <tuple>
#include <array>
#include <string_view>

namespace detail {
    template <std::size_t N>
    constexpr auto split_args(std::string_view s) {
        std::array<std::string_view, N> arr{};

        std::size_t begin{ 0 }, end{ 0 };
        for (std::size_t i = 0; i < N && end != std::string_view::npos; ++i)
        {
            end = s.find_first_of(',', begin);
            arr[i] = s.substr(begin, end - begin);
            arr[i].remove_prefix(std::min(arr[i].find_first_not_of(' '), arr[i].size()));
            begin = end + 1;
        }

        return arr;
    }

    template <std::size_t N, int ...Values, std::size_t ...I>
    constexpr auto get_array(std::array<std::string_view, N> strings, std::index_sequence<I...>) {
        return std::array<std::pair<std::string_view, int>, N> { std::make_pair(strings[I], Values)... };
    }
}

#define EXPAND(x) x
#define VA_ARGS_SIZE(...) std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value
#define F(...) detail::get_array<VA_ARGS_SIZE(__VA_ARGS__), __VA_ARGS__>( detail::split_args<VA_ARGS_SIZE(__VA_ARGS__)>( EXPAND( #__VA_ARGS__ ) ), std::make_index_sequence<VA_ARGS_SIZE(__VA_ARGS__)>{} )

#define A 1
#define B 3
#define C 3
#define D 7

int main()
{
    constexpr auto x = F(A, B, C, D);
    for (const auto &c : x) {
        std::cout << c.first << " " << c.second << "\n";
    }
    
    return 0;
}

输出：

A 1

B 3

C 3

D 7

谢谢@rici 的想法！

Answer 1

在预处理器开始扩展替换列表之前，F 的参数被立即扩展。所以在调用 BOOST_PP_VARIADIC_TO_SEQ 时，参数的名称已经丢失。这不是那个库可以解决的问题。

可以通过在替换正文中使用 # 或 ## 来抑制宏参数的立即扩展。这也适用于可变参数，因此您可以定义，例如

#define F(...) INTERPOLATE(#__VA_ARGS__, __VA_ARGS__)
#define INTERPOLATE(names, ...) /* See below */

INTERPOLATE 然后将使用参数 "A, B, C, D", 1, 2, 3, 4 调用，并且它必须拆分其第一个参数并将其分发。这在运行时间使用例如 strstr 就足够容易了，所以如果运行时间解决方案是可以接受的，它是可用的。（您可以使用 BOOST_PP 库来计算参数并将该数字传递给可变参数运行-time 函数，可能会简化实现。）

如果您使用的是具有 constexpr std::stringview 成员函数的 C++17，则可以在编译时拆分字符串文字。
但是 C 中没有可以做到这一点的工具。（不过，您可以说服编译器优化运行时间代码。需要进行一些实验。）

如果上面的 none 适合您，您可以使用 Python 脚本这样简单的东西轻松地对源文本进行转换，从而取代 F(A, B, C, D) 的调用像这样的东西：

F(("A", A), ("B", B), ("C", C), ("D", D))`

迭代预处理器定义并处理它们

Iterate over preprocessor defines and process them

c++

c-preprocessor