Re: HELP ! need to insert value in array !!

[miker3@ix.netcom.com (Mike Rubenstein)]

dewar@merv.cs.nyu.edu (Robert Dewar) wrote:

> Michael says
> 
> <<Perhaps it was someone who actually knows C.  Whoever said it was
> correct.  Objects may be padded in that there may be bytes that are
> not used, but there must be no additional padding between array
> elements.  For any type T,
> 
>         T a;
>         T b[5];
> 
> we must have sizeof b == 5 * sizeof a. There can be no unused space
> between b[0] and b[1].
> >>
> 
> Ah, a confusion. I thought the statement was about Ada.
> 
> But I am interested in how you could construct a valid ANSI C program
> with portable semantics that could detect the difference, and in particular
> how exactly the ANSI C standard formally prohibits such "additional padding".
> This is the sort of requirement that is very easy to state informally, but
> much harder to state formally.
> 
> What would one expect on a PDP10 with 5 characters per word and an unused
> bit left over, or does the ANSI C standard require 36 bits/character on 
> this machine?
> 
> <<I don't have the C standard at hand, so i would be interested if someone
> could quote chapter and verse on this>>
> 
> This sort of statement is the kind of statement that Ada would certainly
> like to make in the packed case, but it is hard to make it more than
> implementation advice.
> 
> I also don't see how your conditoin above can be correct
> 
> suppose that type T is a struct with a double field and an int field.
> The size of this struct would be 12 bytes, but its alignment requirement
> is 8, so it would not be possible to laout the array b without alignment
> gaps???
> 

It's quite easy to detect the difference.  For example,

	#include <stdio.h>

	int main(void)
	{
	  int a[2];
	  unsigned long d = (char*) a[1] - (char*) a[0];
	  printf ("%lu %lu\n", d, sizeof(int));
	  return 0;
	}

This must print the same number twice.

Note also that without this rule there would be no guarantee that code
like

	#include <stdlib.h>

	int a[5] = { 1, 2, 3, 4, 5 };;
	int *b = malloc(5 * sizeof *b);
	if (b != NULL)
	  memcpy(b, a, sizeof a);

would work.  It would be extremely difficult for an implementation to
fake this with non-contiguous arrays since the ultimate type of the
allocated memory may not be known at the time the malloc() is done.

From ISO 6.1.2.5:

	An array type describes a contiguously allocated nonempty set 
	of objects ...

This rule is not needed in languages like Ada in which the allocation
can be done by statements or functions that have access to the type
being allocated.  PL/I also does not have this requirement and, in
fact, one does occasionally have arrays with non-contiguous elements.

Michael M Rubenstein