void f1(char *explanation){ char p1;
 p1 = malloc(100); (void) sprintf(p1, "The f1 error occurred because of '%s'.", explanation); local_log(p1);}

int getkey(char *filename){ FILE *fp; int key;
 fp = fopen(filename, "r"); fscanf(fp, "%d", &key); return key; }

void f2(int datum){ int *p2;
 /* Uh-oh! No one has initialized p2. */ *p2 = datum; ...        }

/* Allocate once, free twice. */void f3(){ char *p;
 p = malloc(10); ... free(p); ... free(p); }
 /* Allocate zero times, free once. */void f4(){ char *p;
 /* Note that p remains uninitialized here. */ free(p);}

void f8() { struct x *xp;
 xp = (struct x *) malloc(sizeof (struct x)); xp.q = 13; ... free(xp); ... /* Problem! There's no guarantee that the memory block to which xp points hasn't been overwritten. */ return xp.q; }

/********* ...** Note that any function invoking protected_file_read()* assumes responsibility eventually to fclose() its* return value, UNLESS that value is NULL.*********/FILE *protected_file_read(char *filename){ FILE *fp;
 fp = fopen(filename, "r"); if (fp) {... } else {... } return fp;}
 /******** ...** Note that the return value of get_message points to a* fixed memory location. Do NOT free() it; remember to* make a copy if it must be retained ...*********/char *get_message(){ static char this_buffer[400];
 ... (void) sprintf(this_buffer, ...); return this_buffer; }

 /********* ...* While this function uses heap memory, and so * temporarily might expand the over-all memory* footprint, it properly cleans up after itself.* ********/ int f6(char *item1){ my_class c1; int result; ... c1 = new my_class(item1); ... result = c1.x; delete c1; return result;}/********* ...* Note that f8() is documented to return a value* which needs to be returned to heap; as f7 thinly* wraps f8, any code which invokes f7() must be* careful to free() the return value.*********/int *f7(){ int *p;
 p = f8(...); ... return p;}

static char *important_pointer = NULL;void f9(){ if (!important_pointer) important_pointer = malloc(IMPORTANT_SIZE); ... if (condition) /* Ooops! We just lost the reference  important_pointer already held. */important_pointer = malloc(DIFFERENT_SIZE); ...        }

int main(){ char p[5]; strcpy(p, "Hello, world."); puts(p);}