Overloading output << operator for a class to print the tuple inside it [duplicate]

Question

So If I have something like this

template<typename... Args >
class tuple_class
{
  public:
  std::tuple<Args...> tup;

/*I left out the other functions */
};

I want to overload the operator<< so that it will recursively print the tuple when called on the class.

ex.

auto a = tuple_class(1, 2 ,3);
std::cout << a << endl;

would hopefully print '123'

Ive seen other examples of tuple printers but I can't apply it to my class without having a bunch of trouble

I think I should start with a member function like this

  template<typename... Args>
  friend std::ostream& operator<<(std::ostream& os, const my_tuple<Args...> &m);

and then the actual function outside the class

template<typename... Args>
std::ostream& operator<<(std::ostream& os, const my_tuple<Args...> &m)
{
   os << "SOMETHING" << std::endl;
   return os;
}

That actually worked when I call the << operator on my class. But I have no clue how to make it actually print the tuple.

Any help would be appreciated

Answer 1

To build solution I used tuple print code from cppreference mentioned here this. Rest of the code is glue to keep things together. Here I put working sample.

#include <tuple>
#include <iostream>
#include <string>

// tuple printer
template<class Tuple, std::size_t N>
struct TuplePrinter {
    static std::ostream& print(std::ostream& os, const Tuple& t)
    {
        TuplePrinter<Tuple, N - 1>::print(os, t);
        os << ", " << std::get<N - 1>(t);
        return os;
    }
};

template<class Tuple>
struct TuplePrinter<Tuple, 1> {
    static std::ostream& print(std::ostream& os, const Tuple& t)
    {
        os << std::get<0>(t);
        return os;
    }
};

template<class... Args>
std::ostream& print(std::ostream& os, const std::tuple<Args...>& t)
{
    os << "(";
    TuplePrinter<decltype(t), sizeof...(Args)>::print(os, t);
    os << ")\n";
    return os;
}


// class to keep tuple inside
template<typename... Args>
class tuple_class {
    template<typename... Args2>
    friend std::ostream& operator<<(std::ostream& os, const tuple_class<Args2...> &m);

    std::tuple<Args...> tup;
public:
    tuple_class(Args&&... args) : tup(std::forward<Args>(args)...) {

    }
};

// usage of the printer
template<typename... Args>
std::ostream& operator<<(std::ostream& os, const tuple_class<Args...> &m) {
    print(os, m.tup);
    return os;
}



int main() {
    tuple_class<int,float,std::string> tc( 1,3.0f,"string" );
    std::cout << tc;
    return 0;
}