CareerCup

int sprintf ( char * buffer, const char * format [ , argument , ...] );
#define is handled by preprocessor, typedef by compiler
#define has no scope control
some things cannot be done by #define like intelligent declaration of pointers.
typedef int* int_p1;
int_p1 a, b, c; // a, b, and c are all int pointers.

#define int_p2 int*
int_p2 a, b, c; // only the first is a pointer!

#define swap(t, x, y) { \
                                        t _z; \
                                        _z = x; \
                                        x = y; \
                                        y = _z; \
                                    }

1. Generic macro for swapping values of any POD type
2. Only glitch is, it won't work if one of the arguments is _z

macro for swapping two values of the same type:

#define swapp(a,b) a=((a+b)-(b=a))

3)how free remembers how many bytes to delete

Its implementation dependent. In Linux, malloc allocates 4 bbytes more than the actual allocation size. These 4 bytes are 4 bytes before the allocated pointer. And they store the amount of memory allocated by malloc. So when free(ptr) is called, the compiler goes 4 bytes before ptr and reads the amount to be deleted.
This could be totally different for other OSs. Something like maintaining a table of allocations with pointer allocated as key by the heap manager. Or storing the number of bytes allocated as the first few bytes of allocation. HTH

typedef is interpreted by the compiler whereas define is not .

When you call malloc(), you specify the amount of memory to allocate. The amount of memory actually used is slightly more than this, and includes extra information that records (at least) how big the block is. You can't (reliably) access that other information - and nor should you :-).

When you call free(), it simply looks at the extra information to find out how big the block is.
typically this is stored at the end of the block but is highly machine dependent as in some machines this is mapped at some other location.