9

私は次の構造体を持っています:

struct Data
{
    std::string firstMember;
    std::string secondMember;
    std::string thirdMember;
};

constexpr次のように文字列名でメンバーの1つを選択したい

Data instance;
auto& member = getMember(instance, "firstMember"); 

getMemberはconstexprfunction/struct / macros /問題のすべてであり、式は単純に最適化する必要があります(私はそれを望んでいます)auto& member = instance.firstMember;getMemberここでの私の望みは、別の関数から呼び出すことができるようにすることですconstexpr。この関数は、特定のメンバーの名前を計算します->ある種のコンパイル時の反映です。

私は知っています、C ++には反映がないので、問題の構造体のメンバーの名前をなんらかの方法で登録してもかまいません(部分的に特殊化しますか?いくつかのマクロを使用しますか?)。

REGISTER_MEMBER(Data, "firstMember", firstMember);

私が欲しいのは、コンパイル時の最適化を行い、実行時に何もしないことです。それはC++11で可能ですか?

4

1 に答える 1

14

コメントに記載されているように、最初にBOOST_FUSION_ADAPT_STRUCT(そして友達)を見てください:

#include <boost/fusion/include/adapt_struct.hpp>
#include <string>

struct Data
{
    std::string firstMember;
    std::string secondMember;
    std::string thirdMember;
};

BOOST_FUSION_ADAPT_STRUCT(
    Data,
    (std::string, firstMember)
    (std::string, secondMember)
    (std::string, thirdMember)
    )

Dataこれにより、構造がFusionで使用可能なシーケンスに変わります。

#include <boost/fusion/include/at_c.hpp>

int main()
{
    Data d = { "firstData", "secondData", "thirdData" };

    std::cout << boost::fusion::at_c<0>(d) << std::endl;
}

これは印刷し"firstData"ます。メンバーを順番に参照するようにインデックスを変更します。

ここで、コンパイル時に番号を使用してメンバーを参照できるようになりました。しかし、あなたは名前が欲しかった。コメントにも記載されているように、文字列の処理は実行時の機能です...ほとんど。C++11は私たちに与えconstexprます。

少し注意が必要ですが、最終的には次のようになります。

#include <boost/fusion/include/adapt_struct.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/repetition/repeat.hpp>
#include <boost/preprocessor/seq.hpp>
#include <boost/preprocessor/tuple/elem.hpp>
#include <stdexcept>

// and repeat for BOOST_FUSION_ADAPT_TPL_STRUCT, etc...
#define REFLECT_STRUCT(NAME, ATTRIBUTES)                                                \
        REFLECT_STRUCT_DETAIL(NAME,                                                     \
                              ATTRIBUTES,                                               \
                              BOOST_PP_SEQ_POP_FRONT(                                   \
                                BOOST_PP_CAT(                                           \
                                    /* warning: uses fusion implementation details: */  \
                                    BOOST_FUSION_ADAPT_STRUCT_FILLER_0(0,0)ATTRIBUTES,  \
                                    _END)))                                             \

