Специализация шаблона на элементе шаблона класса шаблона

Ответ Джонатана Уэйкли объясняет причину, по которой ваш код не работает.

Мой ответ покажет вам, как решить эту проблему.

В вашем примере тип контейнера, на котором вы хотите специализироваться, определен вне basic_data_object, поэтому вы, конечно, можете использовать его непосредственно в своей специализации:

template <typename S, template<class> class A, typename T>
struct get_data_object_value<S,A,std::vector<T,A>>
{ };

Это определенно соответствует стандарту и работает со всеми компиляторами.

В случае, когда тип определен в basic_data_object, вы можете переместить его из класса.

Пример: вместо

template<typename S, template<class> class A>
struct a_data_object
{
    template<typename T>
    struct a_container
    { };
};

напишите это:

template<typename S, template<class> class A, typename T>
// you can perhaps drop S and A if not needed...
struct a_container
{ };

template<typename S, template<class> class A, typename T>
struct a_data_object
{
    // use a_container<S,A,T>
};

Теперь вы можете специализироваться на:

template <typename S, template<class> class A, typename T>
struct get_data_object_value<S,A,a_container<S,A,T>>
{ };

Примечание. Следующее «решение», по-видимому, связано с ошибкой GCC 4.8.1.

Если контейнер определен только во включающем шаблоне и не может быть перемещен, вы можете сделать это:

1. Получить тип контейнера из basic_data_object:

   template<typename S, template<class> class A, typename T>
   using bdo_container = basic_data_object<S,A>::array_container<T>;
   

2. Напишите специализацию для этого типа:

   template <typename S, template<class> class A, typename T>
   struct get_data_object_value<S,A,bdo_container<S,A,T>>
   { };
   

В стандарте C ++ в параграфе 2 [temp.class.spec.match] говорится:

Частичная специализация соответствует заданному фактическому списку аргументов шаблона, если аргументы шаблона частичной специализации могут быть выведены из фактического списка аргументов шаблона (14.8.2).

14.8.2 - это [temp.arg.deduct], т.е. предложение, описывающее вывод аргументов шаблона для шаблонов функций.

Если вы измените свой код для использования аналогичного шаблона функции и попытаетесь вызвать его, вы увидите, что аргументы не могут быть выведены:

template <typename String, typename T>
void deduction_test(String,
                    typename basic_data_object<String, std::allocator>::template array_container<T>)
{ }

int main()
{
  deduction_test(std::string{}, std::vector<int, std::allocator<int>>{});
}

(Я удалил параметр Allocator, поскольку нет возможности передать параметр шаблона шаблона в качестве аргумента функции, а в типе basic_data_object это невыведенный контекст, я не верю, что это влияет на результат.)

И clang, и GCC говорят, что не могут вывести здесь T. Следовательно, частичная специализация не будет соответствовать тем же типам, которые используются в качестве аргументов шаблона.

Так что я еще не ответил на этот вопрос, только пояснил, что причина кроется в правилах вывода аргументов шаблона, и показал эквивалентность вывода в шаблонах функций.

В 14.8.2.5 [temp.deduct.type] мы получаем список невыведенных контекстов, которые предотвращают дедукцию, и следующее правило в параграфе 6:

Когда имя типа указывается способом, который включает невыведенный контекст, все типы, составляющие это имя типа, также не выводятся.

Поскольку basic_data_object<String, Allocator> находится в невыведенном контексте (это спецификатор вложенного-имени, т.е. появляется перед ::), это означает, что тип T также не выводится, что именно об этом говорят Clang и GCC. нас.

С вашим временным жестко запрограммированным typedef нет невыведенного контекста, поэтому вывод для T выполняется успешно с использованием шаблона функции deduction_test:

template <typename String, typename T>
void deduction_test(String,
                    typename data_object::template array_container<T>)
{ }

int main()
{
  deduction_test(std::string{}, std::vector<int, std::allocator<int>>{}); // OK
}

И, соответственно, частичная специализация вашего шаблона класса может быть сопоставлена, когда он использует этот тип.

Я не вижу способа заставить его работать без изменения определения get_data_object_value, но если это вариант, вы можете избавиться от необходимости выводить тип array_container и вместо этого использовать черту, чтобы определить, является ли тип тем типом, который вы хотите, и специализируемся на результате признака:

#include <string>
#include <vector>
#include <iostream>

template <typename String, template<class> class Allocator>
class basic_data_object
{
public:
  template<typename T>
  using array_container = std::vector<T, Allocator<T>>;

  template<typename T>
    struct is_ac : std::false_type { };

  template<typename T>
    struct is_ac<array_container<T>> : std::true_type { };
};

template <typename String, template<class> class Allocator, typename T, bool = basic_data_object<String, Allocator>::template is_ac<T>::value>
struct get_data_object_value
{
};

template <typename String, template<class> class Allocator, typename T>
struct get_data_object_value<String, Allocator, T, true>
{
  void f() { }
};

int main()
{
  get_data_object_value<std::string,std::allocator,std::vector<short>> obj;
  obj.f();
}

