int replace(char* str, char* old, char* New) { char *i,*j,*m,*r,*w; int k,l; int g,h; int len_str,len_old,len_New; len_str=0;len_old=0;len_New=0; i=str; if(!str||!old||!New) { return -1; } while(*i != '\0') { len_str++; i++; } j=old; while(*j !='\0') { len_old++; j++; } w=New; while(*w !='\0') { len_New++; w++; } if(len_New!=len_old) { return -1; } if(len_str>0 && len_old==0) { return -1; } if(len_str<len_old) { return -1; } i = str; j = old; w = New; for(k=1;k<=len_str;k++) { m=i; for(l=1;l<=len_old;l++) { if(*m == *j) { ++m; ++j; } else { break; } } if(*j=='\0') { break; } ++i; j=old; } if(*j=='\0') { i=str; r=str; for(h=1;h<k;h++) { i++; r++; } for(g=k;g<=k+len_old-1;g++) { while(*w!='\0') { *i=*w; i++; r++; w++; } } return k; } return -1; }
时间: 2024-02-14 19:35:10 浏览: 25
这段代码实现了一个字符串替换函数 replace(),它的作用是将字符串 str 中的 old 子串替换为 New 子串。如果替换成功,则返回 old 子串在 str 中第一次出现的位置;如果替换失败,则返回 -1。
具体实现过程是,首先计算出 str、old 和 New 的长度 len_str、len_old 和 len_New。如果 len_old 不等于 len_New,则说明 old 和 New 的长度不相等,无法替换,函数返回 -1。如果 len_old 为 0 且 len_str 大于 0,则说明 old 为空串,无法替换,函数返回 -1。如果 len_str 小于 len_old,则说明 old 不可能出现在 str 中,无法替换,函数返回 -1。
接下来,从 str 中查找 old 子串。具体做法是,从 str 的第一个字符开始逐个比较,如果当前字符和 old 的第一个字符相等,则从当前位置开始依次比较 str 和 old 的每一个字符,直到不相等或 old 结束。如果 old 结束,则说明找到了第一次出现的位置,记录下来,退出循环。如果 str 结束,则说明没有找到 old,函数返回 -1。
如果找到了 old,则在 str 中替换为 New。具体做法是,从第一次出现的位置开始,依次将 New 中的字符复制到 str 中,直到 New 结束。最后返回第一次出现的位置。
相关问题
编写一个函数: char *ReplaceString(char * str, char * s1, char * s2); 该函数用s2替换str中的s1,函数返回替换后的字符串的指针。
好的,以下是我为您编写的函数:
```c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char *ReplaceString(char * str, char * s1, char * s2) {
int old_len = strlen(s1);
int new_len = strlen(s2);
int count = 0;
char *p, *q, *r;
p = str;
while ((q = strstr(p, s1)) != NULL) {
count++;
p = q + old_len;
}
int len = strlen(str) + (new_len - old_len) * count + 1;
r = (char *) malloc(len * sizeof(char));
p = str;
q = r;
while ((p = strstr(p, s1)) != NULL) {
strncpy(q, str, p - str);
q += p - str;
strncpy(q, s2, new_len);
q += new_len;
p += old_len;
str = p;
}
strcpy(q, str);
return r;
}
int main() {
char *str = "Hello world, this is a test string.";
char *s1 = "test";
char *s2 = "replacement";
char *result = ReplaceString(str, s1, s2);
printf("%s\n", result);
free(result);
return 0;
}
```
这个函数的实现方法是先遍历一遍字符串,计算出需要替换的次数,然后根据替换前后的字符串长度差,计算出最终字符串的长度,再分别从原字符串和目标字符串中逐个字符地拷贝到新字符串中,最后返回新字符串的指针。
定义一个字符串类 String,增加下列成员函数: bool IsSubstring(const char *str):判断 str 是否为当前串的子串; bool IsSubstring(const String &str):判断 str 是否为当前串的子串; int str2num():把数字串转换成数; void toUppercase():把字符串转换成大写字母
&str):重载 IsSubstring 函数,判断 str 是否为当前串的子串; void Append(const char *str):将 str 串附加到当前串的末尾; void Append(const String &str):重载 Append 函数,将 str 串附加到当前串的末尾; void Replace(const char *oldstr, const char *newstr):用 newstr 串替换当前串中的 oldstr 串; void Replace(const String &oldstr, const String &newstr):重载 Replace 函数,用 newstr 串替换当前串中的 oldstr 串; void Delete(int start, int len):删除从 start 位置开始的 len 个字符; int Length():返回当前串的长度。
下面是 String 类的示例实现:
```c++
#include <cstring>
class String {
char *data;
int len;
public:
String() {
data = new char[1];
data[0] = '\0';
len = 0;
}
String(const char *str) {
len = strlen(str);
data = new char[len + 1];
strcpy(data, str);
}
String(const String &str) {
len = str.len;
data = new char[len + 1];
strcpy(data, str.data);
}
~String() {
delete [] data;
}
bool IsSubstring(const char *str) {
return strstr(data, str) != nullptr;
}
bool IsSubstring(const String &str) {
return strstr(data, str.data) != nullptr;
}
void Append(const char *str) {
int new_len = len + strlen(str);
char *new_data = new char[new_len + 1];
strcpy(new_data, data);
strcat(new_data, str);
delete [] data;
data = new_data;
len = new_len;
}
void Append(const String &str) {
Append(str.data);
}
void Replace(const char *oldstr, const char *newstr) {
char *pos = strstr(data, oldstr);
if (pos != nullptr) {
int old_len = strlen(oldstr);
int new_len = strlen(newstr);
int shift = new_len - old_len;
int tail_len = len - (pos - data) - old_len;
char *new_data = new char[len + shift + 1];
strncpy(new_data, data, pos - data);
new_data[pos - data] = '\0';
strcat(new_data, newstr);
strcat(new_data, pos + old_len);
delete [] data;
data = new_data;
len += shift;
}
}
void Replace(const String &oldstr, const String &newstr) {
Replace(oldstr.data, newstr.data);
}
void Delete(int start, int len) {
if (start >= 0 && start < this->len) {
if (len < 0) {
len = this->len - start;
}
if (start + len > this->len) {
len = this->len - start;
}
memmove(data + start, data + start + len, this->len - start - len + 1);
this->len -= len;
}
}
int Length() {
return len;
}
};
```