symmetry of responsibility [study notes]

Stanford -- programming paradigms [lesson 6]

 

About symmetry of responsibility:

the lecturer writes an int version of Stack and then write a generic version of Stack

the int version's stackPop() interface is like this:

int stackPop(Stack* s);

but the generic version of Stack doesn't return the void* type like the int one did:

void stackPop(Stack* s,  void* elemAddr);

Quote some words from the lecturer about this: 

This used to be int. If I wanted to I could have punted on this right here and just passed in
one argument. And I could have returned a void * that pointed to a dynamically allocated
element that’s elemSize bytes wide. And I just would have copied not into elemAddr, but
into the result of the malloc call. With very few exceptions, malloc and strdup and realloc
being them, you usually don’t like a function to dynamically allocate space for the call
and then make it the responsibility of the person who called the function to free it. 

There’s this asymmetry of responsibility, and you try to get in the habit as much as
possible of making any function that allocates memory be the thing that deallocate’s it as
well. There’s just some symmetry there and it’s just easier to maintain dynamically
allocated memory responsibilities.