Template with fold expression creates unwanted parameter copy

Question

The following prototype is intended to make synchronized print:

#include <iostream>
#include <string>
#include <sstream>
#include <mutex>
#include <Windows.h>    // for OutputDebugString

std::mutex sync_mutex;

template<typename T>
void sync_print_impl(std::ostringstream& str, const T& t)
{
    str << t << " ";
}

template<typename ... Args>
void sync_print_impl(std::ostringstream& str, Args ... args)
{
    str; // prevents unused variable warning when sync_print is called without arguments
    (..., sync_print_impl(str, args));
}

template <typename... Args>
void sync_print(Args... args)
{
    std::ostringstream s;
    sync_print_impl(s, args...);

    {
        std::lock_guard<std::mutex> lg(sync_mutex);
        std::cout << s.str() << std::endl;
    }
}

Simple test is OK:

void test1()
{
    sync_print("abc", 1, 5.5);  // prints abc 1 5.5
    sync_print();               // prints empty string
}

The following test shows, that parameters are copied:

class test_class
{
public:
    test_class(int n)
        : data(n)
    {
        OutputDebugString(L"test_class\n");
    }

    test_class(const test_class& other)
    {
        data = other.data; 
        OutputDebugString(L"copy constructor\n");
    }

    test_class& operator=(const test_class& other)
    {
        data = other.data; 
        OutputDebugString(L"operator=\n");
        return *this;
    }

    ~test_class()
    {
        OutputDebugString(L"~test_class\n");
    }

    friend std::ostream& operator<<(std::ostream& os, const test_class& t);

private:
    int data{};
};

std::ostream& operator<<(std::ostream& os, const test_class& t)
{
    os << t.data;
    return os;
}

void test2()
{
    test_class t(5);
    sync_print(t);    // prints 5
}

OutputDebugString result is:

test_class
copy constructor
~test_class
~test_class

How to change sync_print to ensure that parameters are passed by reference?

Answer 1

You do not need extra template function sync_print_impl. Following should be enough, as you can make use of c++17 's fold expression.

In addition, use perfect forwarding to avoid coping the object.

template<typename... Args>
void sync_print_impl(std::ostringstream& str, Args&&... args)
//                                            ^^^^^^^^^^^^^^^^
{
    ((str << std::forward<Args>(args) << " "), ...);
}

template <typename... Args>
void sync_print(Args&&... args)
//              ^^^^^^^^^^^^^^^
{
    std::ostringstream s;
    sync_print_impl(s, std::forward<Args>(args)...);
    //                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^    
    // ... code
}