writeln() and format() with variadic templates

Question

I wanted to get better acquainted with variadic templates, so I decide to try to implement a function like D's writeln(), just for fun.

void writeln()
{
    std::cout << "\n";
}

template<typename T, typename ...Args>
void writeln(T firstArg, Args... extraArgs)
{
    std::cout << firstArg;
    writeln(std::forward<Args>(extraArgs)...);
}

Usage example:

writeln("hello ", "world ", 42, "\t", 3.141592);
writeln(); // prints just a newline

Next, I implemented a format() function, which writes to a string instead of cout:

// Need this because there is no to_string for string in the std namespace.
std::string to_string(const std::string & s)
{
    return s;
}

std::string format()
{
    return "";
}

template<typename T, typename ...Args>
std::string format(T firstArg, Args... extraArgs)
{
    using namespace std;
    std::string s = to_string(firstArg);
    s += format(std::forward<Args>(extraArgs)...);
    return s;
}

// sample:
std::string s = format("hello ", "world ", 42, "\t", 3.141592);

It is uses std::to_string() for the native types. If I want to print custom types, then I can define a local to_string() and the overload resolution should find it.

My concerns are:

1. I haven't had many chances to use variadic templates so far, so I might be missing some caveat here. I was expecting it to be more complicated... Did I miss some corner case?

2. Is my use of std::forward appropriate?

3. Any other comments and suggestion are very welcome.

Answer 1

The biggest thing that sticks out at me is that you're passing all of your Args... parameters by value, thus pretty much making std::forward useless here. To make use of std::forward, the reference type needs to be deduced from the calling context. By itself, std::forward really doesn't do anything except a static_cast to the deduced reference type.

Basically, everywhere you have Args should be passed by Args&&:

template<typename T, typename ...Args>
void writeln(T firstArg, Args&&... extraArgs)

template<typename T, typename ...Args>
std::string format(T firstArg, Args&&... extraArgs)

As a cut down example of the difference this makes, try this example:

#include <memory>
#include <iostream>

struct s
{
    s()
    { }
    
    s(s&& )
    {
        std::cout << "Move\n";
    }
    
    s(const s& )
    {
        std::cout << "Copy\n";
    }
};

template <typename T>
void do_forward(T&& v)
{
    sink(std::forward<T>(v));
}

template <typename U>
void sink(U&& u)
{
    std::cout << "In sink\n";
}

int main()
{
    s something;
    do_forward(something);
}

If I run this, the output is:

In sink

If I change the signature of do_foward and sink to:

template <typename T>
void do_forward(T v)

template <typename U>
void sink(U u)

The output is:

Copy

Move

In sink

If we change main to just pass an actual rvalue reference instead of an lvalue:

int main()
{
    do_forward(s{});
}

We remove the first copy operation (from do_forward) but still have a move operation (in sink).

Answer 2

Just a minor point as an addendum to Yuushi's answer, but instead of having separate functions for std::string and std::cout, you could instead modify it to use a generic stream class, for instance:

std::ostream& writeln( std::ostream& outStream )
{
    outStream << std::endl;
    return outStream;
}

template <typename T, typename... Args>
std::ostream& writeln( std::ostream& outStream, T tFirstArg, Args&&... args )
{
    outStream << tFirstArg;
    return writeln( outStream, std::forward<Args>(args)... );
}

You can then use this to write a line to a file by passing a std::ofstream to writeln, to the output stream by passing std::cout, or to a string by using std::ostringstream as

// Print output to screen:
writeln( std::cout, "hello ", "world ", 42, "\t", 3.141592f );

// Print output to a file, "testfile.txt":
std::ofstream outFile( "testfile.txt" );
if( outFile.good() )
{
    writeln( outFile, "hello ", "world ", 42, "\t", 3.141592f );
}

// Get a string using writeln function:
std::ostringstream ssOutStringStream;
writeln( ssOutStringStream, "hello ", "world ", 42, "\t", 3.141592f );
std::string strOutput = ssOutStringStream.str();