目录
1、求字符串长度
-
strlen
size_t strlen ( const char * str );
strlen
是一个库函数,用于计算给定字符串的长度。它是在<string.h>
头文件中定义的。strlen
函数接受一个指向字符数组的指针(一个字符串)作为参数,并返回一个size_t
类型的值,表示字符串的长度(不包括终止的null字符)。
例子:
#include <stdio.h>
#include <string.h>
int main ()
{
char szInput[256];
printf ("Enter a sentence: ");
gets (szInput);
printf ("The sentence entered is %u characters long.\n",(unsigned)strlen(szInput));
return 0;
}
返回结果:
模拟实现:
size_t my_strlen(const char* str)
{
int count = 0;
while (*str++) {
count++;
}
return count;
}
int main()
{
size_t sz = my_strlen("aasaad");
printf("%d\n", sz);
return 0;
}
2、长度不受限制的字符串函数
-
strcpy
char *strcpy(char *dest, const char *src);
strcpy
是一个库函数,用于复制一个字符串到另一个字符串。它是在<string.h>
头文件中定义的。strcpy
函数接受两个参数:一个目标字符数组的指针和一个源字符串的指针。它将源字符串复制到目标字符数组,并返回目标字符数组的指针。
注意!!!
- 源字符串必须以 '\0' 结束。
- 会将源字符串中的 '\0' 拷贝到目标空间。
- 目标空间必须足够大,以确保能存放源字符串。
- 目标空间必须可变。
例子:
#include <stdio.h>
#include <string.h>
int main() {
char source[] = "Hello, World!";
char destination[50];
strcpy(destination, source);
printf("Source: %s\n", source);
printf("Destination: %s\n", destination);
return 0;
}
模拟实现:
char* my_strcpy(char* dest, char* src)
{
char* ret = dest;
while (*dest++ = *src++);
return ret;
}
-
strcat
char *strcat(char *dest, const char *src);
strcat是一个库函数,用于将一个字符串追加到另一个字符串的末尾,它是在 <string.h>头文件中定义的,strcat接受两个参数,一个目标字符数组的指针和一个源字符串的指针,他将源字符串追加到目标字符串数组的末尾,并返回目标字符数组的字符。
#include <stdio.h>
#include <string.h>
int main() {
char destination[50] = "Hello";
char source[] = ", World!";
strcat(destination, source);
printf("Combined string: %s\n", destination);
return 0;
}
- 源字符串必须以 '\0' 结束。
- 目标空间必须有足够的大,能容纳下源字符串的内容。
- 目标空间必须可修改。
模拟实现:
char* my_strcat(char* dest, char* src)
{
assert(dest && src);
char* ret = dest;
while (*dest)
dest++;
while (*dest++ = *src++);
return ret;
}
如果用模拟函数,不能自己追加自己,由于目标字符串数组和源字符串数组相同,即在第一个while循环之后,dest指向字符串最后一位 ' \0 ',而src等于dest也指向字符串最后一位 ' \0 ',所以在第二个while循环中无法进行追加。
如果用字符串函数strcat是可以自己追加自己的,只要目标空间足够大。
这里的assert确保了以下两点:
dest
不是NULL
。src
不是NULL
。如果任何一个条件不满足(即,如果
dest
或src
是NULL
),assert
将触发一个错误消息并终止程序。这是为了防止后续的代码在无效的指针上操作,从而可能导致未定义的行为或程序崩溃。
-
assert :
- 在C编程中,
assert
是一个宏,用于在程序中设置断言如果断言失败(即表达式为false
),assert
会调用一个错误处理例程,并通常终止程序执行。assert
宏用于确保传递给函数的两个字符串指针dest
和src
都不是NULL
。assert
宏在<assert.h>
头文件中定义。
-
strcmp
int strcmp(const char *str1, const char *str2);
strcmp
)是一个库函数,用于比较两个字符串。这个函数是在<string.h>
头文件中定义的。strcmp
函数接受两个字符串(字符指针)作为参数,并返回一个整数来表示这两个字符串的相对顺序。
- 第一个字符串大于第二个字符串,则返回大于0的数字
- 第一个字符串等于第二个字符串,则返回0
- 第一个字符串小于第二个字符串,则返回小于0的数字
int my_strcmp(const char* str1, const char* str2)
{
assert(str1 && str2);
while (*str1 == *str2) {
if (*str1 == '\0')
return 0;
str1++;
str2++;
}
return *str1 - *str2;
}
int main()
{
int ret = my_strcmp("bbq", "bbb");
if (ret > 0)
printf("大于\n");
else if (ret < 0)
printf("小于\n");
else
printf("等于\n");
return 0;
}
模拟实现:
int my_strcmp(const char* str1, const char* str2)
{
assert(str1 && str2);
while (*str1 == *str2) {
if (*str1 == '\0')
return 0;
str1++;
str2++;
}
return *str1 - *str2;
}
3、长度受限制的字符串函数介绍
-
strncpy
char * strncpy ( char * destination, const char * source, size_t num );
- 拷贝num个字符从源字符串到目标空间。
- 如果源字符串的长度小于num,则拷贝完源字符串之后,在目标的后边追加0,直到num个。
#include <stdio.h>
#include <string.h>
int main()
{
char str1[20];
char str2[20];
strcpy(str1, "To be ");
strcpy(str2, "or not to be");
strncpy(str2, str1, 10);
puts(str2);
return 0;
}
在这个程序中,strncpy
函数用于将 str1
中的内容复制到 str2
中,但最多只复制 10 个字符。
虽然输出结果是 ,但后面超过字符串长度的部分被赋值为\0。
-
strncat
char * strncat ( char * destination, const char * source, size_t num );
- 将源字符的 第一个字符 到 第num字符追加到目标空间末尾,再加上一个终止的空字符 ’ \0 ' 。
- 如果源字符中的C字符串的长度小于num,则只复制直到终止的空字符的内容。
-
strncmp
- int strncmp ( const char * str1, const char * str2, size_t num );
- strncmp用于比较两个字符串的前
num
个字符。
4、字符串查找
-
strstr
char * strstr ( const char *str1, const char * str2);
- strstr 返回一个指向str1中第一次出现的str2的指针
- 如果str2不是str1的一部分,则返回一个空指针。
下面我们来看两个例子:
#include <stdio.h>
#include <string.h>
int main()
{
char str[] = "This is a simple string";
char* pch;
pch = strstr(str, "simple");
printf("%s\n", pch);
strncpy(pch, "sample", 6);
puts(str);
return 0;
}
输出结果:
#include <stdio.h>
#include <string.h>
int main()
{
char str[] = "This is a simple string";
char* pch;
pch = strstr(str, "smple");
printf("%s\n", pch);
return 0;
}
输出结果:
模拟实现:
char* my_strstr(char* str1, char* str2)
{
char* s1 = str1;
char* cp = str1;
char* s2 = str2;
if (*str2 == '\0')
return str1;
while (*cp) {
s1 = cp;
s2 = str2;
while (*s1 == *s2 && *s1 && *s2) {
s1++;
s2++;
}
if (*s2 == '\0')
return cp;
cp++;
}
return NULL;
}
int main()
{
char arr1[] = "abbbcdef";
char arr2[] = "bbc";
return 0;
}
-
strtok
char * strtok ( char * str, const char * sep );
- sep参数是个字符串,定义了用作分隔符的字符集合
- 第一个参数指定一个字符串,它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。
- strtok函数找到str中的下一个标记,并将其用 \0 结尾,返回一个指向这个标记的指针。(注: strtok函数会改变被操作的字符串,所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。)
- strtok函数的第一个参数不为 NULL ,函数将找到str中第一个标记,strtok函数将保存它在字符串中的位置。
- strtok函数的第一个参数为 NULL ,函数将在同一个字符串中被保存的位置开始,查找下一个标记。
- 如果字符串中不存在更多的标记,则返回 NULL 指针。
#include <stdio.h>
#include <string.h>
int main()
{
char arr[] = "[email protected]@666#777";
char copy[30];
strcpy(copy, arr);
char sep[] = "@.#";
char* ret = NULL;
for (ret = strtok(copy, sep); ret != NULL; ret = strtok(NULL, sep))
{
printf("%s\n", ret);
}
return 0;
}
5、错误信息报告
-
strerror
char * strerror ( int errnum );
当库函数在执行的时候发生了错误,会将一个错误码存放在errno这个变量中,errno是C语言提供的一个全局变量。输入错误码,所对应的错误信息。
int main()
{
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d: %s\n", i, strerror(i));//
}
return 0;
}
strerror到底有什么用呢?
int main()
{
//C语言中可以操作文件
//操作文件的步骤
//1. 打开文件
//2. 读/写
//3. 关闭文件
FILE* pf = fopen("data.txt", "r");
if (pf == NULL)
{
printf("fopen: %s\n", strerror(errno));
//通过错误码知道打印失败的原因。
perror("fopen");
return 1;
}
//读文件
//...
//关闭文件
fclose(pf);
return 0;
}
可以将 printf("fopen: %s\n", strerror(errno)); 换成 perror("fopen"); ,他们输出结果相同。
perror功能更强大,它先打印fopen: 加上错误信息。
结果如下:
6、字符分类函数
需要包含 #include <ctype.h>头文件。
int main()
{
printf("%d\n", isupper('a'));
printf("%d\n", isdigit('2'));
printf("%c\n", tolower('A'));
printf("%c\n", tolower('s'));
return 0;
}
输出结果:
int main()
{
char arr[20] = { 0 };
gets(arr);//遇到空格继续读
char* p = arr;
while (*p)
{
if (isupper(*p))// *p>='A' && *p<='Z'
{
*p = tolower(*p);//*p = *p+32;
}
p++;
}
printf("%s\n", arr);
return 0;
}
输出结果:
7、字符操作—内存操作函数:
-
memcpy
void * memcpy ( void * destination, const void * source, size_t num );
- 函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
- 这个函数在遇到 '\0' 的时候并不会停下来。
- 如果source和destination有任何的重叠,复制的结果都是未定义的。
- 函数拷贝结束后,返回目标空间的起始地址。
- 我们看下面的例子就明白了
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2[20] = { 0 };
memcpy(arr2, arr1, 40);
for (int i = 0; i < 20; i++)
printf("%d ", arr2[i]);
return 0;
}
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2[20] = { 0 };
float arr3[] = { 1.0,2.0,3.0 };
float arr4[5] = { 0 };
memcpy(arr2, arr1, 40);
memcpy(arr4, arr3, 8);//8个字节:拷贝两个元素
for (int i = 0; i < 20; i++)
printf("%d ", arr2[i]);
printf("\n");
for (int i = 0; i < 5; i++)
printf("%f ", arr4[i]);
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;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
return ret;
}
- 不能拷贝负数个元素,所以定义为无符号整型size_t类型不能拷贝负数个元素,所以定义为无符号整型size_t类型 。
- 不能转换为(int*)类型,因为传入其他类型则无法实现函数功能,比如num如果是7,意味着函数要7个字节,而int*类型加一拷贝四个字节,所以转换成(char*)类型,每次加一拷贝一个字节,拷贝七次从而完美解决上述问题。
- 不能写成(char*)dest++,强制转换是临时的。
注意!!!memcpy不能自己任何位置拷贝自己任何位置。
如果source和destination有任何的重叠,复制的结果都是未定义的。
这时我们可以用memmove函数。
-
memmove
void * memmove ( void * destination, const void * source, size_t num );
- 和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
- 如果源空间和目标空间出现重叠,就得使用memmove函数处理。
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
memmove(arr1, arr1+2, 20);
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", arr1[i]);
}
return 0;
}
模拟实现:
void* my_memmove(void* dest, const void* src, size_t num)
{
void* ret = dest;
assert(dest && src);
if (dest < src) {
while (num--) {
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
}
else {
while (num--) {
*((char*)dest + num) = *((char*)src + num);
}
}
return ret;
}
首先我们要考虑三种情况,他们分别对应不同的拷贝模式,dest位于src前面时,将src对应位置的值从前往后复制给dest对应位置,这样不会造成src的值尚未复制给dest就被改变。同理第二种和第三种也一样。
第三种情况从前向后和从后向前都可以,我们就选择与第二种情况相同方式从后向前,这样判断拷贝方式只有两种情况了。
输出结果:
- memcpy 只要实现了不重叠拷贝就行
- 但vs 上memcpy 函数实现了重叠拷贝
- 重叠的内存拷贝还是交给memmove来做
- memmove 当然也可以拷贝不重叠的拷贝
-
memcmp
int memcmp ( const void * ptr1, const void * ptr2, size_t num );比较从ptr1和ptr2指针开始的num个字节返回值如下:
int main()
{
int arr1[] = { 1,2,1,4,5,6 };
int arr2[] = { 1,2,257 };
int ret = memcmp(arr1, arr2, 10);
printf("%d\n", ret);
return 0;
}
输出结果:
memset
void * memset ( void * ptr, int value, size_t num )把ptr指向的前num个字节设置成我们想要的value值
int main()
{
char arr[] = "hello bit";
memset(arr+1,'x',4);
printf("%s\n", arr);
return 0;
}
以字节为单位设置的,从arr+1开始的四个字节赋成'x'.
输出结果:
我们看下面例子的结果就理解memset以字节为单位设置了:
int main()
{
int arr[10] = { 0 };
memset(arr, 1, 40);
return 0;
}
好的,字符串函数和内存函数到此就介绍完了,希望这篇文章 可以帮你回忆曾经所学过的知识 。