C99 dynamic array

[kwikius]

Does anyone know what a C99 dynamic array is, and if it will be
useable in C++?

regards
Andy Little

[kwikius]

On Feb 14, 8:18*am, Ian Collins <[e-mail] mwrote:

kwikius wrote:

On Feb 13, 4:52 am, Jeff Schwab <j...@schwabcen ter.comwrote:

<C>
#include <stdlib.h>

void f(size_t z) {

<..>

* * * * some_type c[z]; // ok in c99 only}

Ah I think I get it. As far as the array is concerned z is a constant,
so it cant resize after its created. Thats quite neat, if you can grab
an arbitrary amount of space on the stack in a function.

As observed later, it then raises questions about how this affects
optimisations, as you have a runtime constant.

There is also one potentially crippling problem with VLAs: no indication
of failure. *You can bugger your stack without realising.

Another complication is the incompatibility with C caused by the
different interpretation of const,

void f() {
* const size_t s = 42;

* int bla[s];

}

requires a VLA in C, but not in C++.

My current opinion is:

Looks cool but only on paper. Essentially its a local optimisation,
but in practise gives the optimiser one more extremely heavyweight
variable to deal with, the stack pointer, and so probably causes major
problems in wider optimisations, such as inlining. OTOH I don't know
much about optimisation, but they do seem to run a mile from runtime
constants and especially pointers which this looks likely to create in
abundance.

So in practise I would guess most implementations would end up using
the heap to solve this, unless they are specifically not allowed to,
which apparently isnt the case.

Its interesting though ... I guess C++ can sit back and watch
progress.

regards
Andy Little

[Ian Collins]

James Kanze wrote:

>On Feb 14, 8:18 am, Ian Collins <[e-mail] mwrote:

>>There is also one potentially crippling problem with VLAs:
no indication of failure. You can bugger your stack without
realising.

You can do that very well without VLA's as well. Stack overflow
is undefined behavior in both C and C++.

True, but I was drawing a comparison with the idiomatic C++ solution
(the use of std::vector). VLAs are a C solution to a problem we don't
have in C++.

--
Ian Collins.

[Jerry Coffin]

In article <_Z************ *************** ***@comcast.com >,
je**@schwabcent er.com says...

[ ... ]

Not AFAIK, although C++0x will incorporate some features of C99. The
std::vector is preferable in most respects, anyway. The down-side of
vector is that it uses dynamic storage, which may incur more performance
overhead than automatic (stack-based) storage. Chances are excellent
that whatever you're doing, std::vector is a better choice than a raw array.

C++ 0x also includes std::array, which is really much closer to a VLA --
i.e. the size is constant once it's created. The only major difference
that occurs to me offhand is that std::array has explicit support for
zero-sized arrays, whereas C99 requires the size of a VLA to be greater
than zero.

--
Later,
Jerry.

The universe is a figment of its own imagination.

[Jeff Schwab]

Jerry Coffin wrote:

In article <_Z************ *************** ***@comcast.com >,
je**@schwabcent er.com says...

[ ... ]

>Not AFAIK, although C++0x will incorporate some features of C99. The
std::vector is preferable in most respects, anyway. The down-side of
vector is that it uses dynamic storage, which may incur more performance
overhead than automatic (stack-based) storage. Chances are excellent
that whatever you're doing, std::vector is a better choice than a raw array.

C++ 0x also includes std::array, which is really much closer to a VLA --
i.e. the size is constant once it's created. The only major difference
that occurs to me offhand is that std::array has explicit support for
zero-sized arrays, whereas C99 requires the size of a VLA to be greater
than zero.

The point of a VLA is that the size doesn't have to be a constant
expression. The size of a TR1 std::array is a template parameter, and
as such does have to be a constant (at compile-time) expression. As far
as I know, std::vector will continue to be the closest thing C++ has to
a C99 VLA.