c++11 how to implement `std::string ToString(std::tuple &t)`?

Question

I want a very friendly ToString function for many types, include the std::tuple. The function is like this:

template <typename T>
inline std::string ToString(const T &t) { 
    std::stringstream ss;
    ss << t;
    return ss.str();
}

template <typename... Args>
inline std::string ToString(const std::tuple<Args...> &t) {
    std::stringstream ss;
    for (int i = 0; i < t.size(); i++) {
        ss << ToString(std::get<i>(t)) << " ";
    }
    return ss.str();
}

The second part is wrong on grammar, how to implement it with c++11 template ?

And, how to implement the FromString like this:

template <typename T>
inline T FromString(const std::string &s) {
    std::stringstream ss(s);
    T t;
    ss >> t;
    return t;
}

template <typname... Args>
inline std::tuple<Args...> FromString(const std::string &s) {
    std::tuple<Args...> ret;
    ret.resize(sizeof...Args);
    std::stringstream ss;
    size_t pos;
    for (int i = 0, prev_pos = 0; i < sizeof...Args and prev_pos < s.length(); i++) {
        pos = s.find(" ", prev_pos);
        T t = FromString(s.substr(prev_pos, pos));
        std::get<i>(ret) = t;
        prev_pos = pos
    }
    return ret;
}

The second part is also wrong on c++11 grammar, how to implement it ?

