Optimization code for a debug function (c++11 with templates)

Question

I've created this debug "function", without knowing how to use templates. So I was wondering if there is a easier way to obtain the same result. If someone know any function that i don't know that can help me, let me know. And if you need help to understand something, just ask :)

//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;
}

Perhaps describing the expected behavior of `debug()` might help... — Stefano Sanfilippo, Oct 29 '14 at 22:27
Please describe intuitively what the respective functions do. — sfrehse, Oct 29 '14 at 22:29
@sfrehse: what ? `FN`, and `a`, `b`, `c`, `d`, .. are not self explanatory ? — Jarod42, Oct 29 '14 at 22:36
This question appears to be off-topic because it is about pasting hundreds of lines of code without any reasonable explanation — Alex Celeste, Oct 30 '14 at 02:13

score 0 · Accepted Answer · edited May 23 '17 at 12:20

std::forward_list::max_size returns the maximum number of elements that the forward_list container can hold.

Your forward list implementation should be:

//Forward list
template<>
struct F22<true>{
    template<typename T>
    static void F23(const string& name, const T& a){
        std::size_t i = 0;
        for (const auto& e : a) {
            std::cout << name << "[" << i << "]: " << e << std::endl;
            ++i;
        }
    }
};

BTW, I propose this implementation for the debug function.

You may also be interested by pretty-print-c-stl-containers

Optimization code for a debug function (c++11 with templates)

1 Answers1