Неоднозначная метафункция или неопределенный тип

Я новичок в метафункциях. Я хочу написать функцию, которая заменяет все совпадения определенного типа в составном типе на какой-то другой тип. Например: replace<void *, void, int>::type должно быть int *, replace<void, void, int>::type должно быть int и т. д.

Я в основном потерпел неудачу с двумя разными подходами:

template
    <
        typename C, // Type to be searched
        typename X, // "Needle" that is searched for
        typename Y  // Replacing type
    >
struct replace
{
    typedef C type;
};

// If the type matches the search exactly, replace
template
    <
        typename C,
        typename Y
    >
struct replace<C, C, Y>
{
    typedef Y type;
};

// If the type is a pointer, strip it and call recursively
template
    <
        typename C,
        typename X,
        typename Y
    >
struct replace<C *, X, Y>
{
    typedef typename replace<C, X, Y>::type * type;
};

Мне это показалось довольно простым, но я обнаружил, что когда я пробую replace<void *, void *, int>, компилятор не может решить, использовать ли в этом случае replace<C, C, Y> или replace<C *, X, Y>, поэтому компиляция завершается ошибкой.

Следующее, что я попробовал, это уже удалить указатели в базовой функции:

template
    <
        typename C,
        typename X,
        typename Y
    >
struct replace
{
    typedef typename boost::conditional
        <
            boost::is_pointer<C>::value,
            typename replace
                <
                    typename boost::remove_pointer<C>::type,
                    X, Y
                >::type *,
            C
        >::type
    type;
};

... и именно тогда я обнаружил, что я тоже не могу этого сделать, потому что type, по-видимому, в этот момент не определен, поэтому я не могу сделать рекурсивное typedef из базовой функции.

Теперь у меня нет идей. Как бы вы решили такую ​​проблему?


c++ boost metaprogramming template-meta-programming boost-mpl
person nijansen    schedule 07.05.2012    source источник
comment
Позвольте мне посмотреть, понимаю ли я цель, учитывая два шаблона, извлечь разницу в const-volatile и указателе из разницы и применить это к типу третьего аргумента? Я не слишком уверен, что проблема четко определена, например, каким будет вывод replace<const void, void, const int>::type? А как насчет replace<void,int,double>?   -  person David Rodríguez - dribeas    schedule 08.05.2012
comment
@David Rodríguez - dribeas: проблема представляет собой упражнение, взятое из книги «Метапрограммирование шаблонов C++: концепции, инструменты и методы от Boost и не только». Может я не правильно выразился. Упражнение гласит: Write a ternary metafunction replace_type<c,x,y> that takes an arbitrary compound type c as its first parameter, and replaces all occurences of a type x within c with y.   -  person nijansen    schedule 08.05.2012
comment
Должен признать, описание из книги вместе с образцом перевешивает первоначальный вопрос   -  person sehe    schedule 08.05.2012

Ответы (3)


arrow_upward
3
arrow_downward

Вот общая идея:

template <typename, typename> struct pattern;

template <typename T> struct pattern<T, T>
{
    template <typename U> struct rebind
    {
        typedef U other;
    };
};

template <typename A, typename B> struct pattern<A*, B>
{
    template <typename U> struct rebind
    {
        typedef typename pattern<A, B>::template rebind<U>::other * other;
    };
};

template <typename Haystack, typename Needle, typename New>
struct replace
{
    typedef typename pattern<Haystack, Needle>::template rebind<New>::other type;
};

Контрольная работа:

#include <demangle.hpp>
#include <iostream>
int main()
{
    typedef replace<void, void, int>::type T1;
    typedef replace<void*, void, int>::type T2;

    std::cout << demangle<T1>() << std::endl;
    std::cout << demangle<T2>() << std::endl;
}

Отпечатки:

int
int*

Изменить. Вот несколько более полный набор:

template <typename, typename> struct pattern;
template <typename, typename> struct pattern_aux;

