头文件

"mystring.h"

#ifndef _MYSTR_H
#define _MYSTR_H
#include <stdio.h>
#include <stdlib.h> /*复制*/
char *mystrcpy(char *, const char *); // [destin, source ]
/*复制前n个*/
char *mystrncpy(char *, const int, const char *); // [distin, num, source ]
/*求字符串串长度*/
int mystrlen(const char *); // [str ]
/*字符在字符串中第一次出现的index*/
int myindexof(const char *, const char *); // [str, chr ]
/*字符串在字符串中第一次出现的index*/
int myindexofstr(const char *, const char *); // [str, substr ]
/*拼接两个字符串*/
char *mystrcat(char *, const char *); // [distin, source ]
/*将后字符串的前n个拼接到前字符串末尾*/
char *mystrncat(char *, const int, const char *); // [distin, n, source ]
/*字符在字符串中最后一次出现的index*/
int mylastindexof(const char *, const char *); // [str, chr ]
/*反转字符串*/
char *mystrrev(char *); // [str ]
/*字符串在字符串中最后一次出现的index*/
int mylastindexofstr(const char *, const char *); // [str, substr ]
/*获得字符串从index开始到末尾的子串*/
char *mysubstring(char *, const int, const char *); // [tosubstr, begin_index, str ]
/*获得字符串从f_index开始到t_index的子串*/
char *myftsubstring(char *, const int, const int, const char *); // [tosubstr, begin_index, end_index, str]
/*去除字符串头和串尾的空格(可处理多个)*/
char *mytrimstr(char *); // [str ]
/*字符串比较(对应的字符ASCII值的比较)*/
int mystrcmp(const char *, const char *); // [str1, str2 ]
/*字符串的所有大写字符变小写*/
char *mytolowerstr(char *); // [str ]
/*字符串的所有小写字符变大写*/
char *mytoupperstr(char *); // [str ]
/*从字符串中获得指定index的字符*/
char mygetchrfromstr(const int, const char *); // [index, str ]
/*以指定字符切割字符串*/
int mystrsplit(char **, char *, const char); // [distin, source, char lmt_chr ]
/*将字符串中全部字符设置为指定字符*/
char *mystrset(char *, const char); // [str, set_chr ]
/*将字符串中前n个字符设置为指定字符*/
char *mystrnset(char *, const int, const char); // [str, num, set_chr ]
/*忽略大小写进行字符串比较*/
int mychricmp(const char, const char); // [chr1, chr2 ]
/*忽略大小写进行字符串前n个字符的比较*/
int mystrncmpi(const char *, const int, const char *); // [str1, num, str2 ]
/*修改字符串中全部指定的字符为新的字符*/
char *mystrmodchr(char *, const char, const char); // [str, old_chr, new_chr ]
/*修改字符串中全部指定的子字符串为新的字符串*/
char *mystrmodstr(char *, const char *, const char *); // [str, old_str, new_str ]
/*复制字符串到安全的位置并返回指向它内存的指针*/
char *mystrdup(const char *); // [source ]
/*在字符串的指定index处插入字符*/
char *mystrinsertchr(char *, const int, const char); // [str, index, chr ]
/*在字符串的指定index处插入字符串*/
char *mystrinsertstr(char *, const int, const char *); // [str, index, insert_str ]
/*数字字符串转int类型整数*/
int mystrtoint(const char *); // [int_str ]
/*数字字符串转double类型浮点数*/
double mystrtodbl(const char *); // [dbl_str ] ///////////////////////////// void test_mystrcpy();
void test_mystrncpy();
void test_mystrlen();
void test_myindexof();
void test_myindexofstr();
void test_mystrcat();
void test_mystrncat();
void test_mylastindexof();
void test_mystrrev();
void test_mylastindexofstr();
void test_mysubstring();
void test_myftsubstring();
void test_mytrimstr();
void test_mystrcmp();
void test_mytolowerstr();
void test_mytoupperstr();
void test_mygetchrfromstr();
void test_mystrsplit();
void test_mystrset();
void test_mystrnset();
void test_mychricmp();
void test_mystrncmpi();
void test_mystrmodchr();
void test_mystrmodstr();
void test_mystrdup();
void test_mystrinsertchr();
void test_mystrinsertstr();
void test_mystrtoint();
void test_mystrtodbl();
#endif /* _MYSTR_H */

具体功能实现代码

复制

//返回值:成功正  失败NULL
char *mystrcpy(char *destin, const char *source){
if (!destin || !source){
return NULL;
}
char *pd = destin;
const char *ps = source;
while ((*pd++ = *ps++))
;
return destin; }

复制前n个

//返回值:成功正  失败NULL
char *mystrncpy(char *destin, const int num, const char *source){
if (!destin || !source){
return NULL;
}
char *pd = destin;
const char *ps = source;
int i = ;
while ((i++ < num) && (*pd++ = *ps++))
;
if (--i == num){
return destin;
}
else{
for(++i; i > -; *pd-- = '\0', --i)
;
return NULL;
}
}

