✔ Eigene explode()-Funktion, bitte um Kommentare

[Bratkartoffel]

Hallo Forum,

habe vor Kurzem für ein Projekt meiner Firma eine Funktion schreiben müssen, welche einen String an Hand eines anderen Strings in mehrere Teile zerlegt.
Da das Ganze in C und nicht C++ gemacht werden soll, habe ich nach langem Googeln aufgegeben und mir selbst was zusammengezimmert.

Nun meine Frage an euch C-Geeks:
* Ist mein Ansatz korrekt?
* Erkennt ihr einen Fehler in der Implementierung?
* Kann man es einfacher lösen?

/*
original: Der String welcher geteilt werden soll
exploder: Die Zeichenkette, an welchem geteilt wird
countPtr: Ein Zeiger auf ein int, in welches die Anzahl der Teile gespeichert wird.
*/
const char** explode (const char* original, const char* exploder, int* countPtr) {
//  printf("Starting explode(\"%s\", \"%s\")\n", original, exploder);
  int lenExploder = strlen(exploder);
  int lenOriginal = strlen(original);

  char* pch = strstr(original, exploder);  // Trennstring suchen
  int matches = 1;  // Auf alle Fälle wird ein Teil zurückgeliefert

  // Schleife, um alle Vorkommen von exploder zu suchen und zu zählen
  while(pch != NULL) {
//    printf("Match: %s at %i from %i\n", pch, pch-original, lenOriginal);
    matches++;  // Treffer zählen
    pch+=lenExploder;  // Pointer auf Treffer inkrementieren und weitersuchen
    pch = strstr(pch, exploder);  // Nächstes Vorkommen suchen
  }

//  printf("Matches: %i\n", matches);
  // Anzahl der Treffer / erwarteten Teile speichern
  if(countPtr != NULL) *countPtr = matches;
  
  // Speicher für Teile reservieren
  const char** ret = (const char**) malloc(sizeof(const char*) * matches);

  // Pointer für den start der Suche auf den Anfang des Strings setzen
  char* start = (char*) original;
  int i=-1;  // Für Rückgabearray der aktuelle Index

  // Alle Vorkommen des Trennstrings suchen und
  // in pch die Adresse des Treffers speichern
  while((pch = strstr(start, exploder)) != NULL) {
    // Speicher in Rückgabearray für den Treffer reservieren
    ret[++i] = (char*) malloc(sizeof(char) * (pch-start));
    // Den Treffer in das Rückgabearray kopieren
    strncpy((char*) ret[i], start, pch-start);
    ((char*) ret[i])[pch-start] = '\0';  // Bugfix, strncpy() setzt kein \0 an das Ende!

//    printf("match=%s, from %i to %i\n", ret[i], start-original, pch-original);
    start = pch+lenExploder;  // Den neuen Startpunk der Suche festlegen
  }

  // Den letzten Teil nach dem letzten Trenner in das Rückgabearray kopieren
  ret[++i] = (char*) malloc(sizeof(char) * (lenOriginal - (original - start)));
  strcpy((char*) ret[i], start);

  // Fertig, Rückgabe der einzelnen Teile
  return ret;
}

Der Code funktioniert, aber ob er richtig ist, ist die andere Frage

// Edit: Code dürfte mehr oder weniger wie er oben steht nun produktiv genutzt werden. Schade dass keine Rückmeldungen gekommen sind :-/

Grüße
BK