C++11: Guaranteeing nonconverting reference from template parameter - c++

Question

So I have a struct X:
struct X
{
int typecode;
char* pData;
int length;
...
}
and a long list of types, we'll call this set TS. TS includes most primitive types and several class types.
For each type T in TS I have a regular function defined:
void setup(X& x, const T& t);
For example for T = string setup looks like:
void setup(X& x, const string& s)
{
x.typecode = X_STRING;
x.pData = s.c_str();
x.length = s.size();
...
}
Now I have a template function convert_to_x:
template<class T>
X convert_to_x(const T& t)
{
X x;
memset(x, 0, sizeof(x));
setup(x, t);
return x;
}
And a function f that takes an array of X:
void f(X* xs, int num_args);
And further a variadic template function g:
template<class... Args)
void g(Args... args)
{
constexpr num_args = sizeof...(args);
X xs[] = { convert_to_x(args)... };
f(xs, num_args);
}
What is going on is that you can call g with any number of parameters and types and it will convert the parameters to an array of X type, and then call f.
The problem is that if g is called with a type that is not in TS, but is convertible to a type in TS, the following happens:
A converting constructor is called to create a temporary t.
setup will store a pointer to this temporary.
the temporary is destroyed.
f is called with an xs that contains hanging pointers.
I need a way at entry to g to convert any arguments that are convertible to a type in TS but are not of a type in TS, and keep them around for the whole scope of g.
What is the best way to achieve this?
Update:
One way I just thought of that may work is to define a regular function convert for each type T in TS as follows:
T convert(const T& t) { return t; }
and then define a wrapper for g:
template<class... Args>
void g2(Args... args)
{
g(convert(args)...);
}
but I think this will cause unnecessary copying of types that are already in TS and don't need converting. Is there some way to use rvalue/lvalue semantics to avoid this?
Update 2:
Maybe this would work:
For each T in TS:
const T& convert(const T& t) { return t; }
T convert(const T&& t) { return t; }
then:
template<class... Args>
void g2(Args... args)
{
g(convert(args)...);
}
Are there any cases where setup could possibly receive a temporary with the above?

Answer 1

You can add deleted overloads for setup:
void setup(X& x, const string& s) = delete;
Since rvalue references bind to temporaries more readily than const lvalue references, calling setup with a temporary will select the overload with rvalue references. But since this setup overload is deleted, it would be illegal to actually call it. So when g is called with the wrong type of argument, the line X xs[] = { convert_to_x(args)... }; requires convert_to_args to call a deleted version of setup, so that instantiation fails. In turn, it causes the particular instantiation of g to fail as well.
Edit
Looking at your update #2, this should work. Since convert already causes the best conversion to one of the TS, g should never be called with unwanted types. So no temporaries would be created by unwanted conversions upon the invocation of setup. Thus, any temporaries would be arguments to g, and would be guaranteed to live for the duration of g.
Edit 2
You're right that T convert(const T&& t) { return t; } could result in values being unnecessarily copied. But this is easily fixed:
const T& convert(const T& t) { return t; }
const T&& convert(const T&& t) { return std::move(t); }
you won't get any copying of values. Lifetime of temporaries is correct, too, since temporaries live until the end of the full expression in which they are created:
template<class... Args>
void g2(Args... args)
{
g(convert(args)...);
} // ^^^^ temporaries created by a conversion here will live until g returns