When to allocate memory in C? -

i've got code bellow it's supposed move bit's position inside byte. works, question else?

what doing wrong , doing right regarding allocation of example_byte , new_byte? hassle simple program? should have not used malloc , let compiler dirty job better?

here guy's opinion in comments section : link.

#include <stdio.h> #include <malloc.h>  typedef unsigned __int8 byte;  byte move(byte* our, int indexold, int indexnew) { byte oldvalue; byte newvalue; byte valuetochange;  valuetochange = 0x01 & ((*our)>>indexold);         // value of bit moved printf("value change : %d\n", valuetochange); oldvalue = (*our) & (~(1<<(indexold)));            // del bit position indexold oldvalue = oldvalue & (~(1<<(indexnew)));          // del bit position indexnew printf("deleted: %x\n", oldvalue);  newvalue = oldvalue | (valuetochange<<(indexnew)); // write bit in new position (indexnew)  return newvalue; }  int main() { byte* example_byte; byte* new_byte;  example_byte = (byte*)malloc(sizeof(byte)); new_byte     = (byte*)malloc(sizeof(byte));  *example_byte = 0xc3;  //  hex 0xc3 = binary 1100 0011 printf("\n");  //***************************************************** // example 1 (move bit position 1 position 5) // example_byte  1100 0011 //                 ^    ^ //               memorize bit -> valuetochange = 0x01 & ((*our)>>indexold) = 1 //               1100 0011 & 1111 1101 = 1100 0001 delete bit oldindex (1) //               1100 0001 & 1101 1111 = 1100 0001 delete bit newindex (5) // new_byte      1100 0001 | 0010 0000 = 1110 0001 *new_byte     = move(example_byte, 1, 5);  printf("old byte : %x\n", *example_byte); // 0xc3 (1100 0011) printf("new byte : %x\n", *new_byte);     // 0xe1 (1110 0001) printf("\n");  //***************************************************** // example 2 (move bit position 6 position 3) // example_byte  1100 0011 //                ^   ^ //               memorize bit -> valuetochange = 0x01 & ((*our)>>indexold) = 1 //               1100 0011 & 1011 1111 = 1000 0011 delete bit oldindex (6) //               1000 0011 & 1111 0111 = 1000 0011 delete bit ftom newindex (3) // new_byte      1000 0011 | 0000 1000 = 1000 1011 *new_byte     = move(example_byte, 6, 3);  printf("old byte : %x\n", *example_byte); // 0xc3 (1100 0011) printf("new byte : %x\n", *new_byte);     // 0x8b (1000 1011) printf("\n");  //***************************************************** // example 3 (move bit position 2 position 6) // example_byte  1100 0011 //                ^    ^ //               memorize bit -> valuetochange = 0x01 & ((*our)>>indexold) = 0 //               1100 0011 & 1111 1011 = 1100 0011 delete bit oldindex (2) //               1100 0011 & 1011 1111 = 1000 0011 delete bit oldindex (6) // new_byte      1000 0011 | 0000 0000 = 1000 0011 *new_byte     = move(example_byte, 2, 6);  printf("old byte : %x\n", *example_byte); // 0xc3 (1100 0011) printf("new byte : %x\n", *new_byte);     // 0x83 (1000 0011) printf("\n");  //***************************************************** // example 4 (move bit position 2 position 4) // example_byte  1100 0011 //                  ^  ^ //               memorize bit -> valuetochange = 0x01 & ((*our)>>indexold) = 0 //               1100 0011 & 1111 1011 = 1100 0011 delete bit oldindex (2) //               1100 0011 & 1110 1111 = 1100 0011 delete bit oldindex (4) // new_byte      1100 0011 | 0000 0000 = 1100 0011 *new_byte     = move(example_byte, 2, 4);  printf("old byte : %x\n", *example_byte); // 0xc3 (1100 0011) printf("new byte : %x  ", *new_byte);     // 0xc3 (1100 0011) printf("\n");  free(new_byte); free(example_byte); return 0; } 

if single byte, there no reason memory allocation @ all. can declare local variable of type byte , pass around.

you need use malloc() when need allocate array of elements, , not know number of elements @ compile time. need when need allocate large structure needs persist in memory after function created exits. if dealing variable of primitive type, should declare local variable, means allocated automatically on stack.