Un-ugly my ReplaceString C function?

-=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- (c) WidthPadding Industries 1987 0\|399\|0 -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=- -=+=-
Socoder -> C/C++/C#/Other -> Un-ugly my ReplaceString C function?
Wed, 22 Sep 2010, 10:14
HoboBen	So I've got this C function to replace any string (needle) with a string (replacement) within a string (haystack). It works, with all the edge cases I've tried it against, and I think it's quite efficient as it doesn't allocate any memory other than one malloc for the result string. But it's really, really verbose and ugly! Can anyone suggest improvements? Usage: printf("New string: %s\n", Pox_ReplaceString("great", "ok", "have a g grea great day and have a great day great")); printf("New string: %s\n", Pox_ReplaceString("great", "fantastic", "have a g grea great day and have a great day great")); char ReplaceString(char needle, char replace, char haystack) { char newString; uint lNeedle = strlen(needle); uint lReplace = strlen(replace); uint lHaystack = strlen(haystack); uint i; uint j = 0; uint k = 0; uint lNew; char active = 0; uint start = 0; uint end = 0; / Calculate new string size / lNew = lHaystack; for (i = 0; i < lHaystack; i++) { if ( (!active) && (haystack[i] == needle[0])) { / Start of needle found / active = 1; start = i; end = i; } else if ( (active) && (i-start == lNeedle) ) { / End of needle / active = 0; lNew += lReplace - lNeedle; } else if ( (active) && (i-start < lNeedle) && (haystack[i] == needle[i-start]) ) { / Next part of needle found / end++; } else if (active) { / Didn't match the entire needle... / active = 0; } } printf("Length: %d --> %d\n", lHaystack, lNew); active= 0; end = 0; / Prepare new string / newString = malloc(sizeof(char) lNew + 1); newString[sizeof(char) * lNew] = 0; /* Build new string / for (i = 0; i < lHaystack; i++) { if ( (!active) && (haystack[i] == needle[0])) { / Start of needle found / active = 1; start = i; end = i; } else if ( (active) && (i-start == lNeedle) ) { / End of needle - apply replacement / active = 0; for (k = 0; k < lReplace; k++) { newString[j] = replace[k]; j++; } newString[j] = haystack[i]; j++; } else if ( (active) && (i-start < lNeedle) && (haystack[i] == needle[i-start]) ) { / Next part of needle found / end++; } else if (active) { / Didn't match the entire needle, so apply skipped chars / active = 0; for (k = start; k < end+2; k++) { newString[j] = haystack[k]; j++; } } else if (!active) { / No needle matched / newString[j] = haystack[i]; j++; } } / If still matching a needle... / if ( active && (i-start == lNeedle)) { / If full needle */ for (k = 0; k < lReplace; k++) { newString[j] = replace[k]; j++; } newString[j] = haystack[i]; j++; } else if (active) { for (k = start; k < end+2; k++) { newString[j] = haystack[k]; j++; } } return newString; } --v (edit: For comparison, and because I feel like boasting, Cobra's Replace takes 1.929 seconds for 1000,000 iterations, Blitz3D takes 1.269, while mine takes 0.337 on a 0.6Ghz slower CPU! ) -=-=- blog \| work \| code \| more code
Wed, 22 Sep 2010, 12:13
Afr0	How comes Cobra's slower than Blitz3D?
Wed, 22 Sep 2010, 12:16
HoboBen	Cobra really falls down on string manipulation (although it's only ~50% slower than Blitz, hardly orders of magnitude, and string manipulation in any language is slow). -=-=- blog \| work \| code \| more code
Wed, 22 Sep 2010, 13:45
Jayenkai	Looks very efficient! Every time I find myself thinking "Why not use...", it's usually a basic String function that's the answer, and since I'm trying to avoid those (because, you obviously have, and I'm not going to argue with that!) then I can't seem to think enough to make it any neater! or rather... Not without plain compacting, and making things into those unreadable horrible one-line "double if" things.. eeuw! At least this is vaguely readable! I wonder.. In Cobra, if you switch to ascii character numbers, make an array of those numbers (like a C string does), then did this function style stuff to the numbers, and then flipped it back into a string afterwards... Would that prove to be any quicker than faffing about with the strings? -=-=- ''Load, Next List!''
Wed, 22 Sep 2010, 13:55
HoboBen	@Jay, I've actually thought about re-implementing Cobra strings with banks (perhaps with UTF8 support), so that's an interesting idea and I may well attempt it soon. StackOverflow couldn't come up with anything other than the fact that I can avoid strlen(haystack) since I'm looping through it anyway. I'm mainly surprised by how long it is in terms of lines of code (three-and-a-half screens!), but nobody else seemed surprised (maybe that's normal for C!!!). I've got far more important functions that fit into ten lines, but I guess ReplaceString is heading to quite a low level compared to other functions. For any future googlers, here's my revised version: char ReplaceString(char needle, char replace, char haystack) { char newString; uint lNeedle = strlen(needle); uint lReplace = strlen(replace); uint lHaystack; uint i; uint j = 0; uint k = 0; uint lNew = 0; char active = 0; uint start = 0; uint end = 0; / Calculate new string size / for (i = 0; haystack[i] != '\0'; i++) { if ( (!active) && (haystack[i] == needle[0])) { / Start of needle found / active = 1; start = i; end = i; } else if ( (active) && (i-start == lNeedle) ) { / End of needle / active = 0; lNew += lReplace - lNeedle; } else if ( (active) && (i-start < lNeedle) && (haystack[i] == needle[i-start]) ) { / Next part of needle found / end++; } else if (active) { / Didn't match the entire needle... / active = 0; } } lHaystack = i; lNew += lHaystack; active= 0; end = 0; / Prepare new string / newString = malloc(sizeof(char) lNew + 1); newString[sizeof(char) * lNew] = 0; /* Build new string / for (i = 0; i < lHaystack; i++) { if ( (!active) && (haystack[i] == needle[0])) { / Start of needle found / active = 1; start = i; end = i; } else if ( (active) && (i-start == lNeedle) ) { / End of needle - apply replacement / active = 0; for (k = 0; k < lReplace; k++) { newString[j] = replace[k]; j++; } newString[j] = haystack[i]; j++; } else if ( (active) && (i-start < lNeedle) && (haystack[i] == needle[i-start])) { / Next part of needle found / end++; } else if (active) { / Didn't match the entire needle, so apply skipped chars / active = 0; for (k = start; k < end+2; k++) { newString[j] = haystack[k]; j++; } } else if (!active) { / No needle matched / newString[j] = haystack[i]; j++; } } / If still matching a needle... / if ( active && (i-start == lNeedle)) { / If full needle */ for (k = 0; k < lReplace; k++) { newString[j] = replace[k]; j++; } newString[j] = haystack[i]; j++; } else if (active) { for (k = start; k < end+2; k++) { newString[j] = haystack[k]; j++; } } return newString; } --v -=-=- blog \| work \| code \| more code
Wed, 22 Sep 2010, 14:28
Afr0	Unless you really mind mixing C and C++ code, you should be able (?) to use the boost::regex class to do what this function already does, but faster. -=-=- Afr0 Games Project Dollhouse on Github - Please fork!
Wed, 22 Sep 2010, 14:51
Jayenkai	I don't think that was the point, Afr0.
Wed, 22 Sep 2010, 15:04
Afr0	Heh... he wanted suggestions of improvement. Apparently I read that as 'Suggestion of improvement either in terms of code or alternatives...!' Oh well, I suggested an alternative at least! -=-=- Afr0 Games Project Dollhouse on Github - Please fork!
Thu, 23 Sep 2010, 02:06
Cower	I'm not sure what you're using to get your timing, but try mine: char stringReplace(const char haystack, const char needle, const char replace) { char out_str, out_ptr; int needle_len, out_len, replace_len; const char replace_iter, haystack_iter; if (!(haystack \|\| needle)) { return NULL; } out_str = out_ptr = NULL; needle_len = strlen(needle); replace_len = (replace ? strlen(replace) : 0) - needle_len; haystack_iter = haystack; while (haystack_iter) { if (strncmp(haystack_iter, needle, needle_len) == 0) { out_len += replace_len; haystack_iter += needle_len; continue; } ++haystack_iter; } haystack_iter = haystack; out_ptr = out_str = (char)calloc(out_len + 1, sizeof(char)); while (haystack_iter) { if (strncmp(haystack_iter, needle, needle_len) == 0) { if (replace) { replace_iter = replace; while (replace_iter) (out_ptr++) = (replace_iter++); } haystack_iter += needle_len; continue; } (out_ptr++) = (haystack_iter++); } *out_ptr = '\0'; return out_str; } --v Interface is pretty much the same, so probably test-able. I'm just curious to see how it compares.
Thu, 23 Sep 2010, 06:43
HoboBen	Thanks Cower... I'm afraid yours seg faults after ~1000 iterations so I couldn't compare them. Here's my test (uncomment/comment parts in main() to see the difference): /* Compile: $ gcc -ansi -pedantic -W -Wall -Wconversion -Wshadow -O2 replace.c -o replace Or simply: $ gcc replace.c -o replace Run: $ ./replace To benchmark: $ time ./replace / #include <stdlib.h> #include <string.h> #include <stdio.h> #ifndef uint #define uint unsigned int #endif char stringReplace_cower(const char haystack, const char needle, const char replace) { char out_str, out_ptr; int needle_len, out_len, replace_len; const char replace_iter, haystack_iter; if (!(haystack \|\| needle)) { return NULL; } out_str = out_ptr = NULL; needle_len = strlen(needle); replace_len = (replace ? strlen(replace) : 0) - needle_len; haystack_iter = haystack; while (haystack_iter) { if (strncmp(haystack_iter, needle, needle_len) == 0) { out_len += replace_len; haystack_iter += needle_len; continue; } ++haystack_iter; } haystack_iter = haystack; out_ptr = out_str = (char)calloc(out_len + 1, sizeof(char)); while (haystack_iter) { if (strncmp(haystack_iter, needle, needle_len) == 0) { if (replace) { replace_iter = replace; while (replace_iter) (out_ptr++) = (replace_iter++); } haystack_iter += needle_len; continue; } (out_ptr++) = (haystack_iter++); } out_ptr = '\0'; return out_str; } char ReplaceString_ben(char needle, char replace, char haystack) { char newString; uint lNeedle = strlen(needle); uint lReplace = strlen(replace); uint lHaystack; uint i; uint j = 0; uint k = 0; uint lNew = 0; char active = 0; uint start = 0; uint end = 0; / Calculate new string size / for (i = 0; haystack[i] != '\0'; i++) { if ( (!active) && (haystack[i] == needle[0])) { / Start of needle found / active = 1; start = i; end = i; } else if ( (active) && (i-start == lNeedle) ) { / End of needle / active = 0; lNew += lReplace - lNeedle; } else if ( (active) && (i-start < lNeedle) && (haystack[i] == needle[i-start]) ) { / Next part of needle found / end++; } else if (active) { / Didn't match the entire needle... / active = 0; } } lHaystack = i; lNew += lHaystack; active= 0; end = 0; / Prepare new string / newString = malloc(sizeof(char) lNew + 1); newString[sizeof(char) * lNew] = 0; /* Build new string / for (i = 0; i < lHaystack; i++) { if ( (!active) && (haystack[i] == needle[0])) { / Start of needle found / active = 1; start = i; end = i; } else if ( (active) && (i-start == lNeedle) ) { / End of needle - apply replacement / active = 0; for (k = 0; k < lReplace; k++) { newString[j] = replace[k]; j++; } newString[j] = haystack[i]; j++; } else if ( (active) && (i-start < lNeedle) && (haystack[i] == needle[i-start])) { / Next part of needle found / end++; } else if (active) { / Didn't match the entire needle, so apply skipped chars / active = 0; for (k = start; k < end+2; k++) { newString[j] = haystack[k]; j++; } } else if (!active) { / No needle matched / newString[j] = haystack[i]; j++; } } / If still matching a needle... / if ( active && (i-start == lNeedle)) { / If full needle / for (k = 0; k < lReplace; k++) { newString[j] = replace[k]; j++; } newString[j] = haystack[i]; j++; } else if (active) { for (k = start; k < end+2; k++) { newString[j] = haystack[k]; j++; } } return newString; } int main(void) { char s = "Have a nice day!"; int i; /* Test they work correctly: printf("Original: %s\n", s); printf("Replaced (ben): %s\n", ReplaceString_ben("nice", "fantastic", s)); printf("Replaced (cower): %s\n", stringReplace_cower(s, "nice", "fantastic")); / for (i = 0; i < 10000000; i++) / 10,000,000 / { / time ./replace --> 0m2.774s (10,000,000 iterations) / / ReplaceString_ben("nice", "fantastic", s); / / time ./replace --> ?m?.???s (10,000,000 iterations) */ stringReplace_cower(s, "nice", "fantastic"); } return 0; } --v -=-=- blog \| work \| code \| more code
Thu, 23 Sep 2010, 09:19
Cower	Interesting that it'd segfault only after so many iterations. O_o
Thu, 23 Sep 2010, 13:38
Cower	After fixing mine up a bit, it takes 12141ms for 10,000,000 iterations. So, that comes to about 0.0012141ms per call. Yours takes about 3680ms, which is about 0.000368ms per call, which is damned impressive. So, I modified mine: char stringReplace_cower(const char haystack, const char needle, const char replace) { char out_str, out_ptr; int needle_len, out_len, replace_len; const char replace_iter, haystack_iter; const char haystack_end; const char search = NULL; const char haystack_last = haystack; const char needle_end; if (!(haystack && needle && haystack && needle)) { return NULL; } out_len = 0; haystack_end = haystack + strlen(haystack); out_str = out_ptr = NULL; needle_len = strlen(needle); replace_len = ((replace && replace) ? strlen(replace) : 0) - needle_len--; haystack_iter = haystack; needle_end = needle + needle_len; while (haystack_iter) { if (!search && (haystack_iter+needle_len) < haystack_end && haystack_iter == needle && (haystack_iter+needle_len)) { search = needle+1; haystack_last = ++haystack_iter; ++out_len; } if (search) { if (search == needle_end) { out_len += replace_len; search = NULL; } else if (search == haystack_iter) { ++search; } else { search = NULL; haystack_iter = haystack_last; } } ++haystack_iter; ++out_len; } haystack_iter = haystack; out_ptr = out_str = (char)malloc(out_len + 1 * sizeof(char)); while (haystack_iter) { if (!search && (haystack_iter+needle_len) < haystack_end && haystack_iter == needle && (haystack_iter+needle_len)) { search = needle+1; out_ptr = (haystack_iter++); haystack_last = haystack_iter; } if (search) { if (search == needle_end) { // replacement matched ++haystack_iter; replace_iter = replace; while (replace_iter) (out_ptr++) = (replace_iter++); search = NULL; } else if (search == haystack_iter) { ++search; } else { search = NULL; haystack_iter = haystack_last; ++out_ptr; } } if (!search) { (out_ptr++) = haystack_iter; } ++haystack_iter; } out_ptr = '\0'; return out_str; } --v Which resulted in this: So about 0.000384ms per call on average for yours, and 0.000398ms for mine. And the bit of code used for timing is incredibly primitive, so not a lot going on there. int main(void) { char s = "Have an unpleasantly nice day!"; int i; / Test they work correctly: / printf("Original: %s\n", s); printf("Replaced (ben): %s\n", ReplaceString_ben("nice", "fantastic", s)); printf("Replaced (cower): %s\n", stringReplace_cower(s, "nice", "fantastic")); struct timeval tv_start; struct timeval tv_end; gettimeofday(&tv_start, NULL); for (i = 0; i < 10000000; i++) / 10,000,000 / { / time ./replace --> 0m2.774s (10,000,000 iterations) / // ReplaceString_ben("nice", "fantastic", s); / time ./replace --> ?m?.???s (10,000,000 iterations) / stringReplace_cower(s, "nice", "fantastic"); } gettimeofday(&tv_end, NULL); long long start = tv_start.tv_usec / 1000 + tv_start.tv_sec 1000; long long end = tv_end.tv_usec / 1000 + tv_end.tv_sec * 1000; printf("Time elapsed: %Ldms\n", (end - start)); return 0; } --v
Thu, 23 Sep 2010, 15:11
HoboBen	Thanks Cower I'm very shocked that mine stood up to the test! I also noticed, unless you wrap ReplaceString in free(), e.g. free(ReplaceString("nice", "fantastic", s)); It will leak memory! (Especially over 10,000,000 iterations!) -=-=- blog \| work \| code \| more code
Thu, 23 Sep 2010, 15:42
Cower	Leaking memory is fine for testing speed in this case.
Fri, 24 Sep 2010, 07:51
HoboBen	Got rid one of the calls to strlen... reasonably faster \|edit\| Apparently this version is broken... I printf'd the wrong test! \|edit\| -=-=- blog \| work \| code \| more code
Fri, 24 Sep 2010, 08:30
Cower	Only problem with your new version is it doesn't work. >_> Original: Have an unpleasantly nice day! Replaced (ben): Have afantastic ufantasticpleasafantastictly fantasticice day! Replaced (cower): Have an unpleasantly fantastic day! --v Aside from that, mine's currently faster at 0.000327ms per call: \|edit\| Just shaved 100ms off the total \|edit\| char stringReplace_cower(const char haystack, const char needle, const char replace) { char out_str, out_ptr; int out_len, replace_len; const char replace_iter, haystack_iter; const char search = NULL; const char haystack_last = haystack; if (!(haystack && needle && haystack && needle)) { return NULL; } out_len = 0; out_str = out_ptr = NULL; replace_len = (replace ? strlen(replace) : 0); haystack_iter = haystack; while (haystack_iter) { if (!search && haystack_iter == needle) { search = needle+1; haystack_last = ++haystack_iter; ++out_len; } if (search) { if (!search) { out_len += replace_len; search = NULL; } else if (search == haystack_iter) { ++search; } else { search = NULL; haystack_iter = haystack_last; } } ++out_len; ++haystack_iter; } haystack_iter = haystack; out_ptr = out_str = (char)malloc(out_len + 1 sizeof(char)); char haystack_val = 0; while ((haystack_val = haystack_iter)) { if (!search && haystack_iter == needle) { search = needle+1; out_ptr = haystack_iter; haystack_val = (haystack_last = ++haystack_iter); } if (search) { char val = search; if (!val) { // replacement matched replace_iter = replace; while (replace_iter) (out_ptr++) = (replace_iter++); search = NULL; } else if (val == haystack_val) { ++search; } else { search = NULL; ++out_ptr; } } if (!search) { (out_ptr++) = haystack_val; } ++haystack_iter; } out_ptr = '\0'; return out_str; } --v
Fri, 24 Sep 2010, 08:58
HoboBen	The game is on!!! Fixed my faster version, so that it actually works: char ReplaceString_ben2(char needle, char replace, char haystack) { char newString; uint lNeedle = 0; uint lReplace = strlen(replace); uint lHaystack; uint i; uint j = 0; uint k = 0; uint lNew = 0; char active = 0; uint start = 0; uint end = 0; / Calculate new string size / for (i = 0; haystack[i] != '\0'; i++) { if ( (!active) && (haystack[i] == needle[0])) { / Start of needle found / active = 1; start = i; end = i; } else if ( (active) && (needle[i-start] == 0) ) { / End of needle / active = 0; lNew += lReplace - (i-start); lNeedle = (i-start); } else if ( (active) && (needle[i-start] != 0) && (haystack[i] == needle[i-start]) ) { / Next part of needle found / end++; } else if (active) { / Didn't match the entire needle... / active = 0; } } lHaystack = i; lNew += lHaystack; active= 0; end = 0; / Prepare new string / newString = malloc(sizeof(char) lNew + 1); newString[sizeof(char) * lNew] = 0; /* Build new string / for (i = 0; i < lHaystack; i++) { if ( (!active) && (haystack[i] == needle[0])) { / Start of needle found / active = 1; start = i; end = i; } else if ( (active) && (i-start == lNeedle) ) { / End of needle - apply replacement / active = 0; for (k = 0; k < lReplace; k++) { newString[j] = replace[k]; j++; } newString[j] = haystack[i]; j++; } else if ( (active) && (i-start < lNeedle) && (haystack[i] == needle[i-start])) { / Next part of needle found / end++; } else if (active) { / Didn't match the entire needle, so apply skipped chars / active = 0; for (k = start; k < end+2; k++) { newString[j] = haystack[k]; j++; } } else if (!active) { / No needle matched / newString[j] = haystack[i]; j++; } } / If still matching a needle... / if ( active && (i-start == lNeedle)) { / If full needle */ for (k = 0; k < lReplace; k++) { newString[j] = replace[k]; j++; } newString[j] = haystack[i]; j++; } else if (active) { for (k = start; k < end+2; k++) { newString[j] = haystack[k]; j++; } } return newString; } --v edit: Much slower than yours now though! -=-=- blog \| work \| code \| more code
Fri, 24 Sep 2010, 10:03
Cower	New version, down to 0.000310 ms/call average. char stringReplace_cower(const char haystack, const char needle, const char replace) { char out_str, out_ptr; // output string, pointer used for modifying output int out_len, replace_len; // output length, replacement length const char replace_iter, haystack_iter; // replacement iterater, haystack iterator const char needle_iter = NULL; // needle iterator const char haystack_last; // last known position in the haystack, used for backtracking char haystack_val = 0; // last known value in the haystack (used to cut down on derefs) char needle_val = 0; // current value in the needle search if (!(haystack && needle && haystack && needle)) { // no usable haystack or needle = gtfo return NULL; } out_len = 0; out_str = out_ptr = NULL; replace_len = (replace ? strlen(replace) : 0); haystack_iter = haystack; // iterate through haystack string while ((haystack_val = haystack_iter)) { // if there is no ongoing search and the first char of the needle matches // the current haystack value, begin a search if (!needle_iter && haystack_val == needle) { // increment length/iterators since we already know about the first character needle_iter = needle+1; haystack_last = ++haystack_iter; ++out_len; continue; } // if there's an ongoing search if (needle_iter) { needle_val = needle_iter; if (!needle_val) { // search complete, string matches the needle --out_len; // decrement length to account for the needle's length out_len += replace_len; // add the length of the replacement string to the output length needle_iter = NULL; // end the search } else if (needle_val == haystack_val) { // search is ongoing and still matching ++needle_iter; --out_len; // decrement length to account for the needle's length } else { // there was a non-matching character, terminate the search needle_iter = NULL; // backtrack to the last match haystack_iter = haystack_last; } } ++out_len; ++haystack_iter; } haystack_iter = haystack; out_ptr = out_str = (char)malloc(out_len + 1 * sizeof(char)); while ((haystack_val = haystack_iter)) { if (!needle_iter && haystack_iter == needle) { needle_iter = needle+1; // we're now assigning characters to the output out_ptr = haystack_val; haystack_last = ++haystack_iter; continue; } if (needle_iter) { if (!(needle_val = needle_iter)) { // replacement matched replace_iter = replace; // iterate over the replacement, inserting its characters // into the output string while (replace_iter) (out_ptr++) = (replace_iter++); // end search needle_iter = NULL; } else if (needle_val == haystack_val) { // incrmeent needle search ++needle_iter; } else { // something didn't match, end the search needle_iter = NULL; ++out_ptr; } } if (!needle_iter) { // if no search is ongoing, add characters to the output string (out_ptr++) = haystack_val; } // continue iterating through the haystack ++haystack_iter; } out_ptr = '\0'; // null term return out_str; } --v Also added comments, but I don't think they'll help much.
Fri, 24 Sep 2010, 15:31
Afr0	*out_ptr = '\0'; // null term --v Wait... I'm confused. How come dereferencing the pointer in this manner doesn't simply replace the content stored with '\0'? -=-=- Afr0 Games Project Dollhouse on Github - Please fork!
Fri, 24 Sep 2010, 15:39
Cower	I'm not sure what you're asking. It does put a null character in, so I'm not entirely sure why you think it doesn't, or what it is you think it does...
Fri, 24 Sep 2010, 16:10
Afr0	Initially it looked to me like it would replace the entire string with '\0', but I suppose it only puts '\0' at the specific address in memory that you increased in the function... -=-=- Afr0 Games Project Dollhouse on Github - Please fork!
Fri, 24 Sep 2010, 17:27
JL235	Afr0 but I suppose it only puts '\0' at the specific address in memory that you increased in the function... Yes, I'm pretty sure it's doing this. The pointer refers to the beginning of the string and he's replacing it with '\0', so now the string is terminated right at the start (and so is empty).
Fri, 24 Sep 2010, 17:43
Cower	so now the string is terminated right at the start (and so is empty). Wrong. Try again.
Sat, 25 Sep 2010, 07:35
HoboBen	Terminated at the end, I think. Also, thanks v. much for commenting it, Cower - I understand it much better now. -=-=- blog \| work \| code \| more code
Sun, 26 Sep 2010, 20:47
Afr0	Terminated at the end, I think. Yeah, that's pretty much what I said. And obviously that's what's happening, I was just a little confused as to how it was happening. -=-=- Afr0 Games Project Dollhouse on Github - Please fork!