Рекурсивное разыменование указателя

Пытаясь ответить здесь на один вопрос, я нашел этот вопрос:

Как рекурсивно разыменовать указатель (C++03)?

Адаптированный код из ответа следующий:

template<typename T> T& dereference(T &v) { return v; }

template<typename T> const T& dereference(const T &v) { return v; }


template <typename T>
typename std::enable_if<!std::is_pointer<T>::value, T&>::type
dereference(T *v) {
     return dereference(*v);
}

Однако в этом тесте не удается разыменовать указатель на указатель в тип значения:

template <typename T>
class A
{
public:
         bool compare(T a, T b){
                return dereference(a) < dereference(b);
        }


};

int main()
{

        int u = 10;
        int *v = &u;
        int **w = &v;

        int i = 5;
        int *j = &i;
        int **k = &j;

        A<int> a;
        A<int*> b;
        A<int**> c;


        std::cout << a.compare(i, u) << std::endl;
        std::cout << b.compare(j, v) << std::endl;


        // This fails - 5 < 10 == 0
        std::cout << **k << " < " <<  **w <<  " == " << c.compare(k, w) << std::endl;


        return 0;

}

Очевидно, что w и k разыменовываются только один раз, что приводит к вызову operator< для двух указателей.

Я могу исправить это, добавив следующее:

template <typename T>
typename std::enable_if<!std::is_pointer<T>::value, T&>::type
dereference(T **v) {
     return dereference(*v);
}

но тогда это не удастся для int***.

Есть ли способ сделать это рекурсивно без добавления уровней вручную?

Примечание Это всего лишь "теоретический" вопрос.


c++ templates pointers c++11 enable-if
person Nemanja Boric    schedule 26.11.2013    source источник

Ответы (2)


arrow_upward
5
arrow_downward

Это возможно с использованием пользовательского трейта can_dereference:

template <typename T>
struct can_dereference_helper {
    template <typename U, typename = decltype(*std::declval<U>())>
    static std::true_type test(U);
    template <typename...U>
    static std::false_type test(U...);
    using type = decltype(test(std::declval<T>()));
};

template <typename T>
struct can_dereference :
  can_dereference_helper<typename std::decay<T>::type>::type {};

и некоторые взаимно-рекурсивные функции с отправкой битовых тегов:

template <typename T>
auto recursive_dereference(T&& t, std::false_type) ->
  decltype(std::forward<T>(t)) {
    return std::forward<T>(t);
}

template <typename T>
auto recursive_dereference(T&& t) ->
  decltype(recursive_dereference(std::forward<T>(t), can_dereference<T>{}));

template <typename T>
auto recursive_dereference(T&& t, std::true_type) ->
  decltype(recursive_dereference(*std::forward<T>(t))) {
    return recursive_dereference(*std::forward<T>(t));
}

template <typename T>
auto recursive_dereference(T&& t) ->
  decltype(recursive_dereference(std::forward<T>(t), can_dereference<T>{})) {
    return recursive_dereference(std::forward<T>(t), can_dereference<T>{});
}

Посмотрите, как это работает вживую в Coliru. Это может показаться излишним по сравнению с ответом Керрека, но я пошел на общий подход, который будет разыменовывать все, что поддерживает operator*. Я позволю вам решить, какой инструмент лучше всего подходит для вашей проблемы.

person Casey    schedule 26.11.2013
comment
Спасибо! Хотел бы я принять оба ответа, так как я знаю, что вы оба потратили на это время! - person Nemanja Boric; 26.11.2013
comment
Это, вероятно, намного лучше, чем мой ответ, потому что мой не работает с различными квалификациями CV. - person Kerrek SB; 26.11.2013

arrow_upward
2
arrow_downward

Вы можете сделать это с помощью типажа для вычисления окончательного типа возвращаемого значения, здесь он назван remove_all_pointers:

#include <type_traits>

template <typename T> struct remove_all_pointers
{ typedef typename std::remove_reference<T>::type type; };
template <typename T> struct remove_all_pointers<T *>
{ typedef typename std::remove_reference<T>::type type; };

template <typename T>
T & dereference(T & p)
{ return p; }

template <typename U>
typename remove_all_pointers<U>::type & dereference(U * p)
{ return dereference(*p); }

int main(int argc, char * argv[])
{
  return dereference(argv);
}

Вам может понадобиться добавить CV-варианты; Я все еще думаю об этом.

person Kerrek SB    schedule 26.11.2013
comment
Я думаю, вам нужно применить remove_all_pointers рекурсивно, чтобы удалить все указатели. - person Casey; 26.11.2013
comment
Спасибо! Хотел бы я принять оба ответа, так как я знаю, что вы оба потратили на это время! - person Nemanja Boric; 26.11.2013