Issues in perfect forwarding C++

Question

This question is in continuation to question. I didn't wanted to clutter that question and so writing a new question.

After the changes suggested I made one more change. Now I created one non-copyable class and tried passing same class to Print().

#include<utility>
#include<string>
#include<tuple>
#include<sstream>

template<typename... Args> struct Helper_Class
{
    std::tuple<Args...> argTuple;
    Helper_Class(Args&&... args):
                    argTuple(std::make_tuple(std::forward<Args>(args)...))
    {}
};

template<typename... Args>  std::ostream& 
operator<< ( std::ostream& os,Helper_Class<Args...> obj)
{
    return os;  
}

struct A {
    friend int main(int argc, char **argv);
    friend std::ostream & operator<<(std::ostream &os, const A &a) {
        return os << a.i;
    }
    A(int i_) : i(i_) {}
    A(const A &) = delete;
    A &operator=(const A &) = delete;
    const int i;
};


template<typename...Args>
auto Print(Args&&... args)
{
    return Helper_Class<typename std::decay<Args>::type...>(std::forward<Args>(args)...);
    //return Helper_Class<typename std::decay<Args>::type...>(std::forward<Args>(args)...); 
}

template <typename... Ts>
void test( Ts &&...params) {
    std::stringstream s;
    s <<Print(std::forward<Ts>(params)...);
}

int main(int argc, char **argv)
{
    test(1,2,"foo", A(123));
}

But now I am getting linker error. But I should not get one as I am trying to implement move semantics.

Error I am getting is:

/tmp/cckfv4uI.o: In function `std::_Head_base<3ul, A, false>::_Head_base<A>(A&&)':
forwarding.cpp:(.text._ZNSt10_Head_baseILm3E1ALb0EEC2IS0_EEOT_[_ZNSt10_Head_baseILm3E1ALb0EEC5IS0_EEOT_]+0x2a): undefined reference to `A::A(A const&)'
collect2: error: ld returned 1 exit status

Answer 1

Since you just need a way to refer to the arguments, you don't need perfect forwarding at all. Here's an example:

#include<tuple>
#include<sstream>

template<typename Arg_Tuple> struct Helper_Class
{
    Arg_Tuple argTuple;
    Helper_Class(const Arg_Tuple &args): argTuple(args) {}
};

template<typename Arg_Tuple>  std::ostream&
operator<< ( std::ostream& os,Helper_Class<Arg_Tuple> /*obj*/)
{
    return os;
}

struct A {
    friend int main();
    friend std::ostream & operator<<(std::ostream &os, const A &a) {
        return os << a.i;
    }
    A(int i_) : i(i_) {}
    A(const A &) = delete;
    A &operator=(const A &) = delete;
    const int i;
};


template<typename...Args>
auto Print(const Args& ... args)
{
    auto args_tuple = std::tie(args...);
    return Helper_Class<decltype(args_tuple)>(args_tuple);
}

template <typename... Ts>
void test(const Ts &...params) {
    std::stringstream s;
    s <<Print(params...);
}

int main()
{
    test(1,2,"foo", A(123));
}