fork download
copy 
  1. //Containers
  2. #include <array>
  3. #include <deque>
  4. #include <forward_list>
  5. #include <list>
  6. #include <map>
  7. #include <queue>
  8. #include <set>
  9. #include <stack>
  10. #include <unordered_map>
  11. #include <unordered_set>
  12. #include <vector>
  13.  
  14. //Input/Output
  15. #include <iostream>
  16.  
  17. //Other
  18. #include <algorithm>
  19. #include <bitset>
  20. #include <chrono>
  21. #include <complex>
  22. #include <exception>
  23. #include <functional>
  24. #include <initializer_list>
  25. #include <iterator>
  26. #include <limits>
  27. #include <locale>
  28. #include <memory>
  29. #include <new>
  30. #include <numeric>
  31. #include <random>
  32. #include <ratio>
  33. #include <regex>
  34. #include <stdexcept>
  35. #include <string>
  36. #include <system_error>
  37. #include <tuple>
  38. #include <typeindex>
  39. #include <typeinfo>
  40. #include <utility>
  41. #include <valarray>
  42.  
  43. #if 1 // Not in C++11
  44.  
  45. template <std::size_t...> struct index_sequence {};
  46.  
  47. template <std::size_t N, std::size_t... Is>
  48. struct make_index_sequence : make_index_sequence<N - 1, N - 1, Is...> {};
  49.  
  50. template <std::size_t... Is>
  51. struct make_index_sequence<0u, Is...> : index_sequence<Is...> {};
  52.  
  53. #endif
  54.  
  55. namespace detail
  56. {
  57.  
  58.     template<typename T>
  59.     void debug(const std::string& name, const T& t)
  60.     {
  61.         std::cout << name << ": " << t << std::endl;
  62.     }
  63.  
  64.     template<typename T>
  65.     void debug(const std::string& name, const std::stack<T>& a) {
  66.         auto t = a;
  67.         int i = 0;
  68.         while(!t.empty()){
  69.             std::cout << name << "[" << i << "]: " << t.top() << std::endl;
  70.             t.pop();
  71.             i++;
  72.         }
  73.     }
  74.  
  75.     template<typename T>
  76.     void debug(const std::string& name, const std::queue<T>& a) {
  77.         auto t = a;
  78.         int i = 0;
  79.         while(!t.empty()){
  80.             std::cout << name << "[" << i << "]: " << t.front() << std::endl;
  81.             t.pop();
  82.             i++;
  83.         }
  84.     }
  85.  
  86.     template<typename K, typename V>
  87.     void debug(const std::string& /*name*/, const std::map<K, V>& m){
  88.         for (const auto & p : m) {
  89.             std::cout << p.first << " => " << p.second << std::endl;
  90.         }
  91.     }
  92.  
  93.     template<typename T>
  94.     void debug(const std::string& name, std::vector<T>& c) {
  95.         std::size_t i = 0;
  96.         for (const auto& e : c)
  97.             std::cout << name << "[" << i++ << "]: " << e << std::endl;
  98.     }
  99.  
  100.     template<typename T>
  101.     void debug(const std::string& name, std::set<T>& c) {
  102.         std::size_t i = 0;
  103.         for (const auto& e : c)
  104.             std::cout << name << "[" << i++ << "]: " << e << std::endl;
  105.     }
  106.  
  107.     template<typename T>
  108.     void debug(const std::string& name, std::list<T>& c) {
  109.         std::size_t i = 0;
  110.         for (const auto& e : c)
  111.             std::cout << name << "[" << i++ << "]: " << e << std::endl;
  112.     }
  113.  
  114.     template<typename T>
  115.     void debug(const std::string& name, std::forward_list<T>& c) {
  116.         std::size_t i = 0;
  117.         for (const auto& e : c)
  118.             std::cout << name << "[" << i++ << "]: " << e << std::endl;
  119.     }
  120.  
  121.     template<typename T>
  122.     void debug(const std::string& name, std::deque<T>& c) {
  123.         std::size_t i = 0;
  124.         for (const auto& e : c)
  125.             std::cout << name << "[" << i++ << "]: " << e << std::endl;
  126.     }
  127.  
  128.     template <typename Tuple, std::size_t ... Is>
  129.     void debug(const std::vector<std::string>& names, const Tuple& t, index_sequence<Is...>)
  130.     {
  131.         std::initializer_list<int>{(debug(names[Is], std::get<Is>(t)), 0)...};
  132.     }
  133.  
  134.     template<typename ... Ts>
  135.     void dispatch(const char* namesWithComma, std::tuple<Ts...> const& args){
  136.         std::vector<std::string> names;
  137.         std::istringstream is(namesWithComma);
  138.         for (std::string name; getline(is, name, ',');){
  139.             names.push_back(name);
  140.         }
  141.         detail::debug(names, args, make_index_sequence<sizeof...(Ts)>());
  142.     }
  143.  
  144. }
  145.  
  146. #define debug(...) detail::dispatch(#__VA_ARGS__, std::tie(__VA_ARGS__))
  147.  
  148. int main(){
  149.     int a = 1;
  150.     float b = 2;
  151.     std::vector<int> c{3};
  152.     std::deque<int> d{4};
  153.     std::stack<float> e; e.push(5);
  154.     std::queue<double> f; f.push(6);
  155.     std::map<char,int> g{{'g', 7}};
  156.     std::forward_list<int> h{8};
  157.     std::set<int> i{9};
  158.     debug(a,b,c,d,e,f,g,h,i);
  159.     return 0;
  160. }
  161.  
Success #stdin #stdout 0s 3444KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
a: 1
b: 2
c[0]: 3
d[0]: 4
e[0]: 5
f[0]: 6
g => 7
h[0]: 8
i[0]: 9
https://ideone.com/KOuTJO
language:
C++14 (gcc 8.3)
created:
11 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!