template <typename A, typename B> struct pattern_aux
{
    template <typename U> struct rebind
    {
        typedef typename pattern<A, B>::template rebind<U>::other other;
    };
};

template <typename A, typename B, unsigned int N> struct pattern_aux<A[N], B>
{
    template <typename U> struct rebind
    {
        typedef typename pattern<A, B>::template rebind<U>::other other[N];
    };
};


template <typename A, typename B> struct pattern
{
    template <typename U> struct rebind
    {
        typedef typename pattern_aux<A, B>::template rebind<U>::other * other;
    };
};

template <typename T> struct pattern<T, T>
{
    template <typename U> struct rebind
    {
        typedef U other;
    };
};

template <typename A, typename B> struct pattern<A*, B>
{
    template <typename U> struct rebind
    {
        typedef typename pattern<A, B>::template rebind<U>::other * other;
    };
};

template <typename A, typename B> struct pattern<A const, B>
{
    template <typename U> struct rebind
    {
        typedef typename pattern_aux<A, B>::template rebind<U>::other const other;
    };
};

template <typename A, typename B> struct pattern<A volatile, B>
{
    template <typename U> struct rebind
    {
        typedef typename pattern_aux<A, B>::template rebind<U>::other volatile other;
    };
};

template <typename A, typename B> struct pattern<A const volatile, B>
{
    template <typename U> struct rebind
    {
        typedef typename pattern_aux<A, B>::template rebind<U>::other const volatile other;
    };
};

template <typename Haystack, typename Needle, typename New>
struct replace
{
    typedef typename pattern<Haystack, Needle>::template rebind<New>::other type;
};
person Kerrek SB    schedule 07.05.2012
comment
Шаблон в шаблоне, который выглядит аккуратно (я бы такое никогда не придумал!). Я немного поиграю с этой концепцией и вернусь к вам, как только почувствую, что понимаю ее. Спасибо - person nijansen; 08.05.2012
comment
Я добавил небольшое обобщение, чтобы вы могли составить специализацию. В настоящее время я изо всех сил пытаюсь правильно обрабатывать массивы (например, массивы постоянных указателей на изменчивые символы). - person Kerrek SB; 08.05.2012
comment
Пока это действительно играет хорошо! Это такая мощная концепция. Благодарю вас! - person nijansen; 08.05.2012
comment
@nijansen: я добавил несколько улучшенную версию. - person Kerrek SB; 08.05.2012

arrow_upward
1
arrow_downward

Что-то вроде того, что вы пробовали:

#include <typeinfo>
#include <type_traits>

template<typename C, typename X, typename Y>
struct replace {
private:

    typedef
        typename std::conditional <
            std::is_pointer<C>::value,
            typename std::remove_pointer<C>::type,
            C >::type
        strippedT;

    typedef
        typename std::conditional <
            std::is_same<strippedT, X>::value,
            Y,
            strippedT>::type
        replacedT;
public:

    typedef
        typename std::conditional <
            std::is_pointer<C>::value,
            replacedT*,
            replacedT >::type
        type;
};

int main()
{
    typedef replace<void*, void, int>::type T1;
    std::cout << typeid(T1).name() << '\n';  // prints Pi on my implementation

    typedef replace<void, void, int>::type T2;
    std::cout << typeid(T2).name();          // prints i
}

Ответ Керрека выглядит намного лучше :)

person jrok    schedule 07.05.2012

arrow_upward
0
arrow_downward

Следуя вашему коду, почему бы не добавить еще одну специализацию

template
    <
        typename C,
        typename Y
    >
struct replace<C*, C, Y>
{
    typedef Y* type;
};

живой код пример результатов

Или еще больше:

template<class T>
struct tag_t {using type=T;};

template <class C, class X, class Y>
struct replace {};

template <class C, class Y>
struct replace<C, C, Y>: tag_t<Y> {};

template <class C, class Y>
struct replace<C*, C, Y>: tag_t<Y*>{};

живой код результаты

person pepero    schedule 05.08.2017