На самом деле это не масштабируется, если вам нужно несколько частичных специализаций шаблона класса, поскольку вам нужно будет добавить несколько bool параметров шаблона с аргументами по умолчанию.

Почему-то проблема, кажется, связана с двойным уровнем шаблонов. Я оставлю вам 3 тестовых примера ниже, они просты:

1. Удалите аргументы шаблона First: работает как ожидалось
2. Сделайте First шаблон, но внутренний тип будет простым: работает должным образом
3. Создайте как First, так и шаблоны внутреннего типа: компилируется, но результат неожиданный

Примечание: параметр шаблона шаблона Allocator бесполезен для воспроизведения проблемы, поэтому я оставил его.

Примечание: как GCC (версия ideone, 4.8.1, я полагаю), так и Clang (версия Coliru, 3.4) компилируют код, но дают один и тот же непонятный результат

Из трех приведенных выше примеров я сделал вывод:

• , что это НЕ проблема невыводимого контекста; в противном случае почему бы (2) работать?
• , что это НЕ проблема с псевдонимом; в противном случае почему бы (1) работать?

И поэтому то, что либо проблема гораздо более опасная, чем текущие намеки, заставит нас поверить, ИЛИ что и в gcc, и в Clang есть ошибка.

РЕДАКТИРОВАТЬ: спасибо Джонатану Уэйкли, который терпеливо обучил меня, и я наконец смог понять как стандартные формулировки, относящиеся к этому делу, так и то, как они применяются. Теперь я попытаюсь объяснить это (снова) своими словами. Пожалуйста, обратитесь к ответу Джонатана для получения точных стандартных кавычек (все они находятся в [temp.deduct.type])

• При выводе параметров шаблона (P _i), будь то для функций или классов, вывод выполняется независимо для каждого аргумента.
• Каждый аргумент должен содержать ноль или один кандидата C _i для каждого параметра; если аргумент может предоставить более одного кандидата, вместо этого он не предоставляет ни одного.
• Таким образом, каждый аргумент создает словарь D _n: P _i -> C _i, который отображает подмножество (возможно, пустое) параметров шаблона в быть выведенным к их кандидату.
• The dictionaries D_n are merged together, parameter by parameter:
  • if only one dictionary has a candidate for a given parameter, then this parameter is accepted, with this candidate
  • если несколько словарей имеют одного и того же кандидата для данного параметра, то этот параметр принимается с этим кандидатом
  • если несколько словарей имеют разных несовместимых (*) кандидатов для данного параметра, то этот параметр отклоняется
• Если окончательный словарь завершен (сопоставляет каждый параметр с принятым кандидатом), то дедукция завершается успешно, в противном случае - неуспешно.

(*) похоже, есть возможность найти "общий тип" из доступных кандидатов ... здесь это не имеет значения.

Теперь мы можем применить это к предыдущим примерам:

1) Существует единственный параметр шаблона T:

• сопоставление шаблонов std::vector<int> с typename First::template ArrayType<T> (то есть std::vector<T>), мы получаем D ₀: { T -> int }
• объединение единственного словаря дает { T -> int }, таким образом T выводится как int

2) Существует один параметр шаблона String

• сопоставление шаблонов std::vector<int> с String, получаем D ₀: { String -> std::vector<int> }
• сопоставление с образцом std::vector<int> против typename First<String>::ArrayType мы попадаем в невыводимый контекст (многие значения String могут соответствовать), мы получаем D ₁: {}
• объединение двух словарей дает { String -> std::vector<int> }, таким образом String получается std::vector<int>

3) Два параметра шаблона String и T существуют.

• сопоставление шаблонов std::vector<char> с String, получаем D ₀: { String -> std::vector<char> }
• сопоставление с образцом std::vector<int> против typename First<String>::template ArrayType<T> мы попадаем в невыводимый контекст, получаем D ₁: {}
• объединение двух словарей дает { String -> std::vector<char> }, который является неполным словарем (T отсутствует) дедукция не выполняется

Должен признать, я еще не учел, что аргументы разрешаются независимо друг от друга, и поэтому, чем в этом последнем случае, при вычислении D ₁ компилятор не мог воспользоваться тем фактом, что D ₀ уже вычислил значение для String. Однако, почему это делается таким образом, вероятно, является самостоятельным вопросом.

Без внешнего шаблона он работает, так как печатает "Specialized":

#include <iostream>
#include <vector>

struct First {
    template <typename T>
    using ArrayType = std::vector<T>;
};

template <typename T>
struct Second {
    void go() { std::cout << "General\n"; }
};

template <typename T>
struct Second < typename First::template ArrayType<T> > {
    void go() { std::cout << "Specialized\n"; }
};

int main() {
    Second < std::vector<int> > second;
    second.go();
    return 0;
}

Без внутреннего шаблона он работает, так как печатает "Specialized":

#include <iostream>
#include <vector>

template <typename String>
struct First {
    using ArrayType = std::vector<int>;
};

template <typename String, typename T>
struct Second {
    void go() { std::cout << "General\n"; }
};

