多线程代码中的结构内存布局

Question

The following code is a multi-threaded and is running for thread id=0 and 1 simultaneously .

typedef struct
{
  unsigned char pixels[4];
} FourPixels;

main()

{ 

  FourPixels spixels[];


  //copy on spixels
  spixels[id] = gpixels[id];

  //example : remove blue component
  spixels[id].pixels[0] &= 0xFC;
  spixels[id].pixels[1] &= 0xFC;
  spixels[id].pixels[2] &= 0xFC;
  spixels[id].pixels[3] &= 0xFC;

}

We see that thread id =0 fetches 4 chars, and the thread id =1 fetches another set of 4 chars.

I want to know in memory how the structures spixels[0] and spixles[1] are put, means something like this?

spixels[0]                                      spixels[1]                  
pixel[0] pixel[1] pixel[2] pixel[3]      pixel[0] pixel[1] pixel[2] pixel[3]  
2000        2001   2002     2003          2004     2005     2006      2007

The question is are spixel[0] and spixel[1] placed contiguously with guarantee as shown above?

Answer 1

Yes, they will be laid out contiguously as you say. Now, probably someone will come and say that it is not guaranteed on all platforms, because the alignment of the struct could be more than its size, so you could have a gap between the two struct "bodies" due to implicit padding after the first one. But no matter, because the alignment on any sane compiler and platform will be just 1 byte (as in char).

If I were writing code that relied on this, I'd add a compile-time assertion that the size of two of those structs should be exactly 8 bytes, and then I'd be 100% confident.

Edit: here's an example of how a compile-time check might work:

struct check {
  char floor[sizeof(FourPixels[2]) - 8];
  char ceiling[8 - sizeof(FourPixels[2])];
};

The idea is that if the size is not 8, one of the arrays will have negative size. If it is 8, they'll both have zero size. Note that this is a compiler extension (GCC supports zero-length arrays for example), so you may want to look for a better way. I'm more of a C++ person, and we have fancier tricks for this (in C++11 it's built in: static_assert() ).

Answer 2

An array is guaranteed by the standard to be contiguous. It's also guaranteed that the first entry will be on a low address in memory, and the next will be on a higher, etc.

In the case the structures pixel array, pixel[1] will always come directly after pixel[0] . The same with the next entries.

Answer 3

Yes arrays are placed in contiguous memory location. This is to allow the pointer arithmetic.