Does anyone know what a C99 dynamic array is, and if it will be
useable in C++?
regards
Andy Little
useable in C++?
regards
Andy Little
-
-
Re: C99 dynamic array
kwikius wrote:A variable-length array, i.e. an array whose size can be set by aDoes anyone know what a C99 dynamic array is
run-time variable.
<C>
#include <stdlib.h>
void f(size_t z) {
typedef enum some_t { some_value } some_type;
some_type a[5] = { some_value }; // always ok
// some_type b[z] = { some_value }; // always illegal
some_type c[z]; // ok in c99 only
}
</C>
Not AFAIK, although C++0x will incorporate some features of C99. The, and if it will be useable in C++?
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.
-
Re: C99 dynamic array
On Feb 13, 4:52 am, Jeff Schwab <j...@schwabcen ter.comwrote:<...>kwikius wrote:>Does anyone know what a C99 dynamic array is
A variable-length array, i.e. an array whose size can be set by a
run-time variable.
>
<C>
#include <stdlib.h>
>
void f(size_t z) {
>
typedef enum some_t { some_value } some_type;
>
some_type a[5] = { some_value }; // always ok
// some_type b[z] = { some_value }; // always illegal
some_type c[z]; // ok in c99 only}
>
</C>
Ah ha yes, but does the dynamic array actually just look like aThe 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.
std::vector underneath (use heap allocation) or is there some other
magic.
Its a sort of holy grail isnt it, that you can create a dynamically
sized array without the heap, so if C99 dynamic array does use another
method to allocate, would be interesting.
(my guess is that it woud have same performance as std::vector. There
is no "magic")
regards
Andy Little
Comment
-
Re: C99 dynamic array
kwikius wrote:I believe VLAs use the stack, just like traditional arrays. The "magic"On Feb 13, 4:52 am, Jeff Schwab <j...@schwabcen ter.comwrote:>>kwikius wrote:>A variable-length array, i.e. an array whose size can be set by a>>Does anyone know what a C99 dynamic array is
>run-time variable.
>>
><C>
>#include <stdlib.h>
>>
>void f(size_t z) {
>>
> typedef enum some_t { some_value } some_type;
>>
> some_type a[5] = { some_value }; // always ok
>// some_type b[z] = { some_value }; // always illegal
> some_type c[z]; // ok in c99 only}
>>
></C>
<...>
>>>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.
Ah ha yes, but does the dynamic array actually just look like a
std::vector underneath (use heap allocation) or is there some other
magic.
>
Its a sort of holy grail isnt it, that you can create a dynamically
sized array without the heap, so if C99 dynamic array does use another
method to allocate, would be interesting.
>
(my guess is that it woud have same performance as std::vector. There
is no "magic")
is that the compiler doesn't know a priori how big the function's stack
frame will be; in fact, multiple invocations of the same function might
need frames of different sizes. It would be interesting to know what
kinds of complications this creates for compiler implementers, and how
those problems have been worked around.
Comment
-
Re: C99 dynamic array
On 2008-02-13 15:50:05 -0500, Jeff Schwab <jeff@schwabcen ter.comsaid:
They're not required to.>
I believe VLAs use the stack, just like traditional arrays.
--
Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com) Author of "The
Standard C++ Library Extensions: a Tutorial and Reference
(www.petebecker.com/tr1book)
Comment
-
Re: C99 dynamic array
On 2008-02-13 21:50, Jeff Schwab wrote:There should be little trouble to create the actual frame, nor to usekwikius wrote:>>On Feb 13, 4:52 am, Jeff Schwab <j...@schwabcen ter.comwrote:>>>>kwikius wrote:
>>>Does anyone know what a C99 dynamic array is
>>A variable-length array, i.e. an array whose size can be set by a
>>run-time variable.
>>>
>><C>
>>#include <stdlib.h>
>>>
>>void f(size_t z) {
>>>
>> typedef enum some_t { some_value } some_type;
>>>
>> some_type a[5] = { some_value }; // always ok
>>// some_type b[z] = { some_value }; // always illegal
>> some_type c[z]; // ok in c99 only}
>>>
>></C>
><...>
>>>>>>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.
>Ah ha yes, but does the dynamic array actually just look like a
>std::vector underneath (use heap allocation) or is there some other
>magic.
>>
>Its a sort of holy grail isnt it, that you can create a dynamically
>sized array without the heap, so if C99 dynamic array does use another
>method to allocate, would be interesting.
>>
>(my guess is that it woud have same performance as std::vector. There
>is no "magic")
I believe VLAs use the stack, just like traditional arrays. The "magic"
is that the compiler doesn't know a priori how big the function's stack
frame will be; in fact, multiple invocations of the same function might
need frames of different sizes. It would be interesting to know what
kinds of complications this creates for compiler implementers, and how
those problems have been worked around.
VLAs, you just have to remember the size of each VLA and use it to
calculate the offsets. Which means that some operations (probably all
that accesses elements in an VLA) will require one or more additional
computations to calculate the offset from the stack-pointer.
--
Erik Wikström
Comment
-
Re: C99 dynamic array
Erik Wikström wrote:That's per-invocation overhead, right? So recursive functions with VLAsOn 2008-02-13 21:50, Jeff Schwab wrote:>>kwikius wrote:>I believe VLAs use the stack, just like traditional arrays. The "magic">>On Feb 13, 4:52 am, Jeff Schwab <j...@schwabcen ter.comwrote:
>>>kwikius wrote:
>>>>Does anyone know what a C99 dynamic array is
>>>A variable-length array, i.e. an array whose size can be set by a
>>>run-time variable.
>>>>
>>><C>
>>>#include <stdlib.h>
>>>>
>>>void f(size_t z) {
>>>>
>>> typedef enum some_t { some_value } some_type;
>>>>
>>> some_type a[5] = { some_value }; // always ok
>>>// some_type b[z] = { some_value }; // always illegal
>>> some_type c[z]; // ok in c99 only}
>>>>
>>></C>
>><...>
>>>
>>>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.
>>Ah ha yes, but does the dynamic array actually just look like a
>>std::vector underneath (use heap allocation) or is there some other
>>magic.
>>>
>>Its a sort of holy grail isnt it, that you can create a dynamically
>>sized array without the heap, so if C99 dynamic array does use another
>>method to allocate, would be interesting.
>>>
>>(my guess is that it woud have same performance as std::vector. There
>>is no "magic")
>is that the compiler doesn't know a priori how big the function's stack
>frame will be; in fact, multiple invocations of the same function might
>need frames of different sizes. It would be interesting to know what
>kinds of complications this creates for compiler implementers, and how
>those problems have been worked around.
There should be little trouble to create the actual frame, nor to use
VLAs, you just have to remember the size of each VLA and use it to
calculate the offsets. Which means that some operations (probably all
that accesses elements in an VLA) will require one or more additional
computations to calculate the offset from the stack-pointer.
could get very messy...
Comment
-
Re: C99 dynamic array
Pete Becker wrote:Are there any implementations that use free store? If the compiler hasOn 2008-02-13 15:50:05 -0500, Jeff Schwab <jeff@schwabcen ter.comsaid:
>>>>
>I believe VLAs use the stack, just like traditional arrays.
They're not required to.
to ensure that all possible return paths free the memory, it seems like
it's half way to C++-style destructors.
Comment
-
Re: C99 dynamic array
On Feb 13, 4:52 am, Jeff Schwab <j...@schwabcen ter.comwrote:
<..><C>
#include <stdlib.h>
>
void f(size_t z) {Ah I think I get it. As far as the array is concerned z is a constant,some_type c[z]; // ok in c99 only}
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.
So it looks like you arent getting something for nothing, but maybe
you are getting it quite cheap :-)
regards
Andy Little
Comment
-
Re: C99 dynamic array
kwikius wrote:There is also one potentially crippling problem with VLAs: no indicationOn 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.
>
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++.
--
Ian Collins.
Comment
-
Re: C99 dynamic array
On Feb 14, 8:18 am, Ian Collins <ian-n...@hotmail.co mwrote:My current opinion is: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++.
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
Comment
-
Re: C99 dynamic array
James Kanze wrote:True, but I was drawing a comparison with the idiomatic C++ solution>>On Feb 14, 8:18 am, Ian Collins <ian-n...@hotmail.co 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++.
>
(the use of std::vector). VLAs are a C solution to a problem we don't
have in C++.
--
Ian Collins.
Comment
-
Re: C99 dynamic array
In article <_ZKdncvySLL56i _anZ2dnUVZ_oaon Z2d@comcast.com >,
jeff@schwabcent er.com says...
[ ... ]
C++ 0x also includes std::array, which is really much closer to a VLA --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.
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.
Comment
-
Re: C99 dynamic array
Jerry Coffin wrote:The point of a VLA is that the size doesn't have to be a constantIn article <_ZKdncvySLL56i _anZ2dnUVZ_oaon Z2d@comcast.com >,
jeff@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.
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.
Comment
Comment