2

たとえば、同じ 2 つの引数型を持つ一連の関数 f1、f2 などがあります。マクロを使いたい

RUN((f1)(f2)(f3), a, b)

結果で一連の関数を実行する

f1(a, b), f2(a, b), f3(a, b)

ブーストプリプロセッサが役立つと思います。私は試した

#define RUN_DETAIL(pR, pData, pF) pF(a, b);
#define RUN(pFs, a, b) BOOST_PP_SEQ_FOR_EACH(RUN_DETAIL, BOOST_PP_EMPTY, pFs)

しかし、失敗しました。どうやってするの？

以下のような答えが見つかりました

#define RUN_DETAIL(pR, pData, pF) pF pData;
#define RUN(pFs, ...) BOOST_PP_SEQ_FOR_EACH(RUN_DETAIL, (__VA_ARGS__), pFs)

この手法は、一連のマクロを呼び出す場合にも機能します。

4

1 に答える 1

6

ここでマクロを使用する必要はありません。Coliruでライブを見る:

#include <boost/fusion/adapted/std_tuple.hpp>
#include <boost/fusion/algorithm.hpp>
#include <boost/phoenix.hpp>

template <typename... F>
struct sequence_application
{
    explicit sequence_application(F... fs) : fs(fs...) { }

    template <typename... Args>
        void operator()(Args const&... args) const {
            namespace phx = boost::phoenix;
            using namespace phx::arg_names;

            boost::fusion::for_each(fs, phx::bind(arg1, phx::cref(args)...));
        }
    private:
        std::tuple<F...> fs;
};

template <typename... F>
sequence_application<F...> apply_all(F&&... fs) {
    return sequence_application<F...>(std::forward<F>(fs)...);
}

これを実証しましょう:

#include <iostream>
#include <string>

void foo(const char* v) { std::cout << __FUNCTION__ << ": " << v << "\n"; }
void bar(std::string v) { std::cout << __FUNCTION__ << ": " << v << "\n"; }

struct poly_functor {
    template <typename... T>
        void operator()(T&...) const { std::cout << __PRETTY_FUNCTION__ << "\n"; }
};

もちろん、質問のように直接呼び出しを行うことができます。

poly_functor pf;
apply_all(&foo, &bar, pf)("fixed invocation is boring");

しかし、それは確かにかなり退屈です。どうですか、複合ファンクターを保持して、別のアルゴリズムに渡しますか?

auto combined = apply_all(&foo, &bar, pf);

boost::for_each(
        std::vector<const char*> {"hello", "world", "from", "various"},
        combined);

それでは、マクロ アプローチでそれを試してください。マクロは、C++ の第一級言語市民ではありません。

最後に、可変引数リストで機能することを示しましょう。

struct /*anonymous*/ { int x, y; } point;

// the variadic case
apply_all(pf)("bye", 3.14, point);

完全なデモは次のように表示されます。

foo: fixed invocation is boring
bar: fixed invocation is boring
void poly_functor::operator()(T &...) const [T = <char const[27]>]
foo: hello
bar: hello
void poly_functor::operator()(T &...) const [T = <const char *const>]
foo: world
bar: world
void poly_functor::operator()(T &...) const [T = <const char *const>]
foo: from
bar: from
void poly_functor::operator()(T &...) const [T = <const char *const>]
foo: various
bar: various
void poly_functor::operator()(T &...) const [T = <const char *const>]
void poly_functor::operator()(T &...) const [T = <char const[4], const double, const <anonymous struct at test.cpp:54:5>>]
于 2014-06-11T12:52:04.350 に答える