Closed. This question is off-topic. It is not currently accepting answers.
Learn more。
想改进这个问题吗？
Update the question所以堆栈溢出的值小于aa>。
两年前关闭。
我想写一个良好的功能与utf8支持更好的性能。
我做了深入的研究，发现了以下候选人：
char* replace(char* orig, char* rep, char* with)
{
//33-34
char* result; // the return string
char* ins; // the next insert point
char* tmp; // varies
size_t len_rep; // length of rep
size_t len_with; // length of with
size_t len_front; // distance between rep and end of last rep
int count; // number of replacements
/* char* strstr(char const* s1, char const* s2);
retourne un pointeur vers la première occurrence de s2 dans s1
(ou NULL si s2 n’est pas incluse dans s1). */
if (!orig)
return NULL;
if (!rep || !(len_rep = strlen(rep)))
return NULL;
if (!(ins = strstr(orig, rep)))
return NULL;
if (!with)
with = "";
len_with = strlen(with);
/* { initialisation;
while (condition) {
Instructions
mise_à_jour;
} }*/
// compte le nombre d'occurences de la chaîne à remplacer
for (count = 0; (tmp = strstr(ins, rep)); ++count) {
ins = tmp + len_rep;
}
// allocation de mémoire pour la nouvelle chaîne
tmp = result = malloc(strlen(orig) + (len_with - len_rep) * count + 1);
if (!result)
return NULL;
/* char* strcpy(char* dest, char const* src);
copie la chaîne src dans la chaîne dest. Retourne dest.
Attention ! aucune vérification de taille n’est effectuée ! */
/* char* strncpy(char* dest, char const* src, size_t n);
copie les n premiers caractères de src dans dest. Retourne dest.
Attention ! n’ajoute pas le '\0' à la fin si src contient plus de n
caractères !*/
// from here on,
// tmp points to the end of the result string
// ins points to the next occurrence of rep in orig
// orig points to the remainder of orig after "end of rep"
while (count--) { // count évaluée, puis incrémentée
// donc ici tant que count est > 0
ins = strstr(orig, rep);
len_front = ins - orig;
tmp = strncpy(tmp, orig, len_front) + len_front;
tmp = strcpy(tmp, with) + len_with;
orig += len_front + len_rep; // move to next "end of rep"
}
strcpy(tmp, orig);
return result;
}
char* replace8(char *str, char *old,char *new)
{
//1.2 :||||||||||
int i, count = 0;
int newlen = strlen(new);
int oldlen = strlen(old);
for (i = 0; str[i]; ++i)
if (strstr(&str[i], old) == &str[i])
++count, i += oldlen - 1;
char *ret = (char *) calloc(i + 1 + count * (newlen - oldlen), sizeof(char));
if (!ret) return "";
i = 0;
while (*str)
if (strstr(str, old) == str)
strcpy(&ret[i], new),
i += newlen,
str += oldlen;
else
ret[i++] = *str++;
ret[i] = '\0';
return ret;
}
char *replace7(char *orig, char *rep, char *with)
{
//33-34-35
char *result; // the return string
char *ins; // the next insert point
char *tmp; // varies
int len_rep; // length of rep
int len_with; // length of with
int len_front; // distance between rep and end of last rep
int count; // number of replacements
if (!orig)
{
return NULL;
}
if (!rep)
{
rep = "";
}
len_rep = strlen(rep);
if (!with)
{
with = "";
}
len_with = strlen(with);
ins = orig;
for (count = 0; tmp = strstr(ins, rep); ++count)
{
ins = tmp + len_rep;
}
// first time through the loop, all the variable are set correctly
// from here on,
// tmp points to the end of the result string
// ins points to the next occurrence of rep in orig
// orig points to the remainder of orig after "end of rep"
tmp = result = malloc(strlen(orig) + (len_with - len_rep) * count + 1);
if (!result)
{
return NULL;
}
while (count--)
{
ins = strstr(orig, rep);
len_front = ins - orig;
tmp = strncpy(tmp, orig, len_front) + len_front;
tmp = strcpy(tmp, with) + len_with;
orig += len_front + len_rep; // move to next "end of rep"
}
strcpy(tmp, orig);
return result;
}
char *replace6(char *st, char *orig, char *repl)
{
//17-18
static char buffer[4000];
char *ch;
if (!(ch = strstr(st, orig)))
return st;
strncpy(buffer, st, ch-st);
buffer[ch-st] = 0;
sprintf(buffer+(ch-st), "%s%s", repl, ch+strlen(orig));
return buffer;
}
char* replace3(char* s, char* term, char* new_term)
{
//error
char *nw = NULL, *pos;
char *cur = s;
while(pos = strstr(cur, term))
{
nw = (char*)realloc(nw, pos - cur + strlen(new_term));
strncat(nw, cur, pos-cur);
strcat(nw, new_term);
cur = pos + strlen(term);
}
strcat(nw, cur);
free(s);
return nw;
}
char *replace2(char *original,char *pattern,char *replacement)
{
//34-37
size_t replen = strlen(replacement);
size_t patlen = strlen(pattern);
size_t orilen = strlen(original);
size_t patcnt = 0;
char * oriptr;
char * patloc;
// find how many times the pattern occurs in the original string
for (oriptr = original; patloc = strstr(oriptr, pattern); oriptr = patloc + patlen)
{
patcnt++;
}
{
// allocate memory for the new string
size_t retlen = orilen + patcnt * (replen - patlen);
char * const returned = (char *) malloc( sizeof(char) * (retlen + 1) );
if (returned != NULL)
{
// copy the original string,
// replacing all the instances of the pattern
char * retptr = returned;
for (oriptr = original; patloc = strstr(oriptr, pattern); oriptr = patloc + patlen)
{
size_t skplen = patloc - oriptr;
// copy the section until the occurence of the pattern
strncpy(retptr, oriptr, skplen);
retptr += skplen;
// copy the replacement
strncpy(retptr, replacement, replen);
retptr += replen;
}
// copy the rest of the string.
strcpy(retptr, oriptr);
}
return returned;
}
}
char *replace4(char *string, char *oldpiece, char *newpiece)
{
//20-21
int str_index, newstr_index, oldpiece_index, end,
new_len, old_len, cpy_len;
char *c;
static char newstring[10000];
if ((c = (char *) strstr(string, oldpiece)) == NULL)
return string;
new_len = strlen(newpiece);
old_len = strlen(oldpiece);
//str = strlen(string);
end = strlen(string) - old_len;
//int count;
//for (count = 0; (strstr(oldpiece, newpiece)); ++count){}
//newstring = malloc(str + (old_len - new_len) * count + 1);
oldpiece_index = c - string;
newstr_index = 0;
str_index = 0;
while(str_index <= end && c != NULL)
{
/* Copy characters from the left of matched pattern occurence */
cpy_len = oldpiece_index-str_index;
strncpy(newstring+newstr_index, string+str_index, cpy_len);
newstr_index += cpy_len;
str_index += cpy_len;
/* Copy replacement characters instead of matched pattern */
///*newstring=realloc(newstring,sizeof(newstring)+new_len+old_len+end+newstr_index);
strcpy(newstring+newstr_index, newpiece);
newstr_index += new_len;
str_index += old_len;
/* Check for another pattern match */
if((c = (char *) strstr(string+str_index, oldpiece)) != NULL)
oldpiece_index = c - string;
}
/* Copy remaining characters from the right of last matched pattern */
strcpy(newstring+newstr_index,
string+str_index);
return newstring;
}
char *replace5(char *orig, char *rep, char *with)
{
//32-33-35
char *result;
char *ins;
char *tmp;
int len_rep;
int len_with;
int len_front;
int count;
if (!orig)
return NULL;
if (!rep)
rep = "";
len_rep = strlen(rep);
if (!with)
with = "";
len_with = strlen(with);
ins = orig;
for (count = 0; (tmp = strstr(ins, rep)); ++count) {
ins = tmp + len_rep;
}
tmp = result = malloc(strlen(orig) + (len_with - len_rep) * count + 1);
if (!result)
return NULL;
while (count--) {
ins = strstr(orig, rep);
len_front = ins - orig;
tmp = strncpy(tmp, orig, len_front) + len_front;
tmp = strcpy(tmp, with) + len_with;
orig += len_front + len_rep;
}
strcpy(tmp, orig);
return result;
}
Replace()和
replace4()是来自其他的，但不是malloc，realloc。
Replace（）性能测试
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <inttypes.h>
#include <assert.h>
#include <stdint.h>
#include <sys/stat.h>
#include <stdarg.h>
char *temp;
int main()
{
for(int current=1;current<=80000;current++)
{
temp=/*replace6*//*replace3*/replace4("1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890","0","black");
//printf("%s",temp);
}
return 0;
}
如何才能使
replace6()功能更好？
我可以将malloc、realloc添加到
replace()或
replace4()吗？