目录
- 一：strlen
- 二：strcpy
- 三：strcat
- 四：strcmp
- 五：strncpy
- 六：strncat
- 七：strncmp
- 八：strstr
- 九：strtok
- 九：strerror
- 十：perror
- 十一：一些字符函数
- 十二：memcpy
- 十三：memmove
- 十四：memcmp
- 十四：memset
成都创新互联公司是专业的鼓楼网站建设公司，鼓楼接单;提供成都做网站、网站制作、
成都外贸网站建设,网页设计,网站设计,建网站,PHP网站建设等专业做网站服务;采用PHP框架,可快速的进行鼓楼网站开发网页制作和功能扩展;专业做搜索引擎喜爱的网站,专业的做网站团队,希望更多企业前来合作!
一：strlenstrlen：计算字符串长度函数
size_t strlen ( const char * str );
注意事项：
- 字符串以
'\0'作为结束标志，strlen函数返回值是在字符串中'\0'前面出现的字符个数（不包含'\0'） - 参数是一个字符指针变量
- 参数指向的字符串必须要以
'\0'结束，否则计算出的长度是随机值 - 注意函数的返回值为
size_t，是无符号的
因为返回值是size_t，所以就要避免出现下面这样的代码：strlen("abc") - strlen("abcde")，strlen("abc")算出的结果是3，strlen("abcde")算出的结果是5，可能想着3-5得到-2，实际上并不是这样的，这里算出的3和5都是无符号整型，算出的-2也是一个无符号整型，-2在内存中以补码的形式存储，从无符号整型的视角看去，这串补码就表示一个很大的正数。
模拟实现：//常规实现
int my_strlen1(const char* arr)
{assert(arr != NULL);
int count = 0;
while (*arr)
{count++;
arr++;
}
return count;
}
//递归实现
int my_strlen2(const char* arr)
{assert(arr!=NULL);
if (*arr == '\0')
{return 0;
}
else
{return 1 + my_strlen2(arr + 1);
}
}
//指针减指针实现
int my_strlen3(const char* arr)
{assert(arr != NULL);
const char* start = arr;
while (*arr)
{arr++;
}
return arr - start;
}
int main()
{char arr[] = "abcdef";
int len = my_strlen3(arr);
printf("%d\n", len);
return 0;
}
二：strcpystrcpy：字符串拷贝函数，把源字符串拷贝到目标空间
char * strcpy ( char * destination, const char * source );
注意事项：
- 函数有两个参数，其中
source指向待拷贝的字符串，也叫做源字符串，destination是目标空间的地址 - 源字符串必须以’\0’结束
- 会把源字符串中的 ‘\0’ 也拷贝到目标空间
- 目标空间必须足够大，以确保能存放源字符串，否则会出现非法访问
- 目标空间必须可变，例如把源字符串拷贝到一个字符串常量里面是不可取的
模拟实现：char* my_strcpy(char* dest, const char* src)
{assert(dest && src);
char* ret = dest;
while (*dest++ = *src++)
{;
}
return ret;
}
int main()
{char arr1[20] = {0 };
char arr2[] = "hello world";
my_strcpy(arr1, arr2);
printf("%s\n", arr1);
return 0;
}
三：strcatstrcat：字符串追加函数，将源字符串追加到目标字符串后面，目标中的终止字符’\0’会被源字符串的第一个字符覆盖
char * strcat ( char * destination, const char * source );
注意事项：
- 函数有两个参数，其中
source指向要追加的字符串，也叫做源字符串，destination是目标空间的地址 - 目标空间中必须要有
'\0'，作为追加的起始地址 - 源字符串中也必须要有
'\0'作为追加的结束标志 - 目标空间必须足够大，能容纳下源字符串的内容
- 目标空间必须可修改
- 自己给自己追加会陷入死循环
模拟实现：char* my_strcat(char* dest, const char* src)
{assert(dest && src);
char* ret = dest;
//找目标空间的'\0'
while (*dest != '\0')
{dest++;
}
//追加
while (*dest++ = *src++)
{;
}
return ret;
}
int main()
{char arr1[20] = "hello ";
char arr2[] = "world";
my_strcat(arr1, arr2);
printf("%s\n", arr1);
return 0;
}
四：strcmpstrcmp：字符串比较函数
int strcmp ( const char * str1, const char * str2 );
注意事项：
- 这里比较的不是两个字符串的长度，而是对应位置上的ASCII值
- 第一个字符串大于第二个字符串，则返回大于0的数字
- 第一个字符串等于第二个字符串，则返回0
- 第一个字符串小于第二个字符串，则返回小于0的数字
模拟实现：int my_strcmp(const char* str1, const char* str2)
{assert(str1 && str2);
while (*str1 == *str2)//如果相等就进去，两个指针加加，但是可能会出现两个字符串相等的情况，两个指针都指向'\0'，此时比较就结束了
{if (*str1 == '\0')
{ return 0;
}
str1++;
str2++;
}
if (*str1 >*str2)
{return 1;
}
else
{return -1;
}
}
int main()
{char arr1[] = "abq";
char arr2[] = "abq";
int ret=my_strcmp(arr1, arr2);
printf("%d\n", ret);
return 0;
}
五：strncpystrncpy：长度受限的字符串拷贝函数
char * strncpy ( char * destination, const char * source, size_t num );
注意事项：
- 拷贝num个字符从源字符串到目标空间。
- 如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。
模拟实现：char* my_strncpy(char* dest, const char* src, int num)
{assert(dest && src);
char* ret = dest;
while (num)
{if (*src == '\0')//此时说明src指针已经指向了待拷贝字符串的结束标志'\0'处，src指针就不用再++了
{ *dest = '\0';
dest++;
}
else
{ *dest = *src;
dest++;
src++;
}
num--;
}
return ret;
}
int main()
{char arr1[20] = "xxxxxxxxxxxxxxxxxxx";
my_strncpy(arr1, "abcdef", 10);
printf("%s\n", arr1);
return 0;
}
六：strncatstrncat：长度受限的字符串追加函数
char * strncat ( char * destination, const char * source, size_t num );
注意事项：
- 从源字符串的第一个字符开始往后数num个字符追加到目标空间的后面，外加一个终止字符。
- 如果源字符串的长度小于 num，则仅复制终止字符之前的内容。
模拟实现：char* my_strncat(char* dest, const char* src, int sz)
{assert(dest && src);
char* ret = dest;
//找目标空间的\0
while (*dest != '\0')
{dest++;
}
//追加
while (sz)
{*dest++ = *src++;
sz--;
}
*dest = '\0';
return ret;
}
int main()
{char arr1[20] = "abc\0xxxxxxxxxxx";
my_strncat(arr1, "defjhigk", 3);
printf("%s\n", arr1);
return 0;
}
七：strncmpstrncmp：长的受限的字符串比较函数
int strncmp ( const char * str1, const char * str2, size_t num );
注意事项：
- 比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完。
模拟实现：int my_strncmp(const char* str1, const char* str2, int sz)
{assert(str1 && str2);
while (sz)
{if (*str1< *str2)
{ return -1;
}
else if (*str1 >*str2)
{ return 1;
}
else if(*str1 == '\0'||*str2 =='\0')//当有一个为'\0'，说明比较就可以结束了
{ if (*str1 == '\0' && *str2 == '\0')//如果二者都是'\0'，说明两个字符串相等
{ return 0;
}
else if(*str1 =='\0')//如果str1为'\0'，说明str1小，str2大
{ return -1;
}
else//如果src为'\0'，说明str1大，str2小
{ return 1;
}
}
sz--;
str1++;
str2++;
}
}
int main()
{int ret = my_strncmp("abcdef", "abcd", 5);
printf("%d\n", ret);
return 0;
}
八：strstrstrstr：字符串查找函数
const char * strstr ( const char * str1, const char * str2 );
注意事项：
- 在str1指向的字符串中查找str2指向的字符串
- 返回一个指向str1中第一次出现的str2的指针
- 如果 str2 不是 str1 的一部分，则返回一个空指针
- 匹配过程不包括终止空字符，但它到此为止
模拟实现：char* my_strstr(char* str1, char* str2)
{assert(str1 && str2);
if (*str2 == '\0')
{return str1;
}
char* s1 = str1;
char* s2 = str2;
char* cp = str1;
while (*cp)
{s1 = cp;
s2 = str2;
while (*s1 != '\0' && *s2 != '\0' && *s1 == *s2)
{ s1++;
s2++;
}
if (*s2 == '\0')
{ return cp;
}
cp++;
}
return NULL;
}
int main()
{char arr1[] = "abbvcbcbbdbbvbnui";
char arr2[] = "bbvb";
char* ret = my_strstr(arr1, arr2);
if (ret == NULL)
{printf("找不到\n");
}
else
{printf("%s\n", ret);
}
return 0;
}
九：strtokstrtok：字符串拆分函数
char * strtok ( char * str, const char * sep );
注意事项：
- sep参数是个字符串，定义了用作分隔符的字符集合
- 第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记
- strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
- strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置
- strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记
- 如果字符串中不存在更多的标记，则返回 NULL 指针
代码实现：int main()
{char arr[] = "konglong@qq.com";
char* p = "@.";
char buf[20] = {0 };
strcpy(buf, arr);
char* ret=NULL;
for (ret = strtok(buf, p); ret != NULL; ret = strtok(NULL, p))
{printf("%s\n", ret);
}
return 0;
}
九：strerrorstrerror：把错误码转换成错误信息的函数
char * strerror ( int errnum );
注意事项：
- C语言的库函数在运行的时候，如果发生错误，就会把错误码存在一个变量中，这个变量是：errno
- 返回的指针指向静态分配的字符串（错误信息字符串）
一些错误码对应的错误信息：
int main()
{printf("%s\n", strerror(0));
printf("%s\n", strerror(1));
printf("%s\n", strerror(2));
printf("%s\n", strerror(3));
printf("%s\n", strerror(4));
printf("%s\n", strerror(5));
return 0;
}
//结果：
No error
Operation not permitted
No such file or directory
No such process
Interrupted function call
Input/output error
strerror函数的一般用法：
int main()
{//打开文件
FILE* pf = fopen("test.c", "r");
if (pf == NULL)
{printf("%s\n", strerror(errno));//需要包含头文件#includereturn 1;
}
//读文件
//关闭文件
fclose(pf);
return 0;
}
//打开失败时屏幕显示：
No such file or directory
fopen是一个打开文件的函数，第一参数是文件名，第二个参数是打开方式，如果打开成功会返回一个有限的指针，打开失败会返回一个空指针，此时我们就可以通过strerror函数去查看为什么打开失败
十：perrorperror：直接打印错误信息的函数
void perror ( const char * str );
注意事项：
str指向一个字符串，这个字符串包含要在错误消息本身之前打印的自定义消息。如果是空指针，则不会打印前面的自定义消息，但仍会打印错误消息- 如果参数
str不是空指针，则打印str后跟冒号 （:)和一个空间。然后，无论str是否为空指针，都会打印生成的错误描述，后跟换行符 （'\n'）
perror函数的一般用法：
int main()
{//打开文件
FILE* pf = fopen("test.txt", "r");
if (pf == NULL)
{perror("fopen");
return 1;
}
//读文件
//关闭文件
fclose(pf);
return 0;
}
//打开失败时显示：
fopen: No such file or directory
十一：一些字符函数字符分类函数：| 函数 | 如果它的参数复合下列条件就返回真（一个非零数字） |
|---|
| iscntrl | 任何控制字符 |
| isspace | 空白字符：空格’ ‘，换页’\f’，换行’\n’，回车’\r’，制表符’\t’或者垂直制表符’\v’ |
| isdigit | 十进制数字0~9 |
| isxdigit | 十六进制数字，包括所有十进制数字，小写字母a~f，大写字母A~F |
| islower | 小写字母a~z |
| isupper | 大写字母A~Z |
| isalpha | 字母a~z或A~Z |
| isalnum | 字母或者数字，a~z，A~Z ，0~9 |
| ispunct | 标点符号，任何不属于数字或者字母的图形字符（可打印） |
| isgraph | 任何图形字符 |
| isprint | 任何可打印字符，包括图形字符和空白字符 |
字符转换函数：tolower：将大写字母转换为小写字母
int tolower ( int c );
注意事项：
- 如果 c 是大写字母并且具有小写等效字母，则将 c 转换为其小写等效项。如果无法进行此类转换，则返回的值为 c 不变。
- 大写字母是以下任意字母：A B C D E F G H I J K L M N O P Q R S T U V W X Y Z，分别翻译为：a b c d e f g h i j k l m n o p q r s t u v w x y z
- 这里是值传递，不会改变实参
toupper：将小写字母转换成大写字母
int toupper ( int c );
注意事项：
- 如果 c 是小写字母并且具有大写等效字母，则将 c 转换为其大写等效字母。如果无法进行此类转换，则返回的值为 c 不变
- 这里是值传递，不会改变实参
应用：
int main()
{char arr[] = "I Have An Apple";
int i = 0;
while (arr[i])
{if (isupper(arr[i]))
{ printf("%c", tolower(arr[i]));//把转换的小写字母直接打印出来
}
else
{ printf("%c", arr[i]);
}
i++;
}
return 0;
}
//结果：
i have an apple
int main()
{char arr[] = "I Have An Apple";
int i = 0;
while (arr[i])
{if (isupper(arr[i]))
{ arr[i] = tolower(arr[i]);//用转换后的小写字符替换原有的大写字符
}
printf("%c", arr[i]);
i++;
}
return 0;
}
以上介绍的这些函数都是针对字符串或者字符的，那如果我们要拷贝其他类型的数据呢？用上面这些函数自然就行不通了，此时就要用到即将介绍的内存函数了。
十二：memcpymemcpy：内存拷贝函数
void * memcpy ( void * destination, const void * source, size_t num );
注意事项：
这里的destination指向要在其中赋值内容的目标数组，source指向要复制的数据源，num是要复制的字节数，注意这里前两个指针的的类型还有函数返回值都是void*，这是因为，memcpy这个函数是内存拷贝函数，它有可能拷贝整型，浮点型，结构体等等各种类型的数据……虽然返回类型是void*，但他也是必不可少的，void*也表示一个地址，用户可以把它强制转换成自己需要的类型去使用。
应用：
//把arr1中的1、2、3、4、5拷贝到arr2数组中
int main()
{int arr1[] = {1,2,3,4,5,6,7,8,9,10 };
int arr2[10] = {0 };
memcpy(arr2, arr1, 20);//拷贝5个整型，就是20个字节
return 0;
}
//把arr1中的3、4、5、6拷贝到arr2数组中
int main()
{int arr1[] = {1,2,3,4,5,6,7,8,9,10 };
int arr2[10] = {0 };
memcpy(arr2, arr1+2, 16);//此时只要改变参数中数据源的地址就可以，把3的地址传过去就行，复制4个整型就是1个字节
return 0;
}
模拟实现：void* my_memcpy(void* dest, const void* src, size_t num)
{assert(dest && src);
void* ret = dest;
while (num)
{*(char*)dest = *(char*)src;
((char*)dest)++;
((char*)src)++;
num--;
}
return ret;
}
int main()
{int arr1[] = {1,2,3,4,5,6,7,8,9,10 };
int arr2[10] = {0 };
my_memcpy(arr2, arr1+2, 16);
return 0;
}
上面代码中模拟出来的my_memcpy函数已经可以实现把arr1数组中的元素拷贝到arr2数组里面去。但当我们想把arr1数组中的1、2、3、4、5拷贝到arr1数组中的3、4、5、6、7上去时，就会发生错误，如下图：
原因是：当1拷贝到3上时，原来的3已经被1替换，当2拷贝到4上的时候，原来的4已将被2替换。所以当拷贝arr[2]到arr[4]上的时候，原本arr[2]里面存放的3已将被1替换了，同理，所以才得出了不符合我们预期的结果。那如何解决这个问题呢？先来分析这个问题产生的原因，这是因为源空间与目标空间之间有重叠，这里的arr[2]、arr[3]、arr[4]既是源空间也是目标空间，当拷贝1和2的时候把源空间中开没有拷贝的3和4就给覆盖了，此时源空间arr[2]和arr[3]里面存的就不再是3和4了，而是1和2，所以此时拷贝arr[2]和arr[3]里面的数据，其实拷贝的就是1和2。为了解决这个问题，我们可以从后往前拷贝，此时就不会出现这样的问题
解决的思路就是：先拷贝重叠区域的元素，避免其还没拷贝就被覆盖掉。但并不是一遇到源空间和目标空间重叠就从后王前拷贝，比如下面这样，此时要把3、4、5、6、7拷贝到1、2、3、4、5里面
此时就不能用上面的方法从后往前拷贝了，但是可以根据上面提到的解决思路：先拷贝重叠区域的元素，所以此时就应该从前往后拷贝，即按照3、4、5、6、7的顺序去拷贝
因此在拷贝的时候，是按照从前往后的顺序还是从后往前的顺序得看具体的情况。当目标空间的起始位置在源空间的前面时，就得从前往后进行拷贝。当目标空间的起始位置在源空间的后面的时候，就要从后往前拷贝。当源空间和目标空间没有任何重叠的时候，不管是从前往后拷贝还是从后往前拷贝效果都一样。
接下来介绍的memmove函数就可以完成重叠空间的元素拷贝。
十三：memmovememmove：内存拷贝函数
void * memmove ( void * destination, const void * source, size_t num );
它的参数、返回值与memcpy函数一模一样。这里就不过多介绍。对于这两个函数来说，目标空间必须足够大，不然就会发生越界访问。
模拟实现：void* my_memmove(void* dest, const void* src, int num)
{assert(dest && src);
void* ret = dest;
if (dest< src)
{//从前向后
while (num--)
{ *(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
}
else
{//从后往前
while (num--)//num为1的时候，下面的num就是0
{ *((char*)dest + num) = *((char*)src + num);//通过num的减减就可以实现对每一个字节的访问
}
}
return ret;
}
int main()
{int arr1[] = {1,2,3,4,5,6,7,8,9,10 };
my_memmove(arr1+2, arr1, 20);
return 0;
}
十四：memcmpmemcmp：内存比较函数
int memcmp ( const void * ptr1, const void * ptr2, size_t num );
注意事项：
- 比较从ptr1和ptr2指针开始的num个字节
- 两个内存块中不匹配的第一个字节在 ptr1 中的值低于 ptr2 中的值返回一个小于零的数子，相等返回零，两个内存块中不匹配的第一个字节在 ptr1 中的值大于在 ptr2 中的值返回一个大于零的数子
应用
int main()
{int arr1[] = {1,2,6 };//01 00 00 00 02 00 00 00 06 00 00 00
int arr2[] = {1,2,5 };//01 00 00 00 02 00 00 00 05 00 00 00
int ret = memcmp(arr1, arr2, 9);
printf("%d\n", ret);
return 0;
}//结果：
1
十四：memsetmemset：内存设置函数
void * memset ( void * ptr, int value, size_t num );
注意事项：
- 以字节为单位来设置内存中的数据，把从ptr开始往后的num个字节设置成value
- 形参value也可以是字符，字符其实也是整型，因为字符在内存中存的是其ASCII
- value如果是整数的话，需要注意它的取值范围，因为一个字节大可以存储255，超过255就会发生截断
应用：
int main()
{char arr[] = "hello word";
memset(arr, 'x', 5);//先把"hello"改成"xxxxx"
printf("%s\n", arr);
memset(arr + 6, 'y', 4);//再把"word"改成"yyyy"
printf("%s\n", arr);
return 0;
}
//
你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧
网站题目：【C语言进阶】一篇带你掌握字符串和内存函数-创新互联
文章地址：
http://cdkjz.cn/article/hhssh.html
