实现C语言字符串操作的库函数 包括基本的字符串复制 字符串长度 字符串比较等多种函数(C代码)
头文件
"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代码)的更多相关文章
- C语言字符串操作常用库函数
C语言字符串操作常用库函数 *********************************************************************************** 函数 ...
- C关于字符串操作的库函数实现总结
常用C关于字符串操作的库函数实现: //获取字符串长度 int Strlen(const char* s) { assert(s != NULL); ; while (*s++ != '\0') { ...
- C语言字符串操作总结大全(超详细)
本篇文章是对C语言字符串操作进行了详细的总结分析,需要的朋友参考下 1)字符串操作 strcpy(p, p1) 复制字符串 strncpy(p, p1, n) 复制指定长度字符串 strcat( ...
- 零基础学习C语言字符串操作总结大全
本篇文章是对C语言字符串操作进行了详细的总结分析,需要的朋友参考下 1)字符串操作 strcpy(p, p1) 复制字符串 strncpy(p, p1, n) 复制指定长度字符串 strcat(p, ...
- C语言字符串操作总结大全
1)字符串操作 strcpy(p, p1) 复制字符串 函数原型strncpy(p, p1, n) 复制指定长度字符串 函数原型strcat(p, p1) 附加字符串 函数原型strn ...
- c语言的字符串操作(比较详细)
1)字符串操作 strcpy(p, p1) 复制字符串 strncpy(p, p1, n) 复制指定长度字符串 strcat(p, p1) 附加字符串 strncat(p, p1, n) 附加指定长度 ...
- C语言字符串操作函数集
1)字符串操作 strcpy(p, p1) 复制字符串 strncpy(p, p1, n) 复制指定长度字符串 strcat(p, p1) 附加字符串 strncat(p, p1, n) 附加指定长度 ...
- C语言字符串操作详细总结
1)字符串操作 strcpy(p, p1) 复制字符串 strncpy(p, p1, n) 复制指定长度字符串 strcat(p, p1) 附加字符串 strncat(p, p1, n) 附加指定长度 ...
- 面试之C语言字符串操作总结大全(转载)
趁着十一就好好补补数据结构吧,通信这个不软不硬的专业,现在还是得好好学学补习补习,,你这个非211的本科生!虽然拿到了一个offer,但是觉得时间还有,得继续拼一拼,希望不辜负! 1)字符串操作 st ...
随机推荐
- 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中通过修改
- 洛谷P2480 古代猪文
这道题把我坑了好久...... 原因竟是CRT忘了取正数! 题意:求 指数太大了,首先用欧拉定理取模. 由于模数是质数所以不用加上phi(p) 然后发现phi(p)过大,不能lucas,但是它是个sq ...
- C++并发编程之std::async(), std::future, std::promise, std::packaged_task
c++11中增加了线程,使得我们可以非常方便的创建线程,它的基本用法是这样的: void f(int n); std::thread t(f, n + 1); t.join(); 但是线程毕竟是属于比 ...
- Python基础学习(三)
了解了Python的基础使用,接下来继续练手廖雪峰老师的教学案例. 一.变量可以指向函数 说明,一个函数可以赋值给一个变量,该变量就会具有该函数的功能,举例: gg = abs print( gg(- ...
- zabbix监控的基础概念、工作原理及架构(一)
zabbix监控的基础概念.工作原理及架构 转载于网络 一.什么是zabbix及优缺点 Zabbix能监视各种网络参数,保证服务器系统的安全运营,并提供灵活的通知机制以让系统管理员快速定位/解决存在的 ...
- 第一节 Spring的环境搭建
正在构建,扫一扫,敬请期待 和玩得来的人在一起玩才叫玩! 和玩不来的人在一起玩,那种感觉就像加班啊! 关注胖个人微信公众账号,希望对各位学生有所帮助! --胖先生 Spring框架,什么是Sprin ...
- .NET面试题系列(六)多线程
1.多线程的三个特性:原子性.可见性.有序性 原子性:是指一个操作是不可中断的.即使是多个线程一起执行的时候,一个操作一旦开始,就不会被其他线程干扰. 比如,对于一个静态全局变量int i,两个线程同 ...
- [转]CSS浏览器兼容问题总结
E6.0,ie7.0与Firefox的CSS兼容性问题1.DOCTYPE 影响 CSS 处理 2.FF: div 设置 margin-left, margin-right 为 auto 时已经居中, ...
- 洛谷 P1563 玩具谜题
如果你想不耗费脑力做出这个题目,往下看: 本萌新看到这个题目,想到了乘法法则,题目中左右方向要判断两次,很耗脑力,和乘法中的正负号判断非常像. 抽象一点:这个人向内向外就是乘法中括号外的正负号,他的左 ...
- sql 跨服务器查询数据
方法一:用OPENDATASOURCE [SQL SERVER] 跨服务器查询 --1 打开 reconfigure reconfigure SELECT * FROM OPENDATASOURCE( ...