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 multidimensiona l 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 multidimensiona l 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 multidimensiona l 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!?

<implementati on 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**********@g mail.comwrote in message
news:11******** **************@ h48g2000cwc.goo glegroups.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 multidimensiona l 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.de wrote in message
news:44******** **************@ newsspool1.arco r-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******** ***********@new s.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