Dynamic Memory Allocation

[Peyman]

I was trying to show a friend of mine, "why we need 'new' and DMA", and
I suddenly found that I can create arrays of variable length! which is
not supposed to work, but it works!

#include <iostream>

int main()
{
size_t l;
std::cin >l;
T a[l];
for (size_t i = 0; i != l; ++i)
std::cin >a[i];

return 0;
}

instead of
T* a = new T[l]();

and I could even create multidimensional arrays! It just didn't work
previously, is it a new stupid feature in GCC?
BTW, I'm using gcc version 4.0.3 and didn't have chance to try it with
other compilers!

[Thomas Tutone]

Peyman wrote:

I was trying to show a friend of mine, "why we need 'new' and DMA", and
I suddenly found that I can create arrays of variable length! which is
not supposed to work, but it works!

#include <iostream>

int main()
{
size_t l;
std::cin >l;
T a[l];
for (size_t i = 0; i != l; ++i)
std::cin >a[i];

return 0;
}

instead of
T* a = new T[l]();

and I could even create multidimensional arrays! It just didn't work
previously, is it a new stupid feature in GCC?
BTW, I'm using gcc version 4.0.3 and didn't have chance to try it with
other compilers!

It's a gcc extension, and has been around for a while. Try compiling
with -Wall -Wextra -pedantic, and see what happens.

Best regards,

Tom

[W Marsh]

Peyman wrote:

I was trying to show a friend of mine, "why we need 'new' and DMA", and
I suddenly found that I can create arrays of variable length! which is
not supposed to work, but it works!

#include <iostream>

int main()
{
size_t l;
std::cin >l;
T a[l];
for (size_t i = 0; i != l; ++i)
std::cin >a[i];

return 0;
}

instead of
T* a = new T[l]();

and I could even create multidimensional arrays! It just didn't work
previously, is it a new stupid feature in GCC?
BTW, I'm using gcc version 4.0.3 and didn't have chance to try it with
other compilers!

Nice troll.

[Peyman]

thank tom.
just I'm wondering what does the -Wall -Wextra and -pedantic do!?

[Thomas Tutone]

Peyman wrote:

thank tom.
just I'm wondering what does the -Wall -Wextra and -pedantic do!?

<implementation specific/>

Any reason you can't check the manual for yourself? Here's the link:

http://gcc.gnu.org/onlinedocs/gcc-4....arning-Options

</implementation specific>

Best regards,

Tom

[Moonlit]

Hi,

That's pretty neat. I actually wonder why this is not just 'standard C/C++'
since it (at least on most compilers I think) just makes room on the stack
similar to alloca. It is easier to write and faster than a new T[] /delete[]
T

--
Regards, Ron AF Greve

http://moonlit.xs4all.nl

"Peyman" <pe**********@gmail.comwrote in message
news:11**********************@h48g2000cwc.googlegr oups.com...

>I was trying to show a friend of mine, "why we need 'new' and DMA", and
I suddenly found that I can create arrays of variable length! which is
not supposed to work, but it works!

#include <iostream>

int main()
{
size_t l;
std::cin >l;
T a[l];
for (size_t i = 0; i != l; ++i)
std::cin >a[i];

return 0;
}

instead of
T* a = new T[l]();

and I could even create multidimensional arrays! It just didn't work
previously, is it a new stupid feature in GCC?
BTW, I'm using gcc version 4.0.3 and didn't have chance to try it with
other compilers!

[Jens Theisen]

Moonlit wrote:

I actually wonder why this is not just 'standard C/C++'
since it (at least on most compilers I think) just makes room on the stack
similar to alloca.

It is standard C (C99), and has thus a chance to become standard C++ for
compatibility reasons.

It is easier to write and faster than a new T[] /delete[] T

Which you shouldn't write anyway, but instead std::vector< T >.

Jens

[Moonlit]

--

"Jens Theisen" <jt***@arcor.dewrote in message
news:44**********************@newsspool1.arcor-online.net...

Moonlit wrote:

>I actually wonder why this is not just 'standard C/C++' since it (at
least on most compilers I think) just makes room on the stack similar to
alloca.

It is standard C (C99), and has thus a chance to become standard C++ for
compatibility reasons.

Thanks for the info. It would be a nice feature.

>It is easier to write and faster than a new T[] /delete[] T

Which you shouldn't write anyway, but instead std::vector< T >.

Jens

