Question

更新：对于令人困惑的条款感到抱歉 - 我不需要二叉树，但需要分段树或区间树。

想象一下，每次执行我的程序时，我都必须静态初始化一个搜索树。

Tree t;
t.add(10, 'Apple');
t.add(20, 'Pear');
t.add(50, 'Orange');
...
t.add(300, 'Cucumber');

..
// then I use it.
int key = 15;
String s = t.lookup(key) // Returns 'Apple' ( as the key is between 10 and 20)

树中的键和值是＆＃34;静态＆＃34;，硬编码，但必须不时维护。是否存在元编程技巧如何在编译期间将键值组织成二进制搜索树（或跳过列表）？

例如，整个搜索树直接在代码.text中实现，.data中没有任何内容？我也可以预测＆＃34;密钥数量并提供订单。

Answer 1

我怀疑你是在这里从山上开出一座山，而这是因为： -

您认为在C ++中静态初始化 必须在编译时。
要么你不熟悉上层和下界的概念，否则你不知道 [部分]有序序列v中S的{upper | lower}界限可以是通过S的二进制搜索确定，并且您可以依赖标准库至少要有效地做到这一点。

我认为你想要一个静态初始化的数据结构映射字符串文字的整数键，在运行时，您可以使用整数n进行查询并非常有效检索字符串文字s（如果有），其键是最大的不大于n - 附加条件，大概是， n不大于所有键。

如果这是正确的，那么您需要静态初始化的数据结构只是一个静态初始化的映射 M 整数到字符串文字。模板元编程不在框架中。

由于（假定的）附带条件，n更大的查询将失败与所有密钥相比，您需要在M中包含一个带有密钥1的标记值大于你想要找到的最大值。

然后，对于运行时整数n，您在M的上限查询n。 n中M的上限是大于n的最小键，如果有的话。如果返回的迭代器it为M.end()，则表示n没有字符串。否则，如果it == M.begin()，那么每个键都大于n，所以你再没有n的字符串。否则，必须存在<key,value> 位于--it旁边，key必须是不的最大密钥大于n。因此n的字符串是value。

#include <map>

static const std::map<int,char const *> tab = 
{
    { 2,"apple" },
    { 5,"pear" },
    { 9,"orange" },
    { 14,"banana" },
    { 20,"plum" },
    { 20 + 1,nullptr }
};

const char * lookup(int n)
{
    auto it = tab.upper_bound(n);
    return it == tab.begin() || it == tab.end() ? nullptr : (--it)->second;
}

在此示例前面加上：

#include <iostream>

using namespace std;

int main(void)
{
    for (int i = 0; i <= 21; ++i) {
        cout << i;
        char const *out = lookup(i);
        cout << " -> " << (!out ? "Not found" : out) << endl;
    }
    return 0;
}

，输出结果为：

0 -> Not found
1 -> Not found
2 -> apple
3 -> apple
4 -> apple
5 -> pear
6 -> pear
7 -> pear
8 -> pear
9 -> orange
10 -> orange
11 -> orange
12 -> orange
13 -> orange
14 -> banana
15 -> banana
16 -> banana
17 -> banana
18 -> banana
19 -> banana
20 -> plum
21 -> Not found

此程序中的tab是静态数据结构，但事实并非如此在 compiletime 初始化。它在全局静态中初始化调用main之前，程序的初始化。除非你我需要减少程序启动时的纳秒想不通为什么你需要在编译时初始化地图。

如果你做要求它在编译时初始化，它只是比这更有点小气。你需要地图一个constexpr object，意思是编译器可以在编译时构造它;并为它必须是literal type; 这意味着你不能使用std::map，因为它不是文字类型。

因此您必须使用：

constexpr std::pair<int,char const *> tab[] 
{
    { 2,"apple" },
    { 5,"pear" },
    { 9,"orange" },
    { 14,"banana" },
    { 20,"plum" },
    { 20 + 1,nullptr }
};

或类似的，并以基本上所示的方式实现lookup(n)，但在std::upper_bound上调用tab。在那里你会找到如果你的话，我会留下你的练习想要它。

Answer 2

我终于创造了我想要实现的目标。它过于复杂，看起来编译器优化器比我想的要聪明得多。

// Log "function"
template <int N>
struct LOG
{
    static const int value = LOG<N/2>::value + 1;
};
template<>
struct LOG<0>
{
    static const int value = 0;
};

// pow "function"
template <int N>
struct POW
{
    static const int value = POW<N-1>::value * 2;
};
template<>
struct POW<1>
{
    static const int value = 2;
};

template<>
struct POW<0>
{
    static const int value = 1;
};

// Pair <key, value> to be a payload in a type list
template<int k, char v>
struct Pair
{
    static const int key = k;
    static const int value = v;
};