Templates are *compile time only*. You can not use run-time variables as template arguments. To solve this I recommend you have a helper-function which takes a parameter pack, and you [unpack the tuple](https://stackoverflow.com/questions/7858817/unpacking-a-tuple-to-call-a-matching-function-pointer) in a call to that helper function. — Some programmer dude, Jul 13 '17 at 13:29
In template metaprogramming, iteration is usually done using recursion. — François Andrieux, Jul 13 '17 at 13:32
I'm not good at c++ template, so I'm not sure how to write the code exactly... would you show me the code ? — linrongbin, Jul 13 '17 at 13:38

Jarod42 · Accepted Answer · 2017-07-14T13:29:14.227

8

In C++17, you may do:

template <typename ... Ts>
std::string ToString(const Ts& ... ts) { 
    std::stringstream ss;
    const char* sep = "";
    ((static_cast<void>(ss << sep << ts), sep = " "), ...);
    return ss.str();
}

template <typename... Args>
std::string ToString(const std::tuple<Args...> &t) {
    return std::apply([](const auto&... ts) { return ToString(ts...); }, t);
}

Demo

edited Jul 14 '17 at 13:29

answered Jul 13 '17 at 14:06

Jarod42

203,559
14
181
302

@Holt Trailing whitespace – Passer By Jul 13 '17 at 15:01
@PasserBy Original version did not remove the trailing whitespace, updated one does though ;) – Holt Jul 13 '17 at 15:33
does `boost::apply_visitor` do the same thing? it doesn't require c++17 – linrongbin Jul 13 '17 at 23:58
[en.cppreference](http://en.cppreference.com/w/cpp/utility/apply) provides possible implementation. `boost::apply_visitor` is to visit `variant`. – Jarod42 Jul 14 '17 at 00:22
@zhaochenyou Even if it does, [fold expressions](http://en.cppreference.com/w/cpp/language/fold) require C++17. – Holt Jul 14 '17 at 11:58
@Jarod42 Could you detail the behavior of this particular fold expression? I am very intrigued. – Holt Jul 14 '17 at 11:58
Because I'm a git, `struct evil { friend evil operator<<( std::ostream& os, evil ) { return {}; } template friend void operator,(evil, X&&){ exit(-1); } }` and `ToString( evil{} )`; always do a `void` cast before using `,` in generic code. – Yakk - Adam Nevraumont Jul 14 '17 at 13:06
1

@Holt: Fold expression with operator comma: `ss << sep << ts;` followed by `sep = " "` for each `ts`. – Jarod42 Jul 14 '17 at 13:30
Note that in compliant C++ compilers, you can replace `(static_cast(ss << sep << ts), sep = " ")` with `[&]{ss << sep << ts); sep = " ";}()`, which I think is clearer; the downside is that many compilers will fail to work, as they erronously cannot work out that the pack expansion (of `ts...`) occurs outside of the lambda, and generate an error saying tha `ts` is not expanded. – Yakk - Adam Nevraumont Jul 14 '17 at 13:48

Yakk - Adam Nevraumont · Answer 2 · 2017-07-13T15:53:33.790

namespace notstd {
  template<std::size_t...Is>
  struct index_sequence {};
  template<std::size_t N, std::size_t...Is>
  struct make_index_sequence:make_index_sequence<N-1,N-1,Is...>{};
  template<std::size_t...Is>
  struct make_index_sequence<0,Is...>:index_sequence<Is...>{};

#define RETURNS(...) \
  noexcept(noexcept(__VA_ARGS__)) \
  -> decltype(__VA_ARGS__) \
  { return __VA_ARGS__; }

  namespace details {
    template<class F, class Tuple, std::size_t...Is>
    auto apply( F&& f, Tuple&& tuple, index_sequence<Is...> )
    RETURNS( std::forward<F>(f)( std::get<Is>(std::forward<Tuple>(tuple))... ) )
    template<class Tuple>
    using raw_tuple = typename std::remove_cv<typename std::remove_reference<Tuple>::type>::type;
    template<class Tuple>
    using tuple_count = std::tuple_size< raw_tuple<Tuple> >;
  }
  template<class F, class Tuple>
  auto apply( F&& f, Tuple&& tuple )
  RETURNS(
    ::notstd::details::apply(
      std::forward<F>(f),
      std::forward<Tuple>(tuple),
      ::notstd::make_index_sequence<
        ::notstd::details::tuple_count<Tuple>::value
      >{}
    )
  )
}

now this ::notstd::apply behaves a lot like C++17's std::apply.

We then glue this to your ToString via ToStream:

struct to_stream_t;

template<class...Args>
void ToStream(std::ostream& os, const std::tuple<Args...>& t) {
  os << '{';
  ::notstd::apply( to_stream_t{os}, t );
  os << '}';
}
inline void ToStream(std::ostream&) {}
template<class T>
void ToStream(std::ostream& os, const T& t) { 
  os << t;
}
template<class T0, class... Ts>
void ToStream(std::ostream& os, const T0& t0, const Ts& ... ts) { 
  ToStream(os, t0);
  using discard=int[];
  (void)discard{0,((
    void(os << ' '), to_stream_t{os}(ts)
  ),0)...};
}
struct to_stream_t {
  std::ostream& os;
  template<class...Args>
  void operator()(Args const&...args) const {
    ToStream(os, args...);
  }
};
template<class...Ts>
std::string ToString( Ts const&... ts ) {
  std::stringstream ss;
  ToStream( ss, ts... );
  return ss.str();
}

this also flattens recursive tuples.

If you add more std or fundamental type manual ToStream implementations, put them before the body of to_stream_t or recursion won't work. And recurse via to_stream_t{os}(t) instead of ToStream(os, t) generally so you find the right overloads.

Test code:

std::tuple<std::string, std::string, int> t("hello", "world", 42);
std::cout << ToString(t, "-", t);

Live example.

We can augment with vector support:

template<class T, class A>
void ToStream(std::ostream& os, const std::vector<T, A>& v) {
  os << '[';
  for (auto const& x:v)
  {
    if (std::addressof(x) != v.data())
        os << ',';
    to_stream_t{os}(x);
  }
  os << ']';
}

then test with all of this:

std::tuple<std::string, std::string, int> t("hello", "world", 42);
std::cout << ToString(t, "-", t) << "\n";
std::vector< int > v {1,2,3};
std::cout << ToString(v) << "\n";
std::vector< std::tuple<int, int> > v2 {{1,2},{3,4}};
std::cout << ToString(v2) << "\n";
auto t2 = std::tie( v, v2 );
std::cout << ToString(t2) << "\n";

Live example.

The end output is:

{hello world 42} - {hello world 42}
[1,2,3]
[{1 2},{3 4}]
{[1,2,3] [{1 2},{3 4}]}

as expected.

@holt typos fixed. I transitions from `ToStream` to `ToStream` to remove temporary `std::string`s and missed some stuff. — Yakk - Adam Nevraumont, Jul 13 '17 at 15:36
@holt It was required for `ToStream` to support that if I wanted to support recursive tuples. And not supporting that sucks! — Yakk - Adam Nevraumont, Jul 13 '17 at 15:38
@holt There might be a lookup problem; the `to_stream_t` moves the point where we do lookup on `ToStream` inside `to_stream_t` to *after* every `ToStream` is declared. If I use a lambda, I'd need ADL to find `ToStream`s declared *after* the lambda. I could use an ADL token, but that is annoying. `to_stream_t` seems easier. — Yakk - Adam Nevraumont, Jul 13 '17 at 15:42
Did not realize you posted earlier :P BTW yours is about a billion times nicer — Passer By, Jul 13 '17 at 15:59
@holt And what do you do when you want vector and tuple to mutually recurse on their contents? Yet more repeating oneself. I'd rather repeat myself once. — Yakk - Adam Nevraumont, Jul 13 '17 at 17:44

Passer By · Answer 3 · 2017-07-13T15:56:01.423

In C++11 you may ~~want to give up~~ do this

#include<iostream>
#include<tuple>
#include<utility>
#include<sstream>

template<size_t... I>
struct index_sequence {};

template<size_t N, size_t sz, size_t... I>
struct make_index_sequence_
{
    using type = typename make_index_sequence_<N, sz + 1, I..., sz>::type;
};

template<size_t N, size_t... I>
struct make_index_sequence_<N, N, I...>
{
    using type = index_sequence<I...>;  
};

template<size_t N>
using make_index_sequence = typename make_index_sequence_<N, 0>::type;

template<typename Fn, typename Tuple, size_t... I>
auto apply_(Fn&& fn, Tuple&& tup, index_sequence<I...>) -> decltype(fn(std::get<I>(tup)...))
{
    return fn(std::get<I>(tup)...);
}

template<typename Fn, typename Tuple>
auto apply(Fn&& fn, Tuple&& tup) -> decltype(apply_(std::forward<Fn>(fn), std::forward<Tuple>(tup), make_index_sequence<std::tuple_size<typename std::remove_reference<Tuple>::type>::value>{}))
{
    return apply_(std::forward<Fn>(fn), std::forward<Tuple>(tup), make_index_sequence<std::tuple_size<typename std::remove_reference<Tuple>::type>::value>{});
}

All those above is re-implementing the standard library in newer C++.

template<typename T>
std::string ToString(const T& t)
{ 
    std::stringstream ss;
    ss << t;
    return ss.str();
}

template<typename T, typename... Ts>
std::string ToString(const T& t, const Ts&... ts)
{
    return ToString(t) + ToString(ts...);   
}

template<typename... Ts>
std::string ToString(const std::tuple<Ts...>& tup)
{
    return apply<std::string (*)(const Ts&...)>(ToString, tup);   
}

And these are the real logic.

Live

Gave me appreciation on a whole new level just how great syntax sugar is.

c++11 how to implement `std::string ToString(std::tuple &t)`?

3 Answers3

Linked