求字符串串长度

int mystrlen(const char *str){
if (!str){
return -;
}
const char *pstr = str;
while(*pstr++)
;
return (--pstr - str);
}

字符在字符串中第一次出现的index

int myindexof(const char *str, const char *chr){
if (!str || !chr ){
return -;
}
const char *pstr = str;
const char *pchr = chr;
char tmpc = '\0';
while((tmpc = *pstr++) != *pchr && tmpc)
;
if (!tmpc){
return -;
}
else{
return (--pstr - str);
}
}

字符串在字符串中第一次出现的index

int myindexofstr(const char *str, const char *substr){
if (!str || !substr){
return -;
}
const char *pstr = str;
const char *psubstr = substr;
int index = ;
while (*pstr){
if (*psubstr == *pstr){
++pstr;
if (*(++psubstr) == '\0'){
return index;
}
}
else{
pstr = pstr - (psubstr - substr) + ;
index = (pstr - str);
psubstr = substr;
}
}
return -;
}

拼接两个字符串

char *mystrcat(char *destin, const char *source){
if (!destin || !source){
return NULL;
}
char *pd = destin;
const char *ps = source; while(*pd++);
for(--pd; (*pd++ = *ps++);)
;
return destin;
}

将后字符串的前n个拼接到前字符串末尾

char *mystrncat(char *destin, const int n, const char *source){
if(!destin || !source || n > mystrlen(source) || n < ){
return NULL;
}
char *pd = destin;
const char *ps = source;
pd += mystrlen(destin);
for(int i = ; i < n; ++i){
*pd++ = *ps++;
}
*pd = '\0';
return destin;
}

字符在字符串中最后一次出现的index

int mylastindexof(const char *str, const char *chr){
if(!str || !chr){
return -;
}
const char *pstr = str;
const char *pchr = chr;
pstr += mystrlen(str);
while(*(--pstr) != *pchr)
;
return (pstr - str);
}

反转字符串

char *mystrrev(char *str){
if(!str){
return NULL;
}
int length = mystrlen(str);
char *pstr = str;
char *pend = str + (length - );
for(int i = ; i < (length / ); ++i){
static char tmp;
tmp = *pstr;
*pstr++ = *pend;
*pend-- = tmp;
}
return str;
}

字符串在字符串中最后一次出现的index

int mylastindexofstr(const char *str, const char *substr){
if(!str || !substr){
return -;
}
const char *pstr = str;
const char *psubstr = substr;
int strlength = mystrlen(str);
int sublength = mystrlen(substr);
pstr += (strlength - );
psubstr += (sublength - );
int j_sub = ;
int endindex = strlength - ;
for(int i = ; i < strlength; ++i){
if(*pstr == *psubstr){
--pstr;
--psubstr;
if(++j_sub == sublength){
return (endindex - sublength + );
}
}else{
pstr += (j_sub - );
psubstr = substr + sublength- ;
endindex = (pstr - str);
}
}
return -;
}

获得字符串从index开始到末尾的子串

char *mysubstring(char *tosubstr, const int begin_index, const char *str){
if(!tosubstr || !str || begin_index > \
mystrlen(str) || begin_index < ){
return NULL;
}
char *ptosub = tosubstr;
const char *pstr = str;
pstr += begin_index;
while((*ptosub++ = *pstr++))
;
return tosubstr;
}

获得字符串从f_index开始到t_index的子串

char *myftsubstring(char *tosubstr, const int begin_index,    //左闭右开
const int end_index, const char *str){
if(!tosubstr || !str || begin_index >= end_index \
|| begin_index < || end_index > mystrlen(str)){
return NULL;
}
char *ptosub = tosubstr;
const char *pstr = str;
for((pstr += begin_index); pstr < (str + end_index); (*ptosub++ = *pstr++))
;
*ptosub = '\0';
return tosubstr;
}

去除字符串头和串尾的空格(可处理多个)

char *mytrimstr(char *str){   //去除前后空格
if(!str){
return NULL;
}
char *pstr = str;
char *p1 = str;
char *p2 = str + (mystrlen(str) - );
while(*p1++ == ' ')
;
while(*p2-- == ' ')
;
for((--p1, ++p2);p1 <= p2; (*pstr++ = *p1++))
;
*pstr = '\0';
return str;
}

字符串比较(对应的字符ASCII值的比较)

