Question

例如：

std::tuple<int, double> t;
void* p = &std::get<1>(t);

现在我希望通过像

这样的函数得到p的索引

template<typename... Ts>
size_t index(void* p, std::tuple<Ts...> const& t)
{
   ...
}

此示例的结果肯定为1。我感兴趣的是如何在通过显式索引以外的方式获得p时实现函数来获取索引。

Answer 1

C ++ 14中你不需要的东西，一个迷你索引库：

template<unsigned...>struct indexes{using type=indexes;};
template<unsigned Cnt,unsigned...Is>
struct make_indexes:make_indexes<Cnt-1,Cnt-1,Is...>{};
template<unsigned...Is>
struct make_indexes<0,Is...>:indexes<Is...>{};
template<unsigned Cnt>
using make_indexes_t=typename make_indexes<Cnt>::type;

执行实际工作的功能。创建一个指向元素的数组指针。然后搜索p。 nullptr和-1使其适用于空元组。

template<unsigned...Is,class Tuple>
unsigned index_of(indexes<Is...>,void const* p, Tuple const&t){
  void const* r[]={ nullptr, &std::get<Is>(t)... };
  auto it = std::find( std::begin(r), std::end(r), p );
  if (it==std::end(r))
    return -1;
  else
    return (it-std::begin(r))-1;
}

您可以将其放在details命名空间中。

最终功能：

template<class...Ts>
unsigned index_of( void const*p, std::tuple<Ts...> const& t ){
  return index_of( make_indexes_t<sizeof...(Ts)>{}, p, t );
}

失败时返回unsigned(-1)。

Answer 2

比较方面的对数复杂度是可能的 - 假设连续元素的地址在减少：

#include <iostream>
#include <algorithm>
#include <tuple>

// minimalistic index-list implementation

template <std::size_t...> struct index_list {using type = index_list;};

template <typename, typename> struct concat;
template <std::size_t... i, std::size_t... j>
struct concat<index_list<i...>, index_list<j...>> : index_list<i..., j...> {};

// (Inefficient) linear recursive definition of make_indices:
template <std::size_t N> struct make_indices :
    concat<typename make_indices<N-1>::type, index_list<N-1>> {};
template <> struct make_indices<0> : index_list<> {};
template <> struct make_indices<1> : index_list<0> {};

// </>

template <typename T, typename = typename make_indices<std::tuple_size<T>::value>::type> struct offsets;

template <typename... T, std::size_t... indices>
struct offsets<std::tuple<T...>, index_list<indices...>>
{
    static std::size_t index_of(void* p, std::tuple<T...> const& t)
    {
        static const std::tuple<T...> tuple;

        static const std::ptrdiff_t array[]
        {
            reinterpret_cast<char const*>(&std::get<indices>(tuple)) - reinterpret_cast<char const*>(&tuple)...
        };

        auto offset_p_t = static_cast<char const*>(p) - reinterpret_cast<char const*>(&t);

        auto iter = std::lower_bound( std::begin(array), std::end(array), offset_p_t, std::greater<>() );

        if (iter == std::end(array)
         || *iter != offset_p_t)
            return -1;

        return iter - std::begin(array);
    }
};


template <typename... T>
std::size_t index_of(void* p, std::tuple<T...> const& t) {return offsets<std::tuple<T...>>::index_of(p, t);}

int main ()
{
    std::tuple<int, double, std::string> t;
    void* p = &std::get<2>(t);

    std::cout << index_of(p, t);
}

<强> Demo

如何通过地址获取元组中元素的索引？

2 个答案: