头文件

"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. java.lang.UnsupportedClassVersionError: org/kie/api/KieServices$Factory : Unsupported major.minor version 52.0

    Unsupported major.minor version 52.0为JDK1.8编译器的版本,需要更换为JDK1.8的编译器与JDK1.8开发环境 idea中通过修改

  2. 洛谷P2480 古代猪文

    这道题把我坑了好久...... 原因竟是CRT忘了取正数! 题意:求 指数太大了,首先用欧拉定理取模. 由于模数是质数所以不用加上phi(p) 然后发现phi(p)过大,不能lucas,但是它是个sq ...

  3. C++并发编程之std::async(), std::future, std::promise, std::packaged_task

    c++11中增加了线程,使得我们可以非常方便的创建线程,它的基本用法是这样的: void f(int n); std::thread t(f, n + 1); t.join(); 但是线程毕竟是属于比 ...

  4. Python基础学习(三)

    了解了Python的基础使用,接下来继续练手廖雪峰老师的教学案例. 一.变量可以指向函数 说明,一个函数可以赋值给一个变量,该变量就会具有该函数的功能,举例: gg = abs print( gg(- ...

  5. zabbix监控的基础概念、工作原理及架构(一)

    zabbix监控的基础概念.工作原理及架构 转载于网络 一.什么是zabbix及优缺点 Zabbix能监视各种网络参数,保证服务器系统的安全运营,并提供灵活的通知机制以让系统管理员快速定位/解决存在的 ...

  6. 第一节 Spring的环境搭建

     正在构建,扫一扫,敬请期待 和玩得来的人在一起玩才叫玩! 和玩不来的人在一起玩,那种感觉就像加班啊! 关注胖个人微信公众账号,希望对各位学生有所帮助! --胖先生 Spring框架,什么是Sprin ...

  7. .NET面试题系列(六)多线程

    1.多线程的三个特性:原子性.可见性.有序性 原子性:是指一个操作是不可中断的.即使是多个线程一起执行的时候,一个操作一旦开始,就不会被其他线程干扰. 比如,对于一个静态全局变量int i,两个线程同 ...

  8. [转]CSS浏览器兼容问题总结

    E6.0,ie7.0与Firefox的CSS兼容性问题1.DOCTYPE 影响 CSS 处理 2.FF: div 设置 margin-left, margin-right 为 auto 时已经居中,  ...

  9. 洛谷 P1563 玩具谜题

    如果你想不耗费脑力做出这个题目,往下看: 本萌新看到这个题目,想到了乘法法则,题目中左右方向要判断两次,很耗脑力,和乘法中的正负号判断非常像. 抽象一点:这个人向内向外就是乘法中括号外的正负号,他的左 ...

  10. sql 跨服务器查询数据

    方法一:用OPENDATASOURCE [SQL SERVER] 跨服务器查询 --1 打开 reconfigure reconfigure SELECT * FROM OPENDATASOURCE( ...