int mystrcmp(const char *str1, const char *str2){
if(!str1 || !str2){
return -;//-2表示没法比较
}
const char *pstr1 = str1;
const char *pstr2 = str2;
int flag = ;
while((*pstr1) && (*pstr2)){
if(*pstr1 < *pstr2){
flag = -;
break;
}else if(*pstr1 > *pstr2){
flag = ;
break;
}
++pstr1;
++pstr2;
}
if(!(*pstr1) && !(*pstr2)){
flag = ;
}else if(!(*pstr1)){
flag = -;
}else if(!(*pstr2)){
flag = ;
}
return flag;
}

字符串的所有大写字符变小写

char *mytolowerstr(char *str){
if(!str){
return NULL;
}
char *pstr = str;
while(*pstr){
if((*pstr >= 'A') && (*pstr <= 'Z')){
*pstr += ('a' - 'A');
}
++pstr;
}
return str;
}

字符串的所有小写字符变大写

char *mytoupperstr(char *str){
if(!str){
return NULL;
}
char *pstr = str;
while(*pstr){
if((*pstr >= 'a') && (*pstr <= 'z')){
*pstr -= ('a' - 'A');
}
++pstr;
}
return str;
}

从字符串中获得指定index的字符

char mygetchrfromstr(const int index, const char *str){
if(!str || index < || index >= mystrlen(str)){
return '\0';
}
return *(str + index);
}

以指定字符切割字符串

//将字符串按指定字符切割返回指向各个片段首字符的指针  返回子串个数/失败-1
int mystrsplit(char **destin, char *source, const char lmt_chr){
if(!destin || !source || !lmt_chr){
return -;
}
char **pd = destin;
char *ps = source;
int flag = ;
int sub_num = ;
while(*ps){
if(*ps != lmt_chr){
if(!flag){
*pd++ = ps;
++sub_num;
}
flag = ;
}else{
*ps = '\0';
flag = ;
}
++ps;
}
return sub_num;
}

将字符串中全部字符设置为指定字符

char *mystrset(char *str, const char set_chr){
if(!str || !set_chr){
return NULL;
}
char *pstr = str;
for(; *pstr; (*pstr++ = set_chr))
;
return str;
}

将字符串中前n个字符设置为指定字符

char *mystrnset(char *str, const int num, const char set_chr){
if(!str || !set_chr || num < || num > mystrlen(str)){
return NULL;
}
char *pstr = str;
for(int i = ; i < num; (*pstr++ = set_chr), ++i)
;
return str;
}

忽略大小写进行字符串比较

int mychricmp(const char chr1, const char chr2){
if(!chr1 || !chr2){
return -;
}
int diff = chr1 - chr2;
if(diff == || (diff == ('a' - 'A')) || (diff == ('A' - 'a'))){
return ;
}else if(diff < ){
return -;
}else{
return ;
}
}

忽略大小写进行字符串前n个字符的比较

int mystrncmpi(const char *str1, const int num, const char *str2){
if(!str1 || !str2 || num <= ||\
num > mystrlen(str1) || num > mystrlen(str2)){
return -;
}
const char *pstr1 = str1;
const char *pstr2 = str2;
for(int i = ; i < num; ++i){
int flag = mychricmp(*pstr1++, *pstr2++);
if(flag == -){
return -;
}else if(flag == ){
return ;
}else if(flag == -){
return -; //失败
}
}
return ; }

修改字符串中全部指定的字符为新的字符

char *mystrmodchr(char *str, const char old_chr, const char new_chr){
if(!str || !old_chr){ //支持换成'\0'
return NULL;
}
char *pstr = str;
while(*pstr){
if(*pstr == old_chr){
*pstr = new_chr;
}
++pstr;
}
return str;
}

修改字符串中全部指定的子字符串为新的字符串

char *mystrmodstr(char *str, const char *old_str,const char *new_str){
if(!str || !old_str || !new_str){
return NULL;
}
char *pstr = str;
int index = ;
while((index = myindexofstr(pstr, old_str)) != -){
const char *pnew_str = new_str;
for(pstr += index; *pnew_str; *pstr++ = *pnew_str++)
;
}
return str;
}

复制字符串到安全的位置并返回指向它内存的指针

char *mystrdup(const char *source){  //在堆中申请的内存  用时注意 free
if(!source){
return NULL;
}
int str_length = mystrlen(source);
char *destin = NULL;
if(!(destin = (char *)calloc((str_length + ), sizeof(char)))){
return NULL;
}
if(!(mystrcpy(destin, source))){
return NULL;
}
return destin;
}

在字符串的指定index处插入字符

char *mystrinsertchr(char *str, const int index, const char chr){
int str_length = mystrlen(str);
if(!str || index < || index > str_length){ //支持插入'\0' 允许插在串尾
return NULL;
}
char *pstr = str, *lastp;
pstr += str_length;
lastp = pstr + ;
for(int i = ; i <= (str_length - index); (*lastp-- = *pstr--), ++i)
;
*(++pstr) = chr;
return str;
}

在字符串的指定index处插入字符串

char *mystrinsertstr(char *str, const int index, const char *insert_str){
int str_length = mystrlen(str);
if(!str || !insert_str || index < || index > str_length){ //允许插在串尾
return NULL;
}
int insert_str_length = mystrlen(insert_str);
char *pstr = str, *lastp;
const char *pinsert_str = insert_str;
pstr += str_length;
lastp = pstr + insert_str_length;
for(int i = ; i <= (str_length - index); (*lastp-- = *pstr--), ++i)
;
for(int i = ; i < insert_str_length; (*(++pstr) = *pinsert_str++), ++i)
;
return str;
}

数字字符串转int类型整数

int mystrtoint(const char *int_str){
if(!int_str){
fprintf(stderr, "error: input str pointer is null\n");
return ;
}
const char *pint_str = int_str;
for(; *pint_str == ' ' || *pint_str == '\t' ||\
*pint_str == '\r' || *pint_str == '\n'; ++pint_str) //跳过前面的空格、制表符、换行符
;
int sign = ;
if(*pint_str == '-' || *pint_str == '+'){
*pint_str == '-' ? (sign = -) : (sign = );
++pint_str;
}
int the_intnum = ;
//没做英文字符的处理 那显然不是纯数字的字符串
for(; *pint_str; (the_intnum = (*pint_str - '') + * the_intnum), ++pint_str)
;
return (sign * the_intnum);
}

数字字符串转double类型浮点数

double mystrtodbl(const char *dbl_str){
if(!dbl_str){
fprintf(stderr, "error: input str pointer is null\n");
return ;
}
const char *pdbl_str = dbl_str;
for(; *pdbl_str == ' ' || *pdbl_str == '\t' ||\
*pdbl_str == '\r' || *pdbl_str == '\n'; ++pdbl_str) //跳过前面的空格、制表符、换行符
;
double sign = 1.0;
if(*pdbl_str == '-' || *pdbl_str == '+'){
*pdbl_str == '-' ? (sign = -1.0) : (sign = 1.0);
++pdbl_str;
}
double num_bef_point = 0.0;
double num_aft_point = 0.0;
double num_double = 0.0;
for(; *pdbl_str != '.' && *pdbl_str; ++pdbl_str){
num_bef_point = (*pdbl_str - '') + 10.0 * num_bef_point;
}
if(!(*pdbl_str)){;
num_double = sign * num_bef_point;
}else{
double point_flag = 0.1;
for(++pdbl_str; *pdbl_str; ++pdbl_str){
num_aft_point += (*pdbl_str - '') * point_flag;
point_flag *= 0.1;
}
num_double = sign * (num_bef_point + num_aft_point);
}
return num_double;
}

测试功能代码(使用样例)

复制

void test_mystrcpy(){
printf("\n>>>char *mystrcpy(char *, const char *)\n");
char str[] = {};
printf("str:[ %s ]\n", str);
printf("soc:[ %s ]\n", "hello world");
mystrcpy(str, "hello world");
printf("str_op:[ %s ]\n", str);
}

复制前n个

void test_mystrncpy(){
printf("\n>>>char *mystrncpy(char *, const int, const char *)\n");
char str[] = {};
printf("str:[ %s ]\n", str);
printf("soc:[ %s ]\n", "hello world");
printf("num:[ %d ]\n", );
mystrncpy(str,, "hello world");
printf("str_op:[ %s ]\n", str);
}

求字符串串长度

void test_mystrlen(){
printf("\n>>>int mystrlen(const char *)\n");
char *p = "hello";
printf("str:[ %s ]\n", p);
printf("str_op:[ %d ]\n", mystrlen(p));
}

字符在字符串中第一次出现的index

void test_myindexof(){
printf("\n>>>int myindexof(const char *, const char *)\n");
char *p = "aBcaBc";
char c = 'B';
printf("str:[ %s ]\n", p);
printf("chr:[ %c ]\n", c);
printf("str_op:[ %d ]\n", myindexof(p, &c));
}

字符串在字符串中第一次出现的index

void test_myindexofstr(){
printf("\n>>>int myindexofstr(const char *, const char *)\n");
char *p1 = "abCDefghCDij";
char *p2 = "CD";
printf("str:[ %s ]\n", p1);
printf("str:[ %s ]\n", p2);
printf("str_op:[ %d ]\n", myindexofstr(p1, p2));
}

拼接两个字符串

void test_mystrcat(){
printf("\n>>>char *mystrcat(char *, const char *)\n");
char str[] = {'h', 'e', 'l', 'l', 'o', ' '};
char *p = "world";
printf("str1:[ %s ]\n", str);
printf("str2:[ %s ]\n", p);
mystrcat(str, p);
printf("str_op:[ %s ]\n", str);
}

将后字符串的前n个拼接到前字符串末尾

void test_mystrncat(){
printf("\n>>>char *mystrncat(char *, const int, const char *)\n");
char str[] = {'h', 'e', 'l', 'l', 'o', ' '};
char *p = "world";
printf("str1:[ %s ]\n", str);
printf("str2:[ %s ]\n", p);
printf("num:[ %d ]\n", );
mystrncat(str, , p);
printf("str_op:[ %s ]\n", str);
}

字符在字符串中最后一次出现的index

void test_mylastindexof(){
printf("\n>>>int mylastindexof(const char *, const char *)\n");
char *p = "aBcaBc";
char c = 'B';
printf("str:[ %s ]\n", p);
printf("chr:[ %c ]\n", c);
printf("str_op:[ %d ]\n", mylastindexof(p, &c));
}

反转字符串

void test_mystrrev(){
printf("\n>>>char *mystrrev(char *)\n");
char str[] = {'h', 'e', 'l', 'l', 'o', ' '};
printf("str:[ %s ]\n", str);
mystrrev(str);
printf("str_op:[ %s ]\n", str);
}

字符串在字符串中最后一次出现的index

void test_mylastindexofstr(){
printf("\n>>>int mylastindexofstr(const char *, const char *)\n");
char *p1 = "abCDefghCDij";
char *p2 = "CD";
printf("str1:[ %s ]\n", p1);
printf("str2:[ %s ]\n", p2);
printf("str_op:[ %d ]\n", mylastindexofstr(p1, p2));
}

获得字符串从index开始到末尾的子串

void test_mysubstring(){
printf("\n>>>char *mysubstring(char *, const int, const char *)\n");
char str[] = {};
char *p = "hello";
printf("str1:[ %s ]\n", str);
printf("str2:[ %s ]\n", p);
printf("index:[ %d ]\n", );
mysubstring(str, , p);
printf("str_op:[ %s ]\n", str);
}

获得字符串从f_index开始到t_index的子串

void test_myftsubstring(){
printf("\n>>>char *myftsubstring(char *, const int, const int, const char *)\n");
char str[] = {};
char *p = "hello world";
printf("str1:[ %s ]\n", str);
printf("str2:[ %s ]\n", p);
printf("from:[ %d ]\n", );
printf("to:[ %d ]\n", );
myftsubstring(str, , , p);
printf("str_op:[ %s ]\n", str);
}

去除字符串头和串尾的空格(可处理多个)

void test_mytrimstr(){
printf("\n>>>char *mytrimstr(char *)\n");
char str[] = {' ', ' ', 'h', 'e', 'l', 'l', 'o', ' ', ' '};
printf("str:[ %s ]\n", str);
mytrimstr(str);
printf("str_op:[ %s ]\n", str);
}

字符串比较(对应的字符ASCII值的比较)

void test_mystrcmp(){
printf("\n>>>int mystrcmp(const char *, const char *)\n");
char *p1 = "abcd";
char *p2 = "aBdc";
printf("str1:[ %s ]\n", p1);
printf("str2:[ %s ]\n", p2);
printf("str_op:[ %d ]\n", mystrcmp(p1, p2));
}

字符串的所有大写字符变小写

void test_mytolowerstr(){
printf("\n>>>char *mytolowerstr(char *)\n");
char str[] = {'a', 'b', 'C', 'D', 'e'};
printf("str:[ %s ]\n", str);
mytolowerstr(str);
printf("str_op:[ %s ]\n", str);
}

字符串的所有小写字符变大写

void test_mytoupperstr(){
printf("\n>>>char *mytoupperstr(char *)\n");
char str[] = {'a', 'b', 'C', 'D', 'e'};
printf("str:[ %s ]\n", str);
mytoupperstr(str);
printf("str_op:[ %s ]\n", str);
}

从字符串中获得指定index的字符

void test_mygetchrfromstr(){
printf("\n>>>char mygetchrfromstr(const int, const char *)\n");
char *p = "hello";
printf("str:[ %s ]\n", p);
printf("index:[ %d ]\n", );
printf("str_op:[ %c ]\n", mygetchrfromstr(, p));
}

以指定字符切割字符串

void test_mystrsplit(){
printf("\n>>>int mystrsplit(char **, char *, const char)\n");
char *p[] = {};
char **p1 = p;
char str[] = {};
mystrcpy(str, " ab cd ef GH ");
printf("str:[ %s ]\n", str);
int num = mystrsplit(p, str, ' '); //ÒÔ¿Õ¸ñÇиî
for(int i = ; i < num; ++i){
printf("str_op:[ %s ]\n", *p1++);
}
}

将字符串中全部字符设置为指定字符

void test_mystrset(){
printf("\n>>>char *mystrset(char *, const char)\n");
char str[] = {'h', 'e', 'l', 'l', 'o'};
printf("str:[ %s ]\n", str);
printf("chr:[ %c ]\n", 'A');
mystrset(str, 'A');
printf("str_op:[ %s ]\n", str);
}

将字符串中前n个字符设置为指定字符

void test_mystrnset(){
printf("\n>>>char *mystrnset(char *, const int, const char)\n");
char str[] = {'h', 'e', 'l', 'l', 'o'};
printf("str:[ %s ]\n", str);
printf("chr:[ %c ]\n", 'A');
printf("num:[ %d ]\n", );
mystrnset(str, , 'A');
printf("str_op:[ %s ]\n", str);
}

忽略大小写进行字符串比较

void test_mychricmp(){
printf("\n>>>int mychricmp(const char, const char)\n");
char c1 = 'a';
char c2 = 'A';
printf("chr1:[ %c ]\n", c1);
printf("chr2:[ %c ]\n", c2);
printf("str_op:[ %d ]\n", mychricmp(c1, c2));
}

忽略大小写进行字符串前n个字符的比较

void test_mystrncmpi(){
printf("\n>>>int mystrncmpi(const char *, const int, const char *)\n");
char *p1 = "AAAbc";
char *p2 = "aaaBC";
printf("str1:[ %s ]\n", p1);
printf("str2:[ %s ]\n", p2);
printf("num:[ %d ]\n", );
printf("str_op:[ %d ]\n", mystrncmpi(p1, , p2));
}

修改字符串中全部指定的字符为新的字符

void test_mystrmodchr(){
printf("\n>>>char *mystrmodchr(char *, const char, const char)\n");
char str[] = {'a', 'b', 'D', 'c', 'D', 'E'};
printf("str:[ %s ]\n", str);
printf("oldchr:[ %c ]\n", 'D');
printf("newchr:[ %c ]\n", 'W');
mystrmodchr(str, 'D', 'W');
printf("str_op:[ %s ]\n", str);
}

修改字符串中全部指定的子字符串为新的字符串

void test_mystrmodstr(){
printf("\n>>>char *mystrmodstr(char *, const char *, const char *)\n");
char str[] = {};
mystrcpy(str, "abCDEefCDErgfCDE");
printf("str:[ %s ]\n", str);
char *p1 = "CDE";
char *p2 = "HHH";
printf("oldstr:[ %s ]\n", p1);
printf("newstr:[ %s ]\n", p2);
mystrmodstr(str, p1, p2);
printf("str_op:[ %s ]\n", str);
}

复制字符串到安全的位置并返回指向它内存的指针

void test_mystrdup(){
printf("\n>>>char *mystrdup(const char *)\n");
char *p1 = "hello", *p2 = NULL;
printf("str1:[ %s ]\n", p2);
printf("str2:[ %s ]\n", p1);
p2 = mystrdup(p1);
printf("str_op:[ %s ]\n", p2);
free(p2);
p2 = NULL;
}

在字符串的指定index处插入字符

void test_mystrinsertchr(){
printf("\n>>>char *mystrinsertchr(char *, const int, const char)\n");
char str[] = {'h', 'e', 'l', 'l', 'o'};
printf("str:[ %s ]\n", str);
printf("index:[ %d ]\n", );
mystrinsertchr(str, , 'W');
printf("str_op:[ %s ]\n", str);
}

在字符串的指定index处插入字符串

void test_mystrinsertstr(){
printf("\n>>>char *mystrinsertstr(char *, const int, const char *)\n");
char str[] = {'h', 'e', 'l', 'l', 'o'};
printf("str:[ %s ]\n", str);
printf("index:[ %d ]\n", );
char *p = "QQQ";
mystrinsertstr(str, , p);
printf("str_op:[ %s ]\n", str);
}

数字字符串转int类型整数

void test_mystrtoint(){
printf("\n>>>int mystrtoint(const char *)\n");
char *p = " +1034";
int num = ;
printf("str:[ %s ]\n", p);
printf("num:[ %d ]\n", num);
num = mystrtoint(p);
printf("str_op:[ %d ]\n", num);
}

数字字符串转double类型浮点数

void test_mystrtodbl(){
printf("\n>>>double mystrtodbl(const char *)\n");
char *p = " +1034.66";
double num = ;
printf("str:[ %s ]\n", p);
printf("num:[ %lf ]\n", num);
num = mystrtodbl(p);
printf("str_op:[ %lf ]\n", num);
}

整体测试

main.c

#include "mystring.h"

int main()
{
printf("__________________TEST_MYSTR_BY_XLC___________________\n");
test_mystrcpy();
test_mystrncpy();
test_mystrlen();
test_myindexof();
test_myindexofstr();
test_mystrcat();
test_mystrncat();
test_mylastindexof();
test_mystrrev();
test_mylastindexofstr();
test_mysubstring();
test_myftsubstring();
test_mytrimstr();
test_mystrcmp();
test_mytolowerstr();
test_mytoupperstr();
test_mygetchrfromstr();
test_mystrsplit();
test_mystrset();
test_mystrnset();
test_mychricmp();
test_mystrncmpi();
test_mystrmodchr();
test_mystrmodstr();
test_mystrdup();
test_mystrinsertchr();
test_mystrinsertstr();
test_mystrtoint();
test_mystrtodbl();
printf("\n-------------------------------------------------------\n");
return ;
}

