«

Hello,

I was reading this page about the C++11 features in the next VC compiler:
http://blogs.msdn.com/b/vcblog/archi.../10209291.aspx

and was surprised by the following. Since they don't have variadic
templates, they mimic them for small enough numbers of arguments in
the standard library. And then they claim:
"pair's pair(piecewise_construct_t, tuple<Args1...>, tuple<Args2...>)
constructor had "interesting" effects. This requires N^2 overloads
(if we support up to 10-tuples, that means 121 overloads, since empty
tuples count here too)."

I am surprised by this. As far as I know, the usual way to mimic
variadic tuple is:
template <class=void,class=void,/*repeat a few more times*/class=void>
struct tuple;

so tuple<int, double> is actually tuple<int, double, void, void...>

pair's constructor then looks like:
template<class A,class B>
template<class X0,class X1,...,class X10,class Y0,...,class Y10>
pair<A,B>:air(piecewise_construct_t, tuple<X0,...,X10> x,
tuple<Y0,...,Y10> y):
first (construct_from_tuple<A>(x)),
second(construct_from_tuple<B>(y)){}

(plus possibly some std::move or other details)
Since we are only forwarding the tuple, we don't need to know how many
of the template parameters are void, so we only need a single maximal
overload. construct_from_tuple does need overloads, but only a linear
number of them.

Does someone understand their comment?

PS: I tried to comment on that blog entry, but a few days later my
comment hasn't appeared yet. Besides, a third of the comment form is
not visible with firefox. What do you expect from Microsoft?

On Nov 9, 5:33*pm, Marc <marc.gli...@gmail.com> wrote:
> Hello,
>
> I was reading this page about the C++11 features in the next VC compiler:http://blogs.msdn.com/b/vcblog/archi.../10209291.aspx
>
> and was surprised by the following. Since they don't have variadic
> templates, they mimic them for small enough numbers of arguments in
> the standard library. And then they claim:
> "pair's pair(piecewise_construct_t, tuple<Args1...>, tuple<Args2...>)
> constructor had "interesting" effects. *This requires N^2 overloads
> (if we support up to 10-tuples, that means 121 overloads, since empty
> tuples count here too)."
>
> I am surprised by this. As far as I know, the usual way to mimic
> variadic tuple is:
> template <class=void,class=void,/*repeat a few more times*/class=void>
> struct tuple;
>
> so tuple<int, double> is actually tuple<int, double, void, void...>
>
> pair's constructor then looks like:
> template<class A,class B>
> template<class X0,class X1,...,class X10,class Y0,...,class Y10>
> pair<A,B>:air(piecewise_construct_t, tuple<X0,...,X10> x,
> tuple<Y0,...,Y10> y):
> first (construct_from_tuple<A>(x)),
> second(construct_from_tuple<B>(y)){}

But this is cheating. Here, you initialize the members 'first' and
'second' with a single argument (whatever construct_from_tuple
returns, presumable an A and a B object) whereas the standard demands
first and second to be directly constructed with the arguments of
types X0,X1,... and Y0,Y1,... respectivly.

SG

SG wrote:

> On Nov 9, 5:33*pm, Marc <marc.gli...@gmail.com> wrote:
>> pair's constructor then looks like:
>> template<class A,class B>
>> template<class X0,class X1,...,class X10,class Y0,...,class Y10>
>> pair<A,B>:air(piecewise_construct_t, tuple<X0,...,X10> x,
>> tuple<Y0,...,Y10> y):
>> first (construct_from_tuple<A>(x)),
>> second(construct_from_tuple<B>(y)){}
>
> But this is cheating. Here, you initialize the members 'first' and
> 'second' with a single argument (whatever construct_from_tuple
> returns, presumable an A and a B object) whereas the standard demands
> first and second to be directly constructed with the arguments of
> types X0,X1,... and Y0,Y1,... respectivly.

construct_from_tuple<A> directly initializes an A from x, and that A
happens to be "first". The issue would be that it relies on
copy-elision, and the compiler has a flag that disables copy-elision?

If you think this is an issue, would you mind filing a bug report
against libstdc++, which uses the same construction?

Marc <> writes:
> construct_from_tuple<A> directly initializes an A from x, and that A
> happens to be "first". The issue would be that it relies on
> copy-elision, and the compiler has a flag that disables copy-elision?
>
> If you think this is an issue, would you mind filing a bug report
> against libstdc++, which uses the same construction?

I can't comment on correctness here, but I'll note that libstdc++ can
get away with making more assumptions about the compiler's behavior
than (portable) user code, because libstdc++ is developed and
distributed along with the compiler...

-Miles

--
Patience, n. A minor form of despair, disguised as a virtue.