调试函数的优化代码(带有模板的c++11）

我创建了这个调试"函数"，但不知道如何使用模板。所以我想知道是否有更容易的方法来获得同样的结果。如果有人知道任何我不知道的功能，可以帮助我，请告诉我。如果你需要帮助来理解一些东西，只需问：）

//Containers
#include <array>
#include <deque>
#include <forward_list>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <vector>
//Input/Output
#include <iostream>
//Other
#include <algorithm>
#include <bitset>
#include <chrono>
#include <complex>
#include <exception>
#include <functional>
#include <initializer_list>
#include <iterator>
#include <limits>
#include <locale>
#include <memory>
#include <new>
#include <numeric>
#include <random>
#include <ratio>
#include <regex>
#include <stdexcept>
#include <string>
#include <system_error>
#include <tuple>
#include <typeindex>
#include <typeinfo>
#include <utility>
#include <valarray>
using namespace std;
template<bool b> struct F22{};
//Else (Just maps left IMHO)
template<>
struct F22<false>{
    template<typename T>
    static void F23(string name, T a){
        auto t = a;
        int i=0;
        for (auto it=t.begin(); it!=t.end(); ++it)
            cout << it->first << " => " << it->second << endl;
    }
};
//Forward list
template<>
struct F22<true>{
    template<typename T>
    static void F23(string name, T a){
        for (int n( a.max_size() ) , i(0); i < n; i++)
            cout << name << "[" << i << "]: " << *(next(a.begin(),i)) << endl;
    }
};
//Check if is a forward list
template<typename A>
struct F20{
    template<typename T>
    static void F21(string name, T t){
        F22< is_same< T,forward_list<A> >::value >::F23(name,t);
    }
};
template<bool b> struct F18{};
//!(Vector, list, deque or set)
template<>
struct F18<false>{
    template<typename T>
    static void F19(string name, T a){
        F20<typename T::value_type>::F21(name,a);
    }
};
//Vector, list, deque or set
template<>
struct F18<true>{
    template<typename T>
    static void F19(string name, T a){
        for (int n( a.size() ) , i(0); i < n; i++)
            cout << name << "[" << i << "]: " << *(next(a.begin(),i)) << endl;
    }
};
//Check if is a vector, list, deque or a set
template<typename A>
struct F16{
    template<typename T>
    static void F17(string name, T t){
        F18< is_same< T,vector<A> >::value || is_same< T,list<A> >::value || is_same< T,deque<A>  >::value || is_same< T,set<A>  >::value >::F19(name,t);
    }
};
template<bool b> struct F14{};
//Queue
template<>
struct F14<true>{
    template<typename T>
    static void F15(string name, T a){
        auto t = a;
        int i=0;
        while(!t.empty()){
            cout << name << "[" << i << "]: " << t.front() << endl;
            t.pop();
            i++;    
        }
    }
};
//Not queue
template<>
struct F14<false>{
    template<typename T>
    static void F15(string name, T a){
        F16<typename T::value_type>::F17(name,a);
    }
};
//Check if is a queue
template<typename A>
struct F12{
    template<typename T>
    static void F13(string name, T t){
        F14< is_same< T,queue<A> >::value >::F15(name,t);
    }
};
template<bool b> struct F10{};
//Stack
template<>
struct F10<true>{
    template<typename T>
    static void F11(string name, T a){
        auto t = a;
        int i=0;
        while(!t.empty()){
            cout << name << "[" << i << "]: " << t.top() << endl;
            t.pop();
            i++;    
        }
    }
};
//Not stack
template<>
struct F10<false>{
    template<typename T>
    static void F11(string name, T a){
        F12<typename T::value_type>::F13(name,a);
    }
};
//Check if is a stack
template<typename A>
struct F8{
    template<typename T>
    static void F9(string name, T t){
        F10< is_same< T,stack<A> >::value >::F11(name,t);
    }
};
template<bool b> struct F6{};
//is_scalar
template<>
struct F6<true>{
    template<typename T>
    static void F7(string name, T t){
        cout << name << ": " << t << endl;
    }
};
//is_not_scalar
template<>
struct F6<false>{
    template<typename T>
    static void F7(string name, T a){
        F8<typename T::value_type>::F9(name,a);
    }
};
//Controls if it's a scalar type
template<int N>
struct F4{
    template<typename T>
    static void F5(vector<string> vec,T t){
        F6< is_scalar < T > ::value >::F7(vec[N],t);
    }
};
//This split the args
template<int N,int M>
struct F3{
    template<typename T>
    static void F2(vector<string> vec,T const& args){
        if(N>=0){
            F4<N>::F5(vec,get<N>(args));
        }
        if(N<M){
            F3<N+1,M>::F2(vec,args);
        }
    }
};
//F3's loop's end
template<int M>
struct F3<M,M>{
    template<typename T>
    static void F2(vector<string> vec,T const& args){
    }
};
//This split the names in a vector<string>
template<typename ... T>
void F1(const char* nomi,tuple<T...> const& args){
    vector<string> vec;
    istringstream is(nomi);
    for(string buF4er;getline(is,buF4er,',');){
        vec.push_back(buF4er);
    }
    F3<0,tuple_size<tuple<T...>>::value>::F2(vec,args);
}
#define debug(...) F1(#__VA_ARGS__, tie(__VA_ARGS__))
int main(){
    int a = 1;
    float b = 2;
    vector<int> c; c.push_back(3);
    deque<int> d; d.push_back(4);
    stack<float> e; e.push(5);
    queue<double> f; f.push(6);
    map<char,int> g; g['g']=7;
    forward_list<int> h; h.push_front(8);
    set<int> i; i.insert(9);
    debug(a,b,c,d,e,f,g,i); //with h, in my pc crashes
    return 0;
}