True I do use vector a lot. Sometimes it find it still easier to use arrays
when for instance calling OS or library functions that expect arrays.

Regards, Ron AF Greve

http://moonlit.xs4all.nl

[Frederick Gotham]

Peyman posted:

T a[l];

T* a = new T[l]();

To make them equivalent, either:

(1) Change the first one to:

T a[l] = {};

(2) Change the second one to:

T *a = new T[l];

But not both.

I haven't read up much on VLA's, but I wonder what happens when you apply
sizeof to them, or what would happen if you tried to invoke the following
template function with one:

template<class T,size_t len>
void Func(T (&)[len])
{

}

--

Frederick Gotham

[Moonlit]

Hi,

--
Regards, Ron AF Greve

http://moonlit.xs4all.nl

"Frederick Gotham" <fg*******@SPAM.comwrote in message
news:8w*******************@news.indigo.ie...

Peyman posted:

> T a[l];

> T* a = new T[l]();

To make them equivalent, either:

(1) Change the first one to:

T a[l] = {};

(2) Change the second one to:

T *a = new T[l];

But not both.

I haven't read up much on VLA's, but I wonder what happens when you apply
sizeof to them, or what would happen if you tried to invoke the following
template function with one:

template<class T,size_t len>
void Func(T (&)[len])
{

}

Good question.

I just tried some things with (a bit outdated) g++ compiler
It unfortunately doesn't work in VC++.

But with the gnu compiler sizeof just outputs the correct value (the size of
the array). I am not sure how the gnu people did that. With my (old) g++
3.2.2 version the template version just didn't compile (internal error,
segmentation fault, file bug report).

l = 8;
so unsigned long a[l];
sizeof( a ) would output 32
with an unsigned long length of 4. BTW I entered the value dynamically so
the sizeof( a ) isn't just a constant

I tried to find the value on the stack (other then in the variable l) but
couldn't find it. Wonder where they put that value.

>
--

Frederick Gotham

Regards, Ron AF Greve

[Gavin Deane]

Moonlit wrote:

True I do use vector a lot. Sometimes it find it still easier to use arrays
when for instance calling OS or library functions that expect arrays.

If you mean OS or library functions that expect a pointer to the first
element of a contiguous sequence of objects (such as would be held in
an array), vectors can still help. Just use &v[0] and v.size() for the
pointer and the array length (where v is your vector). You get all the
protection and convenience of the standard library in your code and the
use of raw pointers doesn't need to propogate outside the API you are
using.

Gavin Deane

[Moonlit]

Hi,

--

"Gavin Deane" <de*********@hotmail.comwrote in message
news:11**********************@m79g2000cwm.googlegr oups.com...

>
Moonlit wrote:

>True I do use vector a lot. Sometimes it find it still easier to use
arrays
when for instance calling OS or library functions that expect arrays.

If you mean OS or library functions that expect a pointer to the first
element of a contiguous sequence of objects (such as would be held in
an array), vectors can still help. Just use &v[0] and v.size() for the
pointer and the array length (where v is your vector). You get all the

Thanks for the reply.

I tried to come up with some examples where array's would be necessary...,

but actually I couldn't find any that couldn't be replaced with vector :-/.
So I guess I should try to use vector even more in the future.

protection and convenience of the standard library in your code and the
use of raw pointers doesn't need to propogate outside the API you are
using.

Gavin Deane

Regards, Ron AF Greve

http://moonlit.xs4all.nl

[jimmy]

Moonlit 写�：

Hi,

--

"Gavin Deane" <de*********@hotmail.comwrote in message
news:11**********************@m79g2000cwm.googlegr oups.com...

Moonlit wrote:

True I do use vector a lot. Sometimes it find it still easier to use
arrays
when for instance calling OS or library functions that expect arrays.

If you mean OS or library functions that expect a pointer to the first
element of a contiguous sequence of objects (such as would be held in
an array), vectors can still help. Just use &v[0] and v.size() for the
pointer and the array length (where v is your vector). You get all the

Thanks for the reply.

I tried to come up with some examples where array's would be necessary...,

but actually I couldn't find any that couldn't be replaced with vector :-/.
So I guess I should try to use vector even more in the future.

I agree with you :)

>

protection and convenience of the standard library in your code and the
use of raw pointers doesn't need to propogate outside the API you are
using.

Gavin Deane

Regards, Ron AF Greve

http://moonlit.xs4all.nl