Is there a warning / Info to avoiding alignment traps

Well, when you build that, you will get error diagnostics like this one ...

    "file.c", line 15: error: a value of type "int *" cannot be assigned to an
              entity of type "struct s *"
        p = &i[1];
          ^

You can avoid the diagnostic with a cast. But I don't recommend that approach at all. What is the overarching problem you want to solve? There is probably a better way to do it.

Thanks and regards,

-George

Hi!

Indeed the code includes the casts:

    // somewhere in a function: struct s * p;

  p = (struct s *) &i[0];

  long A = p->l;

  p = (struct s *)  &i[1];

  long B = p->l;

The problem is, that in that example reading from an odd address results 
in something you did not expect because of the alignment.

So I need the warning, whenever a pointer is used and points to something
which may be an odd address in case of different pointer types are used.

In the example it was int and long.

Is the problem clearer now?

JD

Accessing an object through a pointer to a different type invokes undefined behavior, which means the compiler will not promise to do what you expect.  Sometimes you can get away with such a cast, but at a minimum the alignment needs to be right, and it's still technically undefined behavior.

See also the C-FAQ entry on undefined behavior.

The one exception is that any object may be accessed through a pointer to unsigned char.  You can do a byte-by-byte copy out of the int array with memcpy.

Are you trying to define a single integer array and use it as if it were an array of various other types at different points in your program?  If so, you would be better off defining an array of structs instead of casting a pointer to an array of integers.

If it's essential to overlay different arrays to share storage, use a union;  that's what they're for.  It's also easier to read.

By using an array of the struct type you mean, whether solo or within a union, you allow the compiler to align the fields properly.

Hi everybody,

it is interesting to see, that you all wonder what I want to do.

Indeed, the question is not answered.

Fact is, reading via a pointer from an odd address gives you undefined behaviour,

when the alignment of int is 1 (variable) and the alignment of long is 2 (pointer access).

As we all know this, is the compiler able to tell the developer, he has done something absolutely dangerous.

What is the error number.

Background is a large project, were many developers work on a codebase. The last two days I searched

a bug  and finally found it. Data was stored in an int array,  then similar to the example above the struct pointer

was used to fetch the data from the array. This is not common programming practice but it was finally coded in such a way.

A simple warning generated by the compiler might have given a hint.

So is there a warning available for such a topic?

JD

Ok, thanks a lot for all your support.
Have a nice afternoon :)

JD