#define REFLECT_STRUCT_DETAIL(NAME, ATTRIBUTES, WRAPPEDATTRIBUTES)                  \
        BOOST_FUSION_ADAPT_STRUCT(NAME, ATTRIBUTES)                                 \
                                                                                    \
        namespace detail                                                            \
        {                                                                           \
            namespace BOOST_PP_CAT(reflect_, NAME)                                  \
            {                                                                       \
                template <int N>                                                    \
                struct member_name;                                                 \
                                                                                    \
                BOOST_PP_SEQ_FOR_EACH_I(REFLECT_STRUCT_DETAIL_MEMBER_NAME,          \
                                        BOOST_PP_EMPTY,                             \
                                        WRAPPEDATTRIBUTES)                          \
                                                                                    \
                template <int N>                                                    \
                constexpr bool member_match_index(const std::size_t index,          \
                                                  const char* const str,            \
                                                  const std::size_t len)            \
                {                                                                   \
                    return index == len ||                                          \
                           (member_name<N>::value()[index] == str[index]            \
                            && member_match_index<N>(index + 1, str, len));         \
                }                                                                   \
                                                                                    \
                template <int N>                                                    \
                constexpr bool member_match(const char* const str,                  \
                                            const std::size_t len)                  \
                {                                                                   \
                    return len == member_name<N>::value_length                      \
                           && member_match_index<N>(0, str, len);                   \
                }                                                                   \
                                                                                    \
                constexpr int find_member(const char* const str,                    \
                                          const std::size_t len)                    \
                {                                                                   \
                    return BOOST_PP_REPEAT(BOOST_PP_SEQ_SIZE(WRAPPEDATTRIBUTES),    \
                                           REFLECT_STRUCT_DETAIL_MEMBER_NAME_TEST,  \
                                           BOOST_PP_EMPTY)                          \
                           throw std::runtime_error("could not find "               \
                                                    BOOST_PP_STRINGIZE(NAME)        \
                                                    " member");                     \
                }                                                                   \
            }                                                                       \
        }                                                                           \
                                                                                    \
        constexpr int BOOST_PP_CAT(indexof_, NAME)(const char* const str,           \
                                                   const std::size_t len)           \
        {                                                                           \
            return detail::BOOST_PP_CAT(reflect_, NAME)::find_member(str, len);     \
        }                                                                           \
                                                                                    \
        template <std::size_t N>                                                    \
        constexpr int BOOST_PP_CAT(indexof_, NAME)(const char (&str)[N])            \
        {                                                                           \
            return detail::BOOST_PP_CAT(reflect_, NAME)::find_member(&str[0], N);   \
        }

#define REFLECT_STRUCT_DETAIL_EXTRACT_NAME(pair) \
        BOOST_PP_STRINGIZE(BOOST_PP_TUPLE_ELEM(1, pair))

#define REFLECT_STRUCT_DETAIL_MEMBER_NAME(r, data, n, elem) \
        REFLECT_STRUCT_DETAIL_MEMBER_NAME_DETAIL(n, REFLECT_STRUCT_DETAIL_EXTRACT_NAME(elem))

#define REFLECT_STRUCT_DETAIL_MEMBER_NAME_DETAIL(n, name)               \
        template <>                                                     \
        struct member_name<n>                                           \
        {                                                               \
            static constexpr std::size_t value_length = sizeof(name);   \
            typedef const char value_type[value_length];                \
                                                                        \
            static constexpr const value_type& value()                  \
            {                                                           \
                return name;                                            \
            }                                                           \
        };

#define REFLECT_STRUCT_DETAIL_MEMBER_NAME_TEST(z, n, text) \
        member_match<n>(str, len) ? n :

怖いように見えますが、時間をかけて分解すれば読みやすくなります。

メンバー名への定数式アクセスを提供するために、独自のマクロを導入する必要があります。醜いもののほとんどは、Boost.Preprocessorリストの処理に由来します。Fusionは、適応中にも名前を記録しますが(を参照) 、残念ながら、名前は使用できないため、boost::fusion::extension::struct_member_nameマークされていません。constexpr

これは与える:

#include <boost/fusion/include/at_c.hpp>
#include <iostream>
#include <string>

struct Data
{
    std::string firstMember;
    std::string secondMember;
    std::string thirdMember;
};

REFLECT_STRUCT(
    Data,
    (std::string, firstMember)
    (std::string, secondMember)
    (std::string, thirdMember)
    )

// your desired code:
// (note the use of at_c ensures this is evaluated at comple-time)
#define GETMEMBER(data, member) boost::fusion::at_c<indexof_Data(member)>(data)

int main()
{
    Data d = { "firstData", "secondData", "thirdData" };

    std::cout << boost::fusion::at_c<indexof_Data("firstMember")>(d) << std::endl;
    std::cout << GETMEMBER(d, "secondMember") << std::endl;
    std::cout << GETMEMBER(d, "thirdMember") << std::endl;
    /* causes error: std::cout << GETMEMBER(d, "nonexistent_member") << std::endl; */
}

これはあなたが求めていたものに近いと思います。

ただし、これがすべて必要なわけではないことに注意してください。Boost.Fusionにはすでに必要なものが含まれている可能性があります。これは、純粋なコンパイル時のもの(Boost.MPL)と通常の実行時のものの間の領域にあります。構造体を適応させると、すでにそれを反復処理するようなことができます(boost::fusion::for_each)。

于 2012-12-15T18:41:25.537 に答える