accessing elements of dynamiclly allocated array

Question

I'm trying to access the next element in dynamically allocated by adding the size of placeholder array to the first element. Size of placeholder array is 4 bytes, so if I add 4 bytes to it first element with address 2147549788, I should be looking at next memory location 2147549792. But, instead I'm looking at an address in 16 bytes 2147549804. If I read the address of array elements directly I get the right address. Wondering why adding size of placeholder gives different results ? Also, if I access the location of second element outside the for loop, the location is off by another 16 bytes i.e 2147549820

#include "stdio.h"
#include "time.h"
#include <stdlib.h>
#include <string.h>

typedef struct Section {
    int numOfStudents;
} Section;

typedef struct School {
    int schoolId;
    Section sections[1]; //placeholder
} School;

int main(void) 
{
    School *schoolA_p;  
    Section section1;
    int sizeOffset = 0;
    int i,sectionSize;

    int sizeOfSchool = sizeof(School) - sizeof(Section) + (sizeof(Section)*2);
    schoolA_p = (struct School *) malloc(sizeOfSchool);

    for(i=0;i<2;i++)
    {
        sectionSize = sizeof(Section);

        printf("\nsize of section = %d\n", sizeof(Section));
        printf("Number of bytes to add to first element to access the next element = %d\n", sizeOffset);
        printf("In Loop Location of schoolA_p->sections[%d]= 0x%lx\n",i, &(schoolA_p->sections[0]) + sizeOffset);

        sizeOffset += sectionSize;
    }

    printf("\n Location of schoolA_p->sections[0]= 0x%lx\n",&(schoolA_p->sections[0]));
    printf("\n Location of schoolA_p->sections[1]= 0x%lx\n",&(schoolA_p->sections[1]));

    printf("\n Outside of lopop Location of schoolA_p->sections[0]= 0x%lx\n", &(schoolA_p->sections[0])+ sizeOffset);

    free(schoolA_p); 
    return 0;
}

Answer 1

Pointer arithmetic works like this: If p is a pointer to an array element a[n], then p + i is a pointer to a[n + i]. In other words, pointer arithmetic moves in units of whatever base type the pointer is declared as, not bytes.

Answer 2

C pointer arithmetic takes into account the size of the data pointed to when you increment a pointer.

So if p is a pointer to data of 4 bytes, p + 1 calculates the address 4 bytes after p.

In other words, your doing too much work. C does this bookkeeping for you, and that's why you're getting incorrect results.

As a side note, this is why you cannot use pointer arithmetic on void* pointers. The size of the data pointed to is not specified.