int a[17]; int b = -1; /* a[17] same as b guaranteed in ANSI C? */

[bq]

In the code
int a[17];
int b = -1;
does ANSI C guarantee that "b" is located in memory right after "a[16]"
so that "a[17]" refers to "b"?

Thanks.
bq

[Rouben Rostamian]

In article <6c************ **************@ posting.google. com>,
bq <fo**********@y ahoo.com> wrote:

In the code
int a[17];
int b = -1;
does ANSI C guarantee that "b" is located in memory right after "a[16]"
so that "a[17]" refers to "b"?

I have not seen reference in the C standard to any guarrantee of this
sort.

Additionally, testing the addresses of your a and b on a recent
version of gcc, it turns out that b comes just _before_ a in the
memory address space. Other compilers may behave differently.

--
Rouben Rostamian

[Mark A. Odell]

fo**********@ya hoo.com (bq) wrote in
news:6c******** *************** ***@posting.goo gle.com:

In the code
int a[17];
int b = -1;
does ANSI C guarantee that "b" is located in memory right after "a[16]"
so that "a[17]" refers to "b"?

No.

--
- Mark ->
--

[Alan Balmer]

On 18 Dec 2003 08:51:00 -0800, fo**********@ya hoo.com (bq) wrote:

In the code
int a[17];
int b = -1;
does ANSI C guarantee that "b" is located in memory right after "a[16]"
so that "a[17]" refers to "b"?

Thanks.
bq

No. In fact, "Hell, no!" Don't do that.

--
Al Balmer
Balmer Consulting
re************* ***********@att .net

[Toni Uusitalo]

a and b are separate variables, compiler can locate them anywhere. only way
to ensure contiguous memory block is to use array (like your a),
struct/union or course allocate some block of memory.

with respect,
Toni Uusitalo

"bq" <fo**********@y ahoo.com> wrote in message
news:6c******** *************** ***@posting.goo gle.com...

In the code
int a[17];
int b = -1;
does ANSI C guarantee that "b" is located in memory right after "a[16]"
so that "a[17]" refers to "b"?

Thanks.
bq

[Kevin D. Quitt]

On 18 Dec 2003 08:51:00 -0800, fo**********@ya hoo.com (bq) wrote:

In the code
int a[17];
int b = -1;
does ANSI C guarantee that "b" is located in memory right after "a[16]"
Only if they are in a struct, and then there still might be some padding
between a and b.

so that "a[17]" refers to "b"?

Not only no, but "hell, no". There is no possible legitimate reason to
want to do that.

--
#include <standard.discl aimer>
_
Kevin D Quitt USA 91387-4454 96.37% of all statistics are made up
Per the FCA, this address may not be added to any commercial mail list

[Fred L. Kleinschmidt]

bq wrote:

In the code
int a[17];
int b = -1;
does ANSI C guarantee that "b" is located in memory right after "a[16]"
so that "a[17]" refers to "b"?

Thanks.
bq

No

--
Fred L. Kleinschmidt
Boeing Associate Technical Fellow
Technical Architect, Common User Interface Services
M/S 2R-94 [phone]

[Toni Uusitalo]

"Toni Uusitalo" <to************ **@luukkudot.ko m> wrote in message
news:sA******** ********@reader 1.news.jippii.n et...

a and b are separate variables, compiler can locate them anywhere. only way to ensure contiguous memory block is to use array (like your a),
struct/union or course allocate some block of memory.

oh, to ensure struct variables to be contiguous you must turn off struct
padding of course.
This whole thing might make sense if you think it from the memory allocation
perspective i.e. if you for example malloc 2 different blocks of memory, for
memory management they're totally separate blocks (they might be contiguous
or they might not) etc. just as separate variables.

with respect,
Toni Uusitalo

[Christopher Benson-Manica]

bq <fo**********@y ahoo.com> spoke thus:

int a[17];
int b = -1;
does ANSI C guarantee that "b" is located in memory right after "a[16]"
so that "a[17]" refers to "b"?

a[17] results in UB, I imagine. I'd be grateful if someone would
quote the Standard on this issue, however...

--
Christopher Benson-Manica | I *should* know what I'm talking about - if I
ataru(at)cybers pace.org | don't, I need to know. Flames welcome.

[Joona I Palaste]

Christopher Benson-Manica <at***@nospam.c yberspace.org> scribbled the following:

bq <fo**********@y ahoo.com> spoke thus:

int a[17];
int b = -1;
does ANSI C guarantee that "b" is located in memory right after "a[16]"
so that "a[17]" refers to "b"?

a[17] results in UB, I imagine. I'd be grateful if someone would
quote the Standard on this issue, however...

a[17] definitely results in UB, but a+17 doesn't. This does not mean,
however, that a+17 will equal &b. It can, but it's not required to.

--
/-- Joona Palaste (pa*****@cc.hel sinki.fi) ------------- Finland --------\
\-- http://www.helsinki.fi/~palaste --------------------- rules! --------/
"Last year he disrespected me - and then he showed lack of respect."
- Anthony Mason