How to realize template class type in template function?

Question

I want to design a print function for STL container, include: std::vector, std::map, std::unodered_map, std::set, std::unordered_set, std::list ....

The ideal function looks like:

template<typename T>
void Show(const T& t)
{
    if (istype(t, std::vector)) 
    {  
        // here is a presudo code
        // print vector
        for (auto i: t) cout << i << endl;
    } 
    else if (istype(t, std::unordered_map)) 
    {
        // print unordered_map
    } 
    else 
    {  }
}

I think the problem happens on istype()

I know there is some function like std::is_same can do this.

But it seems it just can operate on int or float, cant be operated on std::vector, can you help on this?

Answer 1

But it seems it just can operate on int or float, cant be operated on std::vector, can you help on this?

For template classes like stranded containers, you need to specify the template argument to get the concrete type and thereafter you can compare usingstd::is_same. That means something like std::is_same_v<T, std::vector<int>> or std::is_same_v<T, std::vector<float>>, etc... will work.

On the other side, you need to see whether the passed container is a specialization for the standard container. There you need your own std::is_same_v like type traits.

One possible implementation will look like as follows. Also note that you need to use the if constexpr (since c++17) instead of normal if for compile time branching. If no access to c++17, you need to use SFINAE.

(See a Demo)

#include <iostream>
#include <type_traits> // std::false_type, std::true_type
#include <vector>
#include <list>
#include <string>
#include <map>

template<typename Type, template<typename...> class Args>
struct is_specialization final : std::false_type {};

template<template<typename...> class Type, typename... Args>
struct is_specialization<Type<Args...>, Type> : std::true_type {};


template<typename ContainerType>
constexpr void show(const ContainerType& container) noexcept
{
    if constexpr (is_specialization<ContainerType, std::vector>::value
                || is_specialization<ContainerType, std::list>::value)
    {  
        for (const auto ele : container)
            std::cout << ele << '\t';
        std::cout << '\n';
    }
    else if constexpr (is_specialization<ContainerType, std::map>::value)
    {
        for (const auto& [key, value]: container)
            std::cout << key << " " << value << '\t';
        std::cout << '\n';
    }
    // ... so on!
}

int main()
{
    std::vector<int> vec{ 1, 2, 3 };
    show(vec);

    std::list<int> list{ 11, 22, 33 };
    show(list);

    std::map<int, std::string> mp{ {1, "string1"}, {2, "string2"}, {3, "string3"} };
    show(mp);
}

Answer 2

Common feature of all STL containers is that they are iterable in range [begin(),end()). For sequence containers you have to handle printing T as value_type, for (Unordered) associative containers printing std::pair<const Key, T> as value_type must be handled. That is all. I don't see any reasons to checking type of passed container in your implemention.

template<class T>
void Print(const T& val) {
    std::cout << val;
}

template<class Key, class Value>
void Print(const std::pair<const Key,Value>& p) {
    Print(p.first);
    std::cout << " - ";
    Print(p.second);
}

template<class Cont>
void PrintCont(const Cont& cont) {
    std::cout << std::endl;
    for (auto it = cont.begin(); it != cont.end(); ++it) {
        Print(*it);
        std::cout << " ";
    }
    std::cout << std::endl;
}

    std::array<int,2> a{1,2};
    std::vector<int> v{1,2,3};
    std::list<double> l{2., 3., 5.4};
    std::map<int,double> m{ {1,2.},{10,3.14} };
    std::multimap<int,int> m2{ {2,3},{4,5} };
    std::set<float> s{1.f, 23.f, 2.f};
    std::unordered_map<int,Foo> m3{ {1,Foo(1)}, {2,Foo(2)}, {3,Foo(3)}}; 
    PrintCont(a);
    PrintCont(v);
    PrintCont(l);
    PrintCont(m);
    PrintCont(a);
    PrintCont(s);
    PrintCont(m2);
    PrintCont(m3);

Live demo