结果

__________________TEST_MYSTR_BY_XLC___________________

>>>char *mystrcpy(char *, const char *)
str:[ ]
soc:[ hello world ]
str_op:[ hello world ] >>>char *mystrncpy(char *, const int, const char *)
str:[ ]
soc:[ hello world ]
num:[ 5 ]
str_op:[ hello ] >>>int mystrlen(const char *)
str:[ hello ]
str_op:[ 5 ] >>>int myindexof(const char *, const char *)
str:[ aBcaBc ]
chr:[ B ]
str_op:[ 1 ] >>>int myindexofstr(const char *, const char *)
str:[ abCDefghCDij ]
str:[ CD ]
str_op:[ 2 ] >>>char *mystrcat(char *, const char *)
str1:[ hello ]
str2:[ world ]
str_op:[ hello world ] >>>char *mystrncat(char *, const int, const char *)
str1:[ hello ]
str2:[ world ]
num:[ 3 ]
str_op:[ hello wor ] >>>int mylastindexof(const char *, const char *)
str:[ aBcaBc ]
chr:[ B ]
str_op:[ 4 ] >>>char *mystrrev(char *)
str:[ hello ]
str_op:[ olleh ] >>>int mylastindexofstr(const char *, const char *)
str1:[ abCDefghCDij ]
str2:[ CD ]
str_op:[ 8 ] >>>char *mysubstring(char *, const int, const char *)
str1:[ ]
str2:[ hello ]
index:[ 3 ]
str_op:[ lo ] >>>char *myftsubstring(char *, const int, const int, const char *)
str1:[ ]
str2:[ hello world ]
from:[ 3 ]
to:[ 8 ]
str_op:[ lo wo ] >>>char *mytrimstr(char *)
str:[ hello ]
str_op:[ hello ] >>>int mystrcmp(const char *, const char *)
str1:[ abcd ]
str2:[ aBdc ]
str_op:[ 1 ] >>>char *mytolowerstr(char *)
str:[ abCDe ]
str_op:[ abcde ] >>>char *mytoupperstr(char *)
str:[ abCDe ]
str_op:[ ABCDE ] >>>char mygetchrfromstr(const int, const char *)
str:[ hello ]
index:[ 3 ]
str_op:[ l ] >>>int mystrsplit(char **, char *, const char)
str:[ ab cd ef GH ]
str_op:[ ab ]
str_op:[ cd ]
str_op:[ ef ]
str_op:[ GH ] >>>char *mystrset(char *, const char)
str:[ hello ]
chr:[ A ]
str_op:[ AAAAA ] >>>char *mystrnset(char *, const int, const char)
str:[ hello ]
chr:[ A ]
num:[ 3 ]
str_op:[ AAAlo ] >>>int mychricmp(const char, const char)
chr1:[ a ]
chr2:[ A ]
str_op:[ 0 ] >>>int mystrncmpi(const char *, const int, const char *)
str1:[ AAAbc ]
str2:[ aaaBC ]
num:[ 3 ]
str_op:[ 0 ] >>>char *mystrmodchr(char *, const char, const char)
str:[ abDcDE ]
oldchr:[ D ]
newchr:[ W ]
str_op:[ abWcWE ] >>>char *mystrmodstr(char *, const char *, const char *)
str:[ abCDEefCDErgfCDE ]
oldstr:[ CDE ]
newstr:[ HHH ]
str_op:[ abHHHefHHHrgfHHH ] >>>char *mystrdup(const char *)
str1:[ (null) ]
str2:[ hello ]
str_op:[ hello ] >>>char *mystrinsertchr(char *, const int, const char)
str:[ hello ]
index:[ 2 ]
str_op:[ heWllo ] >>>char *mystrinsertstr(char *, const int, const char *)
str:[ hello ]
index:[ 2 ]
str_op:[ heQQQllo ] >>>int mystrtoint(const char *)
str:[ +1034 ]
num:[ 0 ]
str_op:[ 1034 ] >>>double mystrtodbl(const char *)
str:[ +1034.66 ]
num:[ 0.000000 ]
str_op:[ 1034.660000 ] -------------------------------------------------------

