comp.std.c++ Google Group

Re: Adding this_thread::native_handle free function

ymett.on.use...@gmail.com (Yechezkel Mett) — Sun, 12 Dec 2009 18:22:13 UT

It isn't really necessary. Since the only point of getting the native
handle is to call platform-dependant functions, you might as well call
a platform-dependant function to get the handle.
Yechezkel Mett

Re: Why is std::array an aggregate?

james.ka...@gmail.com (James Kanze) — Sun, 12 Dec 2009 18:22:32 UT

That still means you have to write the size. An exception isn't
as good as a compiler error, and a compiler error isn't as good
as not having to write the size to begin with.
Of course they can. So can C style arrays:
int a[] = { f(), g(), h() };
What's special is that it can also be initialized statically:

Re: Why is std::array an aggregate?

schaub-johan...@web.de (Johannes Schaub (litb)) — Sun, 12 Dec 2009 18:21:57 UT

I believe this can all be done using variadic templates:
template<typename T, size_t S>
struct array {
template<typename ...U>
constexpr array(U&&... u):elems{ u... } { }
T elems[S];
array<int, 3> a = { 1, 2 }; // works, is statically initialized
array<int, 2> a = { 1, 2, 3 }; // gives an error at compile time

Re: Must variadic template parameters occur at the end of the template parameter list?

olivier.gr...@gmail.com (Olivier) — Sun, 12 Dec 2009 03:38:12 UT

Hi,
i actually brought up this point a few months ago argumenting the same
point as Scott:
[link]
this would be a great feature added to variadic templates and Douglas
Gregor, at the time, seem to be saying that it could be introduced as

Re: Why is std::array an aggregate?

neverr...@aristeia.com (Scott Meyers) — Sun, 12 Dec 2009 03:37:48 UT

Well, the size of the std::array is part of its type, so if dynamic
initialization were permitted, all we'd need would be a specification for what
happens if the number of clauses in the init list didn't match the declared size
of the std::array. To keep things semi-consistent with aggregate
initialization, we could say that std::array elements without initializers would

Re: unique_ptr assignment

akrze...@gmail.com (restor) — Sun, 12 Dec 2009 03:38:39 UT

You're right. I mis-read the declaration. 6 years of studying C++ and
I still cannot parse a simple template declaration.
Thanks,
&rzej

Re: Must variadic template parameters occur at the end of the template parameter list?

s.gesem...@gmail.com (SG) — Sat, 12 Dec 2009 15:16:47 UT

I think Scott brings up a valid point. I understand that multiple
parameter packs are not allowed for declaring a class template because
the user *has* to specify the arguments. The draft clearly allows
multiple parameter packs for function templates because template
parameters can be deduced. But the same is true for specializations.

Re: "Special" library types

neverr...@aristeia.com (Scott Meyers) — Sat, 12 Dec 2009 06:56:15 UT

Not really. The type is std::nullptr_t, but look how draft C++0x specifies it:
Scott

Re: Why is std::array an aggregate?

james.ka...@gmail.com (James Kanze) — Sat, 12 Dec 2009 06:55:43 UT

Presumably, so that it can be statically initialized, in order
to avoid order of initialization problems. (It still needs a
mechanism for the number of elements to be determined,
statically, from the initialization list, in order to be truly
useful.)

Re: Adding a istream_iterator ctor with a delimiter.

neverr...@aristeia.com (Scott Meyers) — Sat, 12 Dec 2009 06:55:08 UT

Why not just use a std::regex_iterator (or std::tr1::regex_iterator)?
Scott

Re: Must variadic template parameters occur at the end of the template parameter list?

cppljev...@gmail.com (Larry Evans) — Fri, 12 Dec 2009 21:02:43 UT

Hi Scott.
One explanation for why packs are restricted to the end
is found here:
[link]
That's unfortunate because I would find them useful :(
HTH.
-Larry

Re: Must variadic template parameters occur at the end of the template parameter list?

ts...@mail.ru (Nikolay Ivchenkov) — Fri, 12 Dec 2009 21:01:42 UT

See N3000 - 14.2/11: "If a template-parameter of a class template is a
template parameter pack, it shall be the last template-parameter.
[ Note: These are not requirements for function templates because
template arguments might be deduced (14.9.2)."

Re: "Special" library types

pedro.lama...@gmail.com (Pedro Lamarão) — Fri, 12 Dec 2009 21:02:18 UT

Is the type of nullptr user-defined?

Re: "Special" library types

ride...@gmail.com (Sean Hunt) — Fri, 12 Dec 2009 21:00:31 UT

std::nullptr_t is the only other type I can think of, since all values
of type std::nullptr_t are null pointer constants, and thus do all
sorts of magic.
Sean

Why is std::array an aggregate?

neverr...@aristeia.com (Scott Meyers) — Fri, 12 Dec 2009 21:00:50 UT

In TR1, std::tr1::array needed to be an aggregate so that it could be
brace-initialized. To offer the same capability for C++0x's std::array, the
class could simply declare a constructor taking a std::initializer_list. So why
is std::array an aggregate? Making it a non-aggregate would permit e.g., giving