C dynamic array implementation using preprocessor I have implemented a generic dynamic array implementation using defines. As I am new to C, I am not sure whether the code has any flaws. The code is as follows,

#define INIT_CAPAC 5
#define INC_CAPAC 5
#define list(t) struct{ t* data; unsigned int count; unsigned int capac;} 
#define list_init(lst)  lst.data = malloc(sizeof(*lst.data) * INIT_CAPAC); \
                        lst.count = 0; \
                        lst.capac = INIT_CAPAC;
#define list_append(lst, item) lst.data[lst.count++] = item; \
                               if(lst.count &gt;= lst.capac) { \
                                    realloc(lst.data, sizeof(*lst.data) * (lst.capac + INC_CAPAC)); \
                               } 
#define list_count(lst) lst.count
#define list_at(lst, index) lst.data[index]     

typedef list(int) int_list_t;

int main() {
    int_list_t arr;
    list_init(arr);

    list_append(arr, 10);
    list_append(arr, 20);
    list_append(arr, 30);

    printf("Count: %d\n", list_count(arr));
    printf("Item at 0: %d\n", list_at(arr, 0));
    printf("Item at 1: %d\n", list_at(arr, 1)); 
    printf("Item at 2: %d\n", list_at(arr, 2));
}


This implementation seems better than other C solutions because,


We don't store the item size as the part of array structure. In other dynamic array implementations, the size of each element is stored in along with the element count and array capacity. 
This is as intuitive as the dynamic arrays in other high level languages like C++, C#.
Here are some things that may help you improve your code.

Use the appropriate #includes

This program requires two headers, both of which should be included:

#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;


Check the return value of malloc

If the program runs out of memory, a call to malloc (or realloc) can fail.  The indication for this is that the call will return a NULL pointer.  You should check for this and avoid dereferencing a NULL pointer (which typically causes a program crash).  

Don't leak memory

This code leaks memory.  To begin with, the code calls malloc but there is no corresponding call to free.  For a usable general list, there should be something akin to list_destroy().

Be careful with multiline macros

Multiline macros can have odd effects if you're not careful. For instance, if we do this:

for (int i=10; i &lt; 70; ++i)
    list_append(arr, i);


The effect is that the if part of list_append is only executed once rather than once per iteration.  This can be fixed by wrapping all multiline macros in their own block by enclosing them in curly braces.  This will, however, have the side effect of no longer requiring a terminating semicolon if that matters to you.