Question: ```
struct
{
    int m,s,l;
    union
    {
        char c[10];
    };
    float p;
} a;

int main()
{
    printf("%d",sizeof(a));
    return 0;
}

```

according to the calculations ans must be 4\*3+10+4=26 but DEV C++ compiler showing the output 28.

Answer: 
The principles of allocating local variables on stack are roughly the same for all systems

1 -- Stack grows from high addresses to low addresses

2 -- The order of declaration of your variables in your program corresponds to growth of stack

3 -- Each type has alignment - the address of any variable must be divisible by its size (1 for char, 2 for short, etc).Try to waste as little space as possible 

In this way, we try to use some waste space to improve the speed of memory access.
So in your codes, it meams that

```
#include <stdio.h>
#include <stdlib.h>

struct                   //  the base address is &a
{
    int         m;       // [0, 4)  
    int         s;       // [4, 8)
    int         l;       // [8, 12)
    union
    {
        char    c[10];   // [12, 22)
    };
    // char     m_align[2]  //  there are 4 byte for align
    float       p;       // [24, 28)
}a;                      //  sizeof = 28

```

the value `m` is begin at the start of type `a`, and occupancy 4 byte in 32bit system, so it's address is [0, 4). and it's start address can divisible by sizeof(int).

this is the same to `s` and `l`.

and then the union value `c[10]` occupancy, occupancy [12, 22), the begining od it's address 12 can divisible by sizeof(int).

What's importment the next address is 22， and the value `p` will occupancy `sizeof(float) = 4` bytes，but the address 22 can't divisible by `sizeof(float)`. we must fill the space to alignment the struct and try to waste as little space as possible. So the base address of value `p` will be 24 which can divisible by `sizeof(float)`, so the adddress of `p` is [24, 28]...

you can see this <https://en.wikipedia.org/wiki/Data_structure_alignment> for detail
The members in the structure arranged as a group of 4 bytes in 32 bit processor.So you are getting 28 bytes as size.
for more details see [here](http://fresh2refresh.com/c/c-structure-padding/)
It is due to padding