C ++ Сделать вызов функции зависимым от параметра шаблона

Question

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

Код выглядит так:

#include <array>
#include <iostream>
#include <string>

template <typename T>
void serialize(const T &data)
{
    size_t data_size = getSize(data);
    std::cout << "Size: " << data_size << std::endl;
}

constexpr size_t getSize(const int &)
{
    return sizeof(int);
}

size_t getSize(const std::string &str)
{
    return str.size();
}

template <typename T, size_t N>
size_t getSize(const std::array<T, N> &array)
{
    size_t array_size = 0;
    for (const T &element : array)
        array_size += getSize(element);
    return array_size;
}

int main()
{
    int a;
    serialize(a);

    std::string str = "foo";
    serialize(str);

    std::array<std::string, 2> arr = {{"foo", "foobar"}};
    serialize(arr);

    return 0;
}

Есть ли хороший способ сделать getSize() зависимым? Или есть другие способы добиться этого?

Answer 1

Вы можете добавить фиктивный тег, чтобы разрешить ADL:

template <typename T> struct tag {};

template <typename T>
void serialize(const T &data)
{
    size_t data_size = getSize(data, tag<T>{});
    std::cout << "Size: " << data_size << std::endl;
}

constexpr size_t getSize(const int &, tag<int>)
{
    return sizeof(int);
}

size_t getSize(const std::string &str, tag<std::string>)
{
    return str.size();
}

template <typename T, size_t N>
size_t getSize(const std::array<T, N> &array, tag<std::array<T, N>>)
{
    size_t array_size = 0;
    for (const T &element : array)
        array_size += getSize(element, tag<T>{});
    return array_size;
}

Демо

Answer 2

Вы можете сделать getSize() членом вспомогательной структуры:

template <typename T>
struct size_getter {
    static size_t getSize( T );
};

template <typename T>
void serialize(const T &data)
{
    size_t data_size = size_getter<T>::getSize( data );
    std::cout << "Size: " << data_size << std::endl;
}

затем специализируйте их:

template<>
struct size_getter<std::string> {
    static size_t getSize( const std::string &s )
    {
        return s.size();
    }
};

template <typename T, size_t N>
struct size_getter<std::array<T, N>>
{
    static size_t getSize(const std::array<T, N> &array)
    {
        size_t array_size = 0;
        for (const T &element : array)
            array_size += size_getter<T>::getSize(element);
        return array_size;
    }
};

Живой пример