template <typename String>
struct Second < String, typename First<String>::ArrayType > {
    void go() { std::cout << "Specialized\n"; }
};


int main() {
    Second < std::vector<int>, std::vector<int> > second;
    second.go();
    return 0;
}

В обоих случаях он не работает, так как в нем выводится «Общие»:

#include <iostream>
#include <vector>

template <typename String>
struct First {
    template <typename T>
    using ArrayType = std::vector<T>;
};

template <typename String, typename T>
struct Second {
    void go() { std::cout << "General\n"; }
};

template <typename String, typename T>
struct Second < String, typename First<String>::template ArrayType<T> > {
    void go() { std::cout << "Specialized\n"; }
};

int main() {
    Second < std::vector<char>, std::vector<int> > second;
    second.go();
    return 0;
}

В качестве альтернативы, каков наилучший (самый маленький / самый чистый) способ сделать эту работу?

Возможно, это:

• Напишите шаблон признака SFINAE Tr<String,Allocator,T>, который определяет, совпадает ли T с basic_data_object<String,Allocator>::array_container<T::E> для некоторого типа E - если он есть - то есть T::value_type.
• Предоставьте шаблон get_data_object_value с 4-м параметром, по умолчанию равным Tr<String,Allocator,T>::value
• Напишите частичные специализации get_data_object_value, инстанцирующие этот 4-й параметр как true, false соответственно.

Вот демонстрационная программа:

#include <type_traits>
#include <vector>
#include <iostream>

template <typename String, template<class> class Allocator>
struct basic_data_object
{
    template<typename T>
    using array_container = std::vector<T, Allocator<T>>;
};

template<typename T, typename String, template<class> class Allocator>
struct is_basic_data_object_array_container
/* 
    A trait template that has a `static const bool` member `value` equal to
    `true` if and only if parameter type `T` is a container type
    with `value_type E` s.t. 
        `T` = `basic_data_object<String,Allocator>::array_container<T::E>`
*/ 
{
    template<typename A> 
    static constexpr bool
    test(std::is_same<
            A,
            typename basic_data_object<String,Allocator>::template
                array_container<typename A::value_type>
            > *) {
        return std::is_same<
            A,
            typename basic_data_object<String,Allocator>::template
                array_container<typename A::value_type>
            >::value;
    }
    template<typename A> 
    static constexpr bool test(...) {
        return false;
    }
    static const bool value = test<T>(nullptr);
};


template <
    typename String, 
    template<class> class Allocator,
    typename T,
    bool Select = 
        is_basic_data_object_array_container<T,String,Allocator>::value
>           
struct get_data_object_value;


template <
    typename String, 
    template<class> class Allocator,
    typename T
>           
struct get_data_object_value<
    String,
    Allocator,
    T,
    false
>
{
    static void demo() {
        std::cout << "Is NOT a basic_data_object array_container" << std::endl;
    }
};

template <
    typename String, 
    template<class> class Allocator,
    typename T>
struct get_data_object_value<
    String, 
    Allocator,
    T,
    true
>
{
    static void demo() {
        std::cout << "Is a basic_data_object array_container" << std::endl;
    }
};

#include <list>
#include <memory>

using namespace std;

int main(int argc, char **argv)
{
    get_data_object_value<string,allocator,std::vector<short>>::demo();
    get_data_object_value<string,allocator,std::list<short>>::demo();
    get_data_object_value<string,allocator,short>::demo();
    return 0;
}

Построен с использованием gcc 4.8.2, clang 3.4. Вывод:

Is a basic_data_object array_container
Is NOT a basic_data_object array_container
Is NOT a basic_data_object array_container

VC ++ 2013 не скомпилирует это из-за отсутствия поддержки constexpr. Чтобы приспособить этот компилятор, может использоваться следующая менее естественная реализация признака:

template<typename T, typename String, template<class> class Allocator>
struct is_basic_data_object_array_container
{
    template<typename A>
    static
    auto test(
        std::is_same<
            A,
            typename basic_data_object<String, Allocator>::template
                array_container<typename A::value_type>
            > *
        ) ->
            std::integral_constant<
                bool,
                std::is_same<
                    A,
                    typename basic_data_object<String, Allocator>::template
                        array_container<typename A::value_type>
                >::value
            >{}
    template<typename A>
    static std::false_type test(...);
    using type = decltype(test<T>(nullptr));
    static const bool value = type::value;
};

Изменить: этот ответ работает только из-за ошибки в GCC 4.8.1.

Ваш код работает должным образом, если вы опустите ключевое слово template в своей специализации:

template <typename String, template<class> class Allocator, typename T>
struct get_data_object_value
{
    void foo() { std::cout << "general" << std::endl; }
};

template <typename String, template<class> class Allocator, typename T>
struct get_data_object_value
<String, Allocator,
typename basic_data_object<String, Allocator>::array_container<T>>
//                                         ^^^^^^ no template!
{
    void foo() { std::cout << "special" << std::endl; }
};

Пример, протестированный с GCC 4.8.1:

int main()  {
    get_data_object_value<std::string,std::allocator,std::vector<int>> obj;
    obj.foo(); // prints "special"
}