// type list manipulator - access n-th element
template <size_t, class...> struct element;
template <class TT, class...TTs>
struct element<0, TT, TTs...>
{
    typedef TT type;
};
template <size_t K, class TT, class...TTs>
struct element<K, TT, TTs...>
{
    typedef typename element<K-1, TTs...>::type type;
};

template<class... Ts>
struct V;

// Binary split search algorithm (pure templatized)
template<class T, class... Ts>
struct V<T, Ts...> : private V<Ts...>
{
    template<size_t N = sizeof...(Ts), size_t level = LOG<sizeof...(Ts)+1>::value>
    struct impl
    {
        template<size_t IDX>
        inline static char search_impl(size_t n)
        {
            using namespace std;
            static const int depth = LOG<N>::value;
            static const int layer = depth - level;
            static const int key   = element<IDX, T, Ts...>::type::key;
            static const size_t left_idx  = IDX - ( N / POW<layer + 2>::value + 1);
            static const size_t right_idx =
                IDX + ( N / POW<layer + 2>::value + 1) > sizeof...(Ts) ?
                sizeof...(Ts) :
                IDX + ( N / POW<layer + 2>::value + 1);             

            //std::cout << setfill('*') << setw(layer) << ' '
            //    << "Level:" << level << " of:" << depth << std::endl
            //    << std::setw(layer) << ' ' 
            //    << "IDX/val/layer/POW/level: "
            //    << " " << IDX
            //    << "/" << key
            //    << "/" << layer
            //    << "/" << POW<layer>::value
            //    << "/" << level
            //    << "/" << left_idx
            //    << "/" << right_idx
            //    << std::endl;
            if ( n < key )
                return V<T, Ts...>::impl<N, level-1>::template search_impl<left_idx>(n);
            else
                return V<T, Ts...>::impl<N, level-1>::template search_impl<right_idx>(n);       
        }

    };

    template<size_t N>
    struct impl<N,1>
    {
        template<size_t IDX>
        inline static char search_impl(size_t n)
        {
            static const int key   = element<IDX, T, Ts...>::type::key;
            static const char value1 = element<IDX-1, T, Ts...>::type::value;
            static const char value2 = element<IDX, T, Ts...>::type::value;
            if ( n < key )
            {
                //std::cout << " *" << value1 << ' '  << IDX << std::endl;
                return value1;
            } else {
                //std::cout << " *" << value2 << ' '  << IDX << std::endl;
                return value2;
            }
        }
    };

    static void print()
    {
        std::cout << typeid(T).name() << ' ' << T::key << ' ' << (char)T::value << std::endl;
        V<Ts...>::print();
    }
    static char search(size_t n)
    {
        static const size_t level = LOG<sizeof...(Ts)+1>::value;
        static const size_t N = sizeof...(Ts);
        static const int height = LOG<N>::value;
        static const size_t root_idx = N / 2 + 1;
        static const int key = element<root_idx, T, Ts...>::type::key;
        //std::cout << "Level:" << level << " of:" << height << std::endl
        //    << "IDX/val: "
        //    << " " << root_idx
        //    << "/" << input[root_idx]
        //    << std::endl;

        static const size_t left_idx  = root_idx - ( N / POW<2>::value + 1);
        static const size_t right_idx = root_idx + ( N / POW<2>::value + 1);

        if( n < key)
            return V<T, Ts...>::impl<N, level-1>::template search_impl<left_idx>(n);
        else
            return V<T, Ts...>::impl<N, level-1>::template search_impl<right_idx>(n);
    }
};

template<>
struct V<>
{
    static void print()
    {}
};

int main(int argc, char *argv[])
{
    int i = std::stoi(argv[1]);

    typedef V<
    Pair<  0x1,'a'>,
    Pair< 0x11,'b'>,
    Pair< 0x21,'c'>,
    Pair< 0x31,'d'>,
    Pair< 0x41,'e'>,
    Pair< 0x51,'f'>,
    Pair< 0x61,'g'>,
    Pair< 0x71,'h'>,
    Pair< 0x81,'i'>,
    Pair< 0x91,'j'>,
    Pair<0x101,'k'>,
    Pair<0x111,'l'>,
    Pair<0x121,'m'>,
    Pair<0x131,'n'>,
    Pair<0x141,'o'>
    > TV;

    std::cout << (char)TV::search(i) << std::endl;

    return 0;
};

就是这样。我的目标是“强制”编译器将所有常量放入代码中。因为数据段中没有任何内容。生成的代码内联所有search_impl＆lt; *＆gt;方法在一起，结果只包含“cmp”和“jae”指令。但是，如果要搜索的数组被定义为const static，那么看起来合理的编译器无论如何都会这样做。

Answer 3

我会使用switch进行查找。

编译器可以自由使用跳转表，二进制搜索或任何其他技术来优化查找。对于大多数切换表，编译器通常会发出最快的事情。

switch (key)
{
    case 10: return "Apple";
    case 20: return "Pear";
    ...
}

C ++元编程 - 编译时间搜索树

3 个答案: