深入了解C语言字符函数和字符串函数
目录
- 前言
- 求字符串长度
- strlen介绍
- strlen直接使用：
- strlen模拟实现：
- strlen对比sizeof
- 长度不受限制的字符串函数
- strcpy
- 直接使用
- 模拟实现：
- strcat
- 直接使用：
- 模拟实现：
- strcmp
- 运行结果：
- 模拟实现：
- 长度受限制的字符串函数
- strncpy
- strncat
- strncmp
- 字符串查找
- strstr
- strtok
- 字符分类函数
- 内存操作函数
- memcpy
- memmove
- memcmp
- 总结
前言
C语言中对字符串的处理很是繁琐，但是C语言本身是没有字符串类型的，字符串通常放在常量字符串中或者字符数组中。字符串常量适用于那些对它不做修改的字符串函数。直接使用下面函数需要包含其头文件**<string.h>**
求字符串长度
strlen介绍
语法/原型：
size_t strlen(const char* str); //str 表示要求长度的字符串。
strlen所作的是一个计数器的工作，它从内存的某个位置（可以是字符串开头，中间某个位置，甚至是某个不确定的内存区域）开始扫描，直到碰到第一个字符串结束符'\0'为止，然后返回计数器值(长度不包含'\0')。
strlen直接使用：
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <string.h>
int main()
{
char a[] = "abcdefg";
char b[] = { 'a', 'b', 'c', 'd', 'e', 'f', 'g' };
int len1 = strlen(a);
int len2 = strlen(b);
printf("%d\n", len1);
printf("%d\n", len2);
return 0;
}
输出结果：
a,b数组对比：
strlen模拟实现：
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <string.h>
#include <assert.h>
int my_strlen(const char* str)
{
int count = 0;//计数器
assert(str != NULL);
while (*str != '\0')
{
count++;
str++;
}
return count;
}
int main()
{
char a[] = "abcdefg";
int len = my_strlen(a);//使用自己创建的strlen函数来计算数组长度！
printf("%d\n", len);
return 0;
}
输出结果：
strlen对比sizeof
strlen()的一种实现就是遍历字符串，遇到'\0'就终止，因而返回的结果是第一个'\0'前字符元素的个数 sizeof 常用来求变量占用内存空间的大小，因而它返回的是存储字符串的变量所占用的内存空间大小，用来求字符串的长度，只在特定情况下可行，即字符数组刚好被一个字符串占满。
代码检验：
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <string.h>
int main()
{
char a[] = "abcdefg";
printf("%d\n", strlen(a));
printf("%d\n", sizeof(a));//一个字符所占空间为一个字节
printf("%d\n", (sizeof(a) / sizeof(a[0])));
return 0;
}
运行结果：
长度不受限制的字符串函数
strcpy
- 语法/原型：char* strcpy(char* dest , const char * src)
- 头文件：#include <string.h> 和 #include <stdio.h>
- 功能：把从src地址开始且含有NULL结束符的字符串复制到以dest开始的地址空间.
- 说明：src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。
- 注：源字符串必须以'\0'结尾，并且会将源字符串中的'\0'拷贝到目标空间。
直接使用
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
int main()
{
char a[10];
char b[] = "hello bit";
strcpy(a, b);
printf("%s", a);
return 0;
}
运行结果：
模拟实现：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
void my_strcpy(char *a, const char *b)
{
int i = 0;
while (*b != '\0')
{
*a = *b;
*a++;
*b++;
}
*a++ = '\0';
}
int main()
{
char a[10];
char b[] = "hello bit";
my_strcpy(a, b);
printf("%s", a);
return 0;
}
运行结果同上！
strcat
- 语法/原型：char * strcat(char * dest, const char* src);
- 头文件: include<string.h>
- 功能:把src所指向的字符串（包括“\0”）复制到dest所指向的字符串后面（删除dest原来末尾的“\0”）。要保证dest足够长，以容纳被复制进来的*src。*src中原有的字符不变。返回指向dest的指针。
- 说明:src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。
直接使用：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
int main()
{
char a[20]="hello ";
char b[20] = "bit ";
char c[20] = "hello ";
strcat(a, b);
strcat(b, c);
printf("%s\n",a);
printf("%s\n", b);
return 0;
}
模拟实现：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
#include<assert.h>
void my_strcat(char *x, const char *y)
{
assert(x != NULL);
assert(y != NULL);
while (*x)//找到目标字符串中的'\0'
{
x++;
}
while ((*x++ = *y++))
{
;
}
}
int main()
{
char a[20]="hello ";
char b[20] = "bit ";
my_strcat(a, b);
printf("%s\n",a);
return 0;
}
运行结果：
strcmp
- 语法/原型：int strcmp(const char *s1,const char *s2);
- 头文件: include<string.h>
- 功能：用于对两个字符串进行比较(区分大小写) 直接使用：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
#include<assert.h>
int main()
{
char a[20]= "ABCD";
char b[20] = "ABCG";
int i=strcmp(a, b);
if (i > 0)
{
printf("a>b\n");
}
else if (i==0)
{
printf("a=b\n");
}
else
{
printf("a<b\n");
}
return 0;
}
运行结果：
模拟实现：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
#include<assert.h>
int my_strcmp(const char *x, const char *y)
{
int ret = 0;
assert(x != NULL);
assert(y != NULL);
while (!(ret = *(unsigned char *)x - *(unsigned char *)y) && *y)
{
++x;
++y;
}
if (ret < 0)
ret = -1;
else if (ret >0)
ret = 1;
return ret;
}
int main()
{
char a[20]= "ABCD";
char b[20] = "ABCG";
int i=my_strcmp(a, b);
if (i > 0)
{
printf("a>b\n");
}
else if (i==0)
{
printf("a=b\n");
}
else
{
printf("a<b\n");
}
return 0;
}
运行结果同上！
长度受限制的字符串函数
strncpy
- 语法/原型： char *strncpy(char *destinin, char *source, int maxlen);
- 参数:destinin：表示复制的目标字符数组；source：表示复制的源字符数组；maxlen：表示复制的字符串长度.
- 对比: 相对于strcpy增加了长度限制
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
int main()
{
char arr1[20]="1234567";
char arr2[] = "abcdefg";
strncpy(arr1, arr2, 3);//拷贝3个字符到arr1数组
printf("%s\n", arr1);
return 0;
}
运行结果：
strncat
语法/原型：char * strncat(char *dest, const char *src, size_t n);参数说明: dest指向目标字符串，src为指向源字符串。
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h.>
#include<string.h>
int main()
{
char arr1[20] = "hello ";
char arr2[] = "csdn";
strncat(arr1, arr2, 1);
printf("%s\n", arr1);
return 0;
}
strncmp
语法/原型：int strncmp(const char *str1, const char *str2, size_t n)参数说明：str1-- 要进行比较的第一个字符串。str2-- 要进行比较的第二个字符串。n-- 要比较的最大字符数。
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
int main()
{
char* a = "abcdef";
char* b = "abchij";
int i = strncmp(a, b, 4);
if (i > 0)
{
printf("a>b\n");
}
else if (i == 0)
{
printf("a=b\n");
}
else
{
printf("a<b\n");
}
return 0;
}
字符串查找
strstr
- 语法/原型：char *strstr(const char *str1, const char *str2);
- 参数说明：str1 - 要查找的字符串或字符串指针; str2 - 要查找的子串
- 功能：判断字符串str2是否是str1的子串。
- 返回值: 函数返回str2在str1中首次出现的地址；否则，返回NULL。
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
int main()
{
char arr1[] = "hello bit";
char arr2[] = "bit";
char* ret = strstr(arr1, arr2);
if (ret == NULL)
printf("没找到\n");
else
printf("找到了：%s\n", ret);
return 0;
}
strtok
- 语法/原型：char * strtok(char *s, const char *delim);
- 功能参数：分解字符串为一组字符串。s为要分解的字符串，delim为分隔符字符串。
- 说明：strtok()用来将字符串分割成一个个片段。参数s指向欲分割的字符串，参数delim则为分割字符串中包含的所有字符。当strtok()在参数s的字符串中发现参数delim中包含的分割字符时,则会将该字符改为\0 字符。在第一次调用时，strtok()必需给予参数s字符串，往后的调用则将参数s设置成NULL。每次调用成功则返回指向被分割出片段的指针。
字符分类函数
内存操作函数
该系列函数所需头文件：#include <string.h>
memcpy
- 语法/原型：void *memcpy(void *destin, void *source, unsigned n);
- 参数说明：destin-- 指向用于存储复制内容的目标数组，类型强制转换为 void* 指针。source-- 指向要复制的数据源，类型强制转换为 void* 指针。 n-- 要被复制的字节数。
- 功能：从源source所指的内存地址的起始位置开始拷贝n个字节到目标destin所指的内存地址的起始位置中。
- 返回值: 该函数返回一个指向目标存储区destin的指针。
注：这个函数遇到'\0‘的时候并不会停下来。
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
int main()
{
char arr1[] = "abcdef";
char arr2[20] = { 0 };
memcpy(arr2, arr1, 3);//数字3的单位是字节，而一个字符占一个字节
printf("%s\n", arr2);
return 0;
}
运行结果：
memmove
- 语法/原型：void memmove( void dest, const void* src, size_t count );
- 参数说明：
- 功能:由src所指内存区域复制count个字节到dest所指内存区域。
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <string.h>
int main()
{
const char a[] = "abcdefg";
const char b[] = "1234567";
printf("a = %s,b = %s\n", a, b);
memmove(a, b, 7);
printf("a = %s,b = %s\n", a, b);
return(0);
}
memcmp
- 语法/原型：int memcmp(const void *str1, const void *str2, size_t n));
- 参数说明：str1-- 指向内存块的指针。str2-- 指向内存块的指针。n-- 要被比较的字节数。
- 功能:比较内存区域buf1和buf2的前count个字节。
- 返回值:如果返回值 < 0，则表示 str1 小于 str2。返回值 > 0，则表示 str2 小于 str1。如果返回值 = 0，则表示 str1 等于 str2。
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
int main()
{
int a[] = { 1, 2, 3 };
int b[] = { 1, 5};
int ret = memcmp(a,b, 8);//注意第3个参数的单位是字节
if (ret > 0)
{
printf("a>b\n");
}
else if (ret < 0)
{
printf("a<b\n");
}
else
{
printf("a==b\n");
}
return 0;
}
总结
本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注海外IDC网的更多内容！