实现C语言字符串操作的库函数 包括基本的字符串复制 字符串长度 字符串比较等多种函数(C代码)的更多相关文章

  1. C语言字符串操作常用库函数

    C语言字符串操作常用库函数 *********************************************************************************** 函数 ...

  2. C关于字符串操作的库函数实现总结

    常用C关于字符串操作的库函数实现: //获取字符串长度 int Strlen(const char* s) { assert(s != NULL); ; while (*s++ != '\0') { ...

  3. C语言字符串操作总结大全(超详细)

    本篇文章是对C语言字符串操作进行了详细的总结分析,需要的朋友参考下 1)字符串操作  strcpy(p, p1) 复制字符串  strncpy(p, p1, n) 复制指定长度字符串  strcat( ...

  4. 零基础学习C语言字符串操作总结大全

    本篇文章是对C语言字符串操作进行了详细的总结分析,需要的朋友参考下 1)字符串操作 strcpy(p, p1) 复制字符串 strncpy(p, p1, n) 复制指定长度字符串 strcat(p, ...

  5. C语言字符串操作总结大全

    1)字符串操作 strcpy(p, p1)  复制字符串  函数原型strncpy(p, p1, n)   复制指定长度字符串  函数原型strcat(p, p1)   附加字符串  函数原型strn ...

  6. c语言的字符串操作(比较详细)

    1)字符串操作 strcpy(p, p1) 复制字符串 strncpy(p, p1, n) 复制指定长度字符串 strcat(p, p1) 附加字符串 strncat(p, p1, n) 附加指定长度 ...

  7. C语言字符串操作函数集

    1)字符串操作 strcpy(p, p1) 复制字符串 strncpy(p, p1, n) 复制指定长度字符串 strcat(p, p1) 附加字符串 strncat(p, p1, n) 附加指定长度 ...

  8. C语言字符串操作详细总结

    1)字符串操作 strcpy(p, p1) 复制字符串 strncpy(p, p1, n) 复制指定长度字符串 strcat(p, p1) 附加字符串 strncat(p, p1, n) 附加指定长度 ...

  9. 面试之C语言字符串操作总结大全(转载)

    趁着十一就好好补补数据结构吧,通信这个不软不硬的专业,现在还是得好好学学补习补习,,你这个非211的本科生!虽然拿到了一个offer,但是觉得时间还有,得继续拼一拼,希望不辜负! 1)字符串操作 st ...

随机推荐

  1. stm32 外设使用的配置步骤

    @2018-5-10  使用外设的配置步骤 #1 打开时钟 > 打开外设时钟 > 打开相关GPIO时钟 > 打开DMA时钟  (若需要) #2 关联外设与GPIO > 复位关联 ...

  2. 【bzoj3160】 万径人踪灭

    http://www.lydsy.com/JudgeOnline/problem.php?id=3160 (题目链接) 题意 给定一个由'a'和'b'构成的字符串,求不连续回文子序列的个数. Solu ...

  3. 洛谷_Cx的故事_解题报告_第四题70

    1.并查集求最小生成树 Code: #include <stdio.h> #include <stdlib.h>   struct node {     long x,y,c; ...

  4. 3分钟读懂移动端rem使用方法

    1.为什么要用rem 博客很久没写了,原因很简单. 最近接手了一个项目,要同时做PC和移动端的页面,之前没接触过,但毕竟给钱的是大爷,所以还是硬着头皮上了. 移动端最麻烦的是什么? 不同分辨率适配! ...

  5. matplotlib交互模式与pacharm单独Figure设置

    matplotlib交互模式与pacharm单独Figure设置 觉得有用的话,欢迎一起讨论相互学习~Follow Me Matpotlib交互模式 在运行python程序时有时候需要生成以下的 动态 ...

  6. 阿里云Tengine和Openresty/1.11.2.3 数据对比

    HLS播放延迟测试:阿里云48s ,openresy 31s Cache-Control: max-age=300 NGINX下配置CACHE-CONTROL   Content-Length:637 ...

  7. 用Canvas做动画

    之前看过不少HTML5动画的书,讲解的是如何去做,对于其中的数学原理讲解的不详细,常有困惑.最近看的<HTML5+JavaScript 动画基础>这个是译本,Keith Peters曾写过 ...

  8. 一个网页的对象抽象之路——po编程 (干货,Java自动化测试)

    先来看一个在腾讯课堂首页搜索机构的操作步骤: 1:首先打开腾讯课堂的首页:https://ke.qq.com 2:点击课程或机构的下拉选择图标 3:选择机构 4:在搜索框输入要搜索的机构名称 5:点击 ...

  9. Linux 抽象网络设备简介

    Linux 抽象网络设备简介 和磁盘设备类似,Linux 用户想要使用网络功能,不能通过直接操作硬件完成,而需要直接或间接的操作一个 Linux 为我们抽象出来的设备,既通用的 Linux 网络设备来 ...

  10. WPF中各个Template的分析(转)

    作为新手,还是没看明白本文,留着以后再学习 在使用TabControl.ListView.Menu.TreeView的时候被各种Template搞得头昏眼花,决心把这个问题搞清楚,究竟什么时候该用什么 ...