Stringify function for generic container in C++ - c++

Question

How create a generic stringify function for a generic container also for nested container e.g. map<string,vector<list<int>>>?
This is my attempt but it doesn't work.
template<class T>
string stringify(const T& c) {
int length = c.size();
string str = "[";
int i=0;
for (; i <= length-2; i++) {
str += stringfy(c[i]) + ", ";
}
str += c[i] + "]";
return str;
}

Answer 1

It is doable but mostly pointless as you would typically know what kind of data you have to process.
I managed to come up with something like this. It will work for every type that is iterable with for-each loop or a tuple, or has overloaded operator<<. You can do it without C++20 features but it will be a total SFINAE mess.
#include <iostream>
#include <string>
#include <type_traits>
#include <map>
#include <list>
#include <vector>
#include <tuple>
#include <sstream>
using namespace std;
template <typename T>
concept InterableRange = requires (T a) {
std::begin(a);
std::end(a);
};
template <typename T>
concept TupleLikeType = requires (T a) {
std::tuple_size<T>();
};
template<TupleLikeType T>
string stringify(const T& c);
template<class T>
string stringify(const T& c);
template<InterableRange T>
string stringify(const T& c) {
string str = "[ ";
auto size = std::size(c);
std::size_t i = 0;
for (const auto& elem : c) {
str += stringify(elem);
if(i++ < size - 1)
str += ", ";
}
str += " ]";
return str;
}
template<TupleLikeType T>
string stringify(const T& c) {
string str = "[ ";
auto size = std::tuple_size<T>();
std::size_t i = 0;
std::stringstream input;
auto insert = [&input, size, &i](const auto& data) {
input << stringify(data);
if(i++ < size - 1)
{
input.put(',');
input.put(' ');
}
};
std::apply([&insert](const auto&... args){
(insert(args), ...);
}, c);
str += input.str();
str += " ]";
return str;
}
template<class T>
string stringify(const T& c) {
std::stringstream input;
input << c;
return input.str();
}
int main() {
map<string,vector<list<int>>> m {
{ "1", {{1,2}, {3, 4}}},
{ "2", {{10,20}, {30, 40}}}
};
cout << stringify(m);
}
It will print
[ [ [ 1 ], [ [ 1, 2 ], [ 3, 4 ] ] ], [ [ 2 ], [ [ 10, 20 ], [ 30, 40 ] ] ] ]

Answer 2

I did a C++17 solution, the SFINAE is still bearable:
#include <iostream>
#include <set>
#include <map>
#include <string>
#include <vector>
#include <sstream>
// Forward declarations so we can have arbitrary interactions
template<class Container, class Iter = decltype(cbegin(std::declval<Container>()))> // SFINAE to get only containers
std::string stringify(const Container&c);
template<class T1, class T2>
std::string stringify(const std::pair<T1, T2> &p); // Can we get this into the tuple case?
template<class ...Ts>
std::string stringify(std::tuple<Ts...> &t);
template<class T, class = decltype(std::declval<std::stringstream>() << std::declval<T>())>
std::string stringify(T t) {
std::stringstream s;
s << t;
return s.str();
}
template<class ...Ts>
std::string stringify(std::tuple<Ts...> &t) {
const auto string_comma = [] (const auto & arg) { return stringify(arg) + ", "; };
// This prints a , too much but I am too lazy to fix that
return '(' + std::apply([&] (const auto& ...args) { return (string_comma(args) + ...); }, t) + ')';
}
template<class T1, class T2>
std::string stringify(const std::pair<T1, T2> &p) {
return '(' + stringify(p.first) + ", " + stringify(p.second) + ')';
}
template<class Iter>
std::string stringify(Iter begin, Iter end) {
std::string ret{'['};
for(; begin != end;) {
ret += stringify(*begin);
if(++begin != end) {
ret += ", ";
}
}
ret+=']';
return ret;
}
template<class Container, class Iter>
std::string stringify(const Container&c) {
return stringify(cbegin(c), cend(c));
}
int main () {
std::set<std::vector<std::map<int, char>>> v {{{{1, 'A'}, {2, 'E'}}, {{2, 'B'}}}, {{{2, 'C'}}, {{3, 'D'}}}};
std::tuple tup {1.0, "HELLO WORLD", std::pair{67, 42}};
std::cout << stringify(begin(v), end(v)) << '\n';
std::cout << stringify(tup) << '\n';
}