C++ variadic template arguments: object is not forwarded as a reference

Question

Let's say I have the following code:

#include <iostream>

struct NotCopyable
{
    std::string value;

    NotCopyable(const std::string& str) :
        value(str)
    {
    }
    
    // This struct is not allowed to be copied.
    NotCopyable(const NotCopyable&) = delete;
    NotCopyable& operator =(const NotCopyable&) = delete;
};

struct Printable
{
    NotCopyable& nc;

    // This struct is constructed with a reference to a NotCopyable.
    Printable(NotCopyable& inNc) :
        nc(inNc)
    {
    }

    // So that std::cout can print us:
    operator const char*() const
    {
        return nc.value.c_str();
    }
};

// This function constructs an object of type T,
// given some arguments, and prints the object.
template<typename T, typename... ARGS>
void ConstructAndPrint(ARGS... args)
{
    T object(std::forward<ARGS>(args)...);
    std::cout << "Object says: " << object << std::endl;
}

int main(int, char**)
{
    // Create a NotCopyable.
    NotCopyable nc("123");

    // Try and construct a Printable to print it.
    ConstructAndPrint<Printable>(nc);    // "Call to deleted constructor of NotCopyable"
    
    // OK then, let's make absolutely sure that we're forwarding a reference.
    NotCopyable& ncRef = nc;

    // Try again.
    ConstructAndPrint<Printable>(ncRef); // "Call to deleted constructor of NotCopyable"
}

It seems that the NotCopyable isn't being forwarded properly as a reference, even when I explicitly supply a reference variable as the argument. Why is this? Is there any way I can ensure that a reference is forwarded, and not a copy-constructed object?

Answer 1

template<typename T, typename... ARGS>
void ConstructAndPrint(ARGS... args);

take argument by value, so does copy.

You want forwarding reference instead:

// This function constructs an object of type T,
// given some arguments, and prints the object.
template<typename T, typename... ARGS>
void ConstructAndPrint(ARGS&&... args)
{
    T object(std::forward<ARGS>(args)...);
    std::cout << "Object says: " << object << std::endl;
}