Während memmove Speicherverschiebungen vornehmen kann, bei denen sich Ursprungs- und Zielbereich überlappen, muss bei memcpy der Programmierer sicherstellen, dass keine Überlappung vorliegt (dafür spart man ein bisschen Overhead).

Libraryfunktionen (Prototypen in Headerfiles ergänzen):

#include <string.h> void StrDelLen(char *string, size_t numChars) { size_t length = strlen(string); if (numChars > length) { numChars =length; } memmove(string, string + numChars, length - numChars + 1); } void StrInsStr(char *string, char const * toInsert) { size_t insertLength = strlen(toInsert); memmove(string + insertLength, string, strlen(string) + 1); memcpy(string, toInsert, insertLength); } void StrReplaceGlobal(char *string, char const * replace, char const * replacement, int global) { size_t replaceLength = strlen(replace); size_t replacementLength = strlen(replacement); char *p = string; do { p = strstr(p, replace); if (p) { StrDelLen(p, replaceLength); StrInsStr(p, replacement); p += replacementLength; if(!global) { return; } } } while(p); }

Selbstverständlich muss der Programmierer (wie immer in C), dafür sorgen, dass string auf einen Bufferbereich zeigt, der ausreichend Platz für die Ersetzung bereitstellt.

Die Funktion ist zu langsam, weil ...:

• Sobald der Suchstring gefunden wurde, wird dieser erst entfernt (umkopieren des gesamten Reststrings nach vorne)
• Danach wird der Speicherbereich wieder nach hinten geschoben (um Platz für den Ersetzungsstring zu schaffen)
• Und das wird dann auch noch für jeden Treffer wiederholt.

Die ersten beiden Punkte könnte man korrigieren, indem man je nachdem, ob der Ersetzungsstring größer oder kleiner ist, den Reststring direkt an die richtige Position verschiebt, und dann nur noch den Ersetzungsstring einsetzt, etwa so:

void StrReplaceGlobal(char * p, char const * match, char const * replacement, int global) { size_t match_len = strlen(match); size_t replacement_len = strlen(replacement); int relsize = replacement_len - match_len; char * pseudoend = p + strlen(p) - match_len; do { p = strstr(p, match); if (p) { if (relsize) { memmove( p + match_len, p + match_len + relsize, pseudoend - p ); } memcpy(p, replacement, replacement_len); p += replacement_len; if(!global) { return; } } } while(p); }

Den letzten Punkt zu beseitigen, wird ein bischen schwieriger, man zählt wohl zuerst alle vorkommen, und ersetzt dann rückwärts. -- BodoThiesen

Wolf, ich denke das ist ein reines Sprachproblem. Ich muss nicht optimieren, ich kann etwas auch nur auf professionelle Weise tun. Und was bedeutet schon "triftig" ? Das ist eine sehr persönliche Angelegenheit. Wenn ich als Auftraggeber einen Programmierer bezahle, dann stelle ich mich auf deinen Standpunkt und sage: "vergeude keine Arbeitszeit auf etwas mir nicht plausibles". Wenn ich aber als freischaffender Programmierer eine Software entwickle, dann folge ich meinem Gefühl für Qualität, egal ob eine Codebewegung als Optimierung interpretiert werden kann oder nicht, und lass mir dabei von niemandem Vorschriften machen. -- HelmutLeitner 6. August 2009 18:06 CET

Ich hätte das Wort triftig wohl besser weglassen sollen. Ich wollte gar nicht meine Meinung zu dieser konkreten Funktion darstellen, sondern nur einen Gegengewicht zum Punkt Die Funktion ist zu langsam, weil... setzen - hatte also vielleicht auch missverständlich eingerückt. --WolfPeuker 26. August 2009 16:44 CET

Dieses Thema wird vermutlich einigen Platz verschlingen, deswegen ist es wahrscheinlich zweckvoll, das als eigene Seite zu beginnen: VariableTabellenInCeeIdiomSammlung.

• WarumMussCeeWieModulaAussehen
• ZeigerAufAusreichendPlatzAlsCeeIdiom
• ZeigerMitLängeAlsCeeIdiom