Как выполняется специализация вложенных шаблонов C++

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

#include <functional>
#include <iostream>
#include <type_traits>
#include <vector>
#include <array>

template <class T>
struct tag{};

template<typename TObject> 
TObject Deserialize_impl(long version, tag<TObject>) {
    std::cerr << "generic\n";
    return {};
}

template<typename T, std::size_t N> 
std::array<T,N> Deserialize_impl(long version, tag<std::array<T,N>>) {
    std::cerr << "special\n";
    return {};
}

template<typename TObject> 
TObject Deserialize(long version) {
    return Deserialize_impl(version, tag<TObject>{});
}


int main() {
    Deserialize<int>(0);
    Deserialize<std::array<int,3>>(0);

    return 0;
}

Живой пример: http://coliru.stacked-crooked.com/a/9c4fa84d2686997a

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

Хотя функциональная отправка тегов — хороший подход, вот версия специализации класса для сравнения. И то, и другое имеет свое применение, и я не думаю, что какое-либо из этих решений является прискорбным по своей сути, но, возможно, одно из них больше соответствует вашему личному стилю. Для любого написанного вами класса, которому требуется собственный обработчик десериализации, просто напишите специализацию класса Deserializer:

#include <iostream>
#include <string>
using namespace std;

using Value = std::string;

// default deserialize function 
template <typename TObject>
struct Deserializer {
    static TObject deserialize(long version, const Value &value) {
        std::cout << "default impl\n";
        return TObject();
    }
};

// free standing function (if you want it) to forward into the classes
template <typename TObject>
TObject deserialize(long version, const Value &value) {
    return Deserializer<TObject>::deserialize(version, value);
}

// Stub example for your Vec class
template<typename TNum, int cnt> class Vec { };

// Stub example for your Vec deserializer specialization
template <typename TNum, int cnt> struct Deserializer<Vec<TNum, cnt>> {
    static auto deserialize(long version, const Value &value) {
        std::cout << "specialization impl: cnt=" << cnt << "\n";
        return Vec<TNum, cnt>();
    }
};

int main() {
    Value value{"abcdefg"};
    long version = 1;

    deserialize<int>(version, value);
    deserialize<Vec<int, 10>>(version, value);
}

В идеале в этой ситуации Vec должен отражать собственные параметры шаблона в виде элементов Vec::value_type и Vec::size(), которые должны быть constexpr.

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

template< typename >
struct vector_traits;

template< typename TNum, int cnt >
struct vector_traits< Vec< TNum, cnt > > {
    typedef TNum value_type;
    constexpr static int size = cnt;
};

template<typename TVec> TVec Deserialize(long version, Value &value) {
    typedef vector_traits< TVec > traits;
    typedef typename traits::value_type TNum;
    constexpr static int cnt = traits::size;
    …
}

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