Simple C: Filling in the blanks - A simple memory allocator/reallocator.

// main.c

/*
 * Simple memory allocation, reallocation using built-in
 * libc calls.  Based on strdup() and strcat() concepts.
 */

// use gnu99 so we can declare loop index inside for(...) block in tester
// COMPILE: gcc -std=gnu99 main.c -o main

#include <stdio.h>
#include <string.h>
#include <malloc.h>
void dbg(){}  // Try kdbg if you haven't yet.  It's dynamite.  
              // Add -g3 to the compile line if you want to enable it.

/////////////////////////////////////////////////////////////////////////
// The calling function is responsible for free-ing the memory after use.

// use xmalloc() and xrealloc() if you need safety over simplicity and speed.
void _memcat(void** dest, int* destsize, const void* src, int srcsize)
{
  int dsz = *destsize;
  *destsize += srcsize;
  *dest = realloc(*dest, dsz + srcsize);
  memcpy((char*)*dest + dsz, src, srcsize); 
  // the call at the end eliminates an unnecessary call/return pair.
  // Asm coders, see note at the bottom.
}

void _memdup(void** dest, int* destsize, const void* src, int srcsize)
{
  *dest = malloc(srcsize);
  *destsize = srcsize;
  memcpy(*dest, src, srcsize);  
}

// NOTE:
// Since C++ syntax is so strict we can create aliases that will cast the
// input params to the type needed by the functions.  This is a little risky 
// because even 'longs' can be case to char**, and crazy stuff like that so 
// consider deleting these and renaming the above without the underscore prefix 
// to renenable the more comprehensive error checks.  But this CAN be done 
// and may make breaking the ice a little more palletable for folks coming 
// from other programming languages that aren't so strict.

#define memcat(dest, destsize, src, srcsize) \
  _memcat((void**)dest, destsize, (const void*)src, srcsize)

#define memdup(dest, destsize, src, srcsize) \
  _memdup((void**)dest, destsize, (const void*)src, srcsize)


///////////////////////////////////////////////////////////////////////
// Example: 
int main(int argc, char** argv)
{
  dbg();
  const char* a = "this is a";
  const char* b = "this is b";
  
  // the memory descriptor is a base pointer and a length variable.
  // they could have been in a single object but we'll keep them 
  // separate here so the parameter lists make clear what's going on,
  // especially for those new to C/C++.
  void* pa;
  int palen;
  
  
  int paptr; // a temp for test
  
  // here we go... duplicate string a plus its terminator using memory
  // blocks instead of strings, per se.
  memdup(&pa, &palen, a, strlen(a) + 1);
  printf("memdup()\n0x%0X: %s\n", pa, pa);

  // you can lie about the buffer length to truncate the block as far
  // as the descriptor is concerned.  Don't truncate to < 0 though and
  // don't increase the length or the end of the block may be in 
  // non-existent memory.
  palen--; // remove terminator (the lie)
  
  // add a five-byte string to the memory block
  memcat(&pa, &palen, " and ", 5); 
  
  // add string b and it's null char terminator.
  memcat(&pa, &palen, b, strlen(b) + 1);
  
  // Let's have a look...
  printf("memcat()\n0x%0X: %s\n", pa, pa);

  free(pa);
  return 0;
}

stradd(char** s, const char* newstr);