Najbezpieczniejszy i najbardziej czytelny sposób na zawijanie algorytmu w ogólne argumenty?

Jest mało prawdopodobne, aby była wydajna, ale możesz łatwo odwrócić swoją wersję void reverseString(void *array, short typeSize) elementów za pomocą trywialnej arytmetyki wskaźnika i memcpys o odpowiednim rozmiarze.

Oczywiście to podejście nie ma zastosowania do każdego algorytmu, który ma być niezależny od typu. Z Twojego pytania nie wynika jasno, czy interesuje Cię tylko ten konkretny algorytm, czy algorytmy w ogóle.

[Na marginesie: Zauważ, że używanie zamiany XOR nie będzie bardziej efektywne niż robienie tego "naiwnie". Z pewnością jest mniej czytelny!]

... uniwersalne rozwiązanie...

Rozwiązaniem jest napisanie czegoś takiego jak qsort(): wszystkie funkcje, które muszą znać rozmiar poszczególnych wartości, są przekazywane do twojej własnej funkcji ze wskaźnikami do void all over

#include <math.h>
#include <stdio.h>
#include <wchar.h>

void universalReverseArray(void *arr, size_t siz,
                           size_t (*arrlen)(void*),
                           void (*swap)(void*, void*))
{
  size_t elems = arrlen(arr);
  size_t i = 0;
  size_t m = elems >> 1;
  unsigned char *p = arr;

  while(i < m) {
    swap(p + i * siz, p + (elems - 1) * siz);
    i++;
    elems--;
  }
}

void cswap(void *a, void *b) {
  char *aa = a, *bb = b;
  char t = *aa;
  *aa = *bb;
  *bb = t;
}

void dswap(void *a, void *b) {
  double *aa = a, *bb = b;
  double t = *aa;
  *aa = *bb;
  *bb = t;
}

void wswap(void *a, void *b) {
  wchar_t *aa = a, *bb = b;
  wchar_t t = *aa;
  *aa = *bb;
  *bb = t;
}

size_t clen(void *arr) {
  char *aa = arr;
  size_t retval = 0;
  while (*aa) {
    retval += 1;
    aa += 1;
  }
  return retval;
}

size_t dlen(void *arr) {
  double *aa = arr;
  size_t retval = 0;
  while (fabs(*aa) >= 0.0001) {
    retval += 1;
    aa += 1;
  }
  return retval;
}

size_t wlen(void *arr) {
  wchar_t *aa = arr;
  size_t retval = 0;
  while (*aa) {
    retval += 1;
    aa += 1;
  }
  return retval;
}

int main(void) {
  double x[] = {1, 2, 3, 4, 5, 0};
  char y[] = "foobar";
  wchar_t z[4];
  z[0] = 'a'; z[1] = 'b'; z[2] = 'c'; z[3] = 0;

  for (int k=0; k<5; k++) {printf("%f ", x[k]);}
  printf("%s ", y);
  printf("%ls\n", z);

  universalReverseArray(x, sizeof *x, dlen, dswap);
  universalReverseArray(y, sizeof *y, clen, cswap);
  universalReverseArray(z, sizeof *z, wlen, wswap);

  for (int k=0; k<5; k++) {printf("%f ", x[k]);}
  printf("%s ", y);
  printf("%ls\n", z);

  return 0;
}

Możesz zobaczyć, jak działa na ideone: http://ideone.com/t1iOg