字符函数和字符串函数以及内存函数
1. 字符分类函数
C语言中有一系列的函数是专门做字符分类的，也就是一个字符是属于什么类型的字符的。
- 这些函数的使用都需要包含一个头文件是 ctype.h
这些函数的使用方法非常类似，我们就讲解一个函数的使用，其他的非常类似：
- int islower ( int c ); //参数接收的是字符或ASCII码值。
- islower 是能够判断参数部分的 c 是否是小写字母的
- 通过返回值来说明是否是小写字母，如果是小写字母就返回非0的整数，如果不是小写字母，则返回0。
练习1：写一个代码，判断字符是大写，还是小写。
#include <stdio.h>
#include <ctype.h>
int main()
{
int ch = getchar();
//int ret = islower(ch);
//printf("%d\n", ret);
//if (ret)
//{
// printf("小写\n");
//}
if (islower(ch))
{
printf("小写\n");
}
else if (isupper(ch))
{
printf("大写\n");
}
return 0;
}
运行结果：
练习2：把字符串转换成全小写。
#include <stdio.h>
#include <ctype.h>
int main()
{
char arr[] = "I Am A Student";
int i = 0;
while (arr[i])
{
if (isupper(arr[i]))
{
arr[i] += 32;
}
putchar(arr[i]);
i++;
}
return 0;
}
运行结果：
2. 字符转换函数
C语言提供了2个字符转换函数：
int tolower ( int c ); //将参数传进去的大写字母转小写
int toupper ( int c ); //将参数传进去的小写字母转大写
练习： 优化把字符串转换为全小写代码
#include <stdio.h>
#include <ctype.h>
int main()
{
char arr[] = "I Am A Student";
int i = 0;
while (arr[i])
{
if (isupper(arr[i]))
{
//arr[i] += 32;
arr[i] =tolower(arr[i]);
}
putchar(arr[i]);
i++;
}
return 0;
}
运行结果：
3. strlen的使用和模拟实现
1 size_t strlen ( const char * str );
- 字符串以 ‘\0’ 作为结束标志，strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包含 ‘\0’ )。
- 参数指向的字符串必须要以 ‘\0’ 结束。
- 注意函数的返回值为size_t，是无符号的（ 易错 ）
- strlen的使用需要包含头文件
3.1 strlen的使用
代码1：
#include<stdio.h>
#include <string.h>
int main()
{
//char arr[] = "abcdef"; //[a b c d e f \0]=>长度为6
char arr[] = { 'a','b','c','\0' }; //[a b c \0] => 长度为3
size_t len = strlen(arr);
printf("%zd\n", len);
return 0;
}
运行结果：
代码2：
int main()
{
//3-6 = -3 strlen返回值的类型是无符号整型 ，无符号整型-无符号整型 =无符号整型 ，-3被当作一个无符号处理的时候它是一个非常大的整数
//size_t 表示的数字是大于等于0
if (strlen("abc") - strlen("abcdef") > 0)
{
printf("大于\n");
}
else
{
printf("小于\n");
}
return 0;
}
运行结果：
3.2strlen 的模拟实现
方式一：计数器方式
#include<stdio.h>
#include <string.h>
#include <assert.h>
size_t my_strlen(const char* str)
{
size_t count = 0;
assert(str != NULL); //保证指针的有效性 ,断言的是指针变量里面存的地址
while (*str != '\0')
{
count++;
str++;
}
return count;
}
int main()
{
char arr[] = "abcdef";
size_t len = my_strlen(arr);
printf("%zd\n", len);
return 0;
}
运行结果：
方式二：指针-指针的方式
#include<stdio.h>
#include <string.h>
#include <assert.h>
size_t my_strlen(const char* str)
{
char* start = str;
assert(str != NULL);
while (*str)
{
str++;
}
return str -start;
}
int main()
{
char arr[] = "abcdef";
size_t len = my_strlen(arr);
printf("%zd\n", len);
return 0;
}
运行结果：
方式三：写一个函数，不能使用临时变量，求字符串长度 - 递归
size_t my_strlen(const char* str)
{
if (*str == '\0')
return 0;
else
return 1 + my_strlen(str + 1);
}
int main()
{
char arr[] = "abcdef";
size_t len = my_strlen(arr);
printf("%zd\n", len);
return 0;
}
运行结果：
4. strcpy的使用和模拟实现
char* strcpy(char * destination, const char * source );
- Copies the C string pointed by source into the array pointed by destination, including the
terminating null character (and stopping at that point).
将source指向的C字符串复制到destination指向的数组中，包括结束的null字符(并在该点停止)。 - 源字符串必须以 ‘\0’ 结束
- 会将源字符串中的 ‘\0’ 拷贝到目标空间。
- 目标空间必须足够大，以确保能存放源字符串。
- 目标空间必须可修改。
- 返回类型： char *
- 返回值 ：返回的是目标空间的起始地址
- 学会模拟实现。
4.1 strcpy的使用
#include<stdio.h>
#include <string.h>
#include <assert.h>
int main()
{
char arr1[20] = { 0 };
char arr2[] = "hello";
//char arr2[]={'a','b','c','\0'};
strcpy(arr1, arr2);
printf("%s\n", arr1);
return 0;
}
运行结果：
4.2strcpy的模拟实现
#include<stdio.h>
#include <string.h>
#include <assert.h>
char* my_strcpy(char* dest, char* src)
{
char* ret = dest;
assert(dest && src);
while (*dest++ = *src++)
{
;
}
return ret;
}
int main()
{
char arr1[20] = { 0 };
char arr2[] = "helloworld";
my_strcpy(arr1, arr2);
printf("%s\n", arr1);
//printf("%s\n",my_strcpy(arr1, arr2));
return 0;
}
运行结果：
5. strcat的使用和模拟实现
char * strcat ( char * destination, const char * source );
- Appends a copy of the source string to the destination string. The terminating null character in destination is overwritten by the first character of source, and a null-character is included at the end of the new string formed by the concatenation of both in destination.
- 将源字符串的副本追加到目标字符串。destination中的结束null字符被source的第一个字符覆盖，并且在destination中由两者串联形成的新字符串的末尾包含一个空字符。
- 源字符串必须以 ‘\0’ 结束。
- 目标字符串中也得有 \0 ，否则没办法知道追加从哪里开始。
- 目标空间必须有足够的大，能容纳下源字符串的内容。
- 目标空间必须可修改。
- 返回类型：char *
- 返回值 ：返回的是目标空间的起始地址
- 字符串自己给自己追加，如何？答案是：不安全的
5.1 strcat的使用
#include<stdio.h>
#include <string.h>
#include <assert.h>
int main()
{
char arr1[20] = "hello ";
char arr2[] = "world !";
strcat(arr1, arr2);
printf("%s\n", arr1);
return 0;
}
运行结果：
5.2strcat模拟实现
#include<stdio.h>
#include <string.h>
#include <assert.h>
char* my_strcat(char* dest, const char* src)
{
char* ret = dest;
assert(dest && src);
//1. 找到目标空间的\0
while (*dest)
{
dest++;
}
//2. 拷贝源头字符串的数据到目标空间的\0位置及后面空间
while (*dest++ = *src++)
{
;
}
return ret;
}
int main()
{
char arr1[20] = "hello ";
char arr2[] = "world !";
my_strcat(arr1, arr2);
printf("%s\n", arr1);
return 0;
}
运行结果：
字符串自己给自己追加：
char* my_strcat(char* dest, const char* src)
{
char* ret = dest;
assert(dest && src);
//1. 找到目标空间的\0
while (*dest)
{
dest++;
}
//2. 拷贝
while (*dest++ = *src++)
{
;
}
return ret;
}
int main()
{
char arr1[20] = "hello ";
my_strcat(arr1, arr1);
printf("%s\n", arr1);
return 0;
}
运行结果：
字符串自己给自己追加时，因为\0 一开始被覆盖掉了，src 找不到\0, 就会拼命的往后找，就会一直把src里面的字符串向后追加，就会导致死循环，而且会导致越界访问。
6. strcmp的使用和模拟实现
int strcmp ( const char * str1, const char * str2 );
- This function starts comparing the first character of each string. If they are equal to each other, it continues with the following pairs until the characters differ or until a terminating null-character is reached.
- 这个函数开始比较每个字符串的第一个字符。如果它们彼此相等，则继续执行以下对，直到字符不同或达到终止空字符为止。
- 第一个字符串大于第二个字符串，则返回大于0的数字
- 第一个字符串等于第二个字符串，则返回0
- 第一个字符串小于第二个字符串，则返回小于0的数字
- 那么如何判断两个字符串？ 比较两个字符串中对应位置上字符ASCII码值的大小。
6.1 strcmp的使用
#include<stdio.h>
#include <string.h>
int main()
{
int ret = strcmp("bbq", "abcdef");
printf("%d\n", ret);
return 0;
}
运行结果：
6.2 strcmp模拟实现
#include<stdio.h>
#include <string.h>
#include <assert.h>
int my_strcmp(const char* s1, const char* s2)
{
while (*s1 == *s2)
{
if (*s1 == '\0')
return 0;
s1++;
s2++;
}
return *s1 - *s2;
}
int main()
{
int ret = my_strcmp("abcdef", "abc");
if (ret > 0)
printf("大于\n");
else if (ret == 0)
printf("等于\n");
else
printf("小于\n");
return 0;
}
运行结果：
7. strncpy函数的使用
char * strncpy ( char * destination, const char * source, size_t num );
- Copies the first num characters of source to destination. If the end of the source C string (which is signaled by a null-character) is found before num characters have been copied, destination is padded with zeros until a total of num characters have been written to it.
- 将源的第一个num字符复制到目标。如果在复制num个字符之前找到源C字符串的结尾(用空字符表示)，则目的地将用零填充，直到向其写入总数为num个字符。
- 拷贝num个字符从源字符串到目标空间。
- 如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。
#include<stdio.h>
#include <string.h>
int main()
{
char arr1[20] = "XXXXXXXX";
char arr2[] = "hello";
strncpy(arr1, arr2, 7); //num : 从源头字符串拷贝num个字符到目标空间里，不够就补\0
printf("%s\n", arr1);
return 0;
}
调试过程：
运行结果：
8. strncat函数的使用
char * strncat ( char * destination, const char * source, size_t num );
- Appends the first num characters of source to destination, plus a terminating null-character.
（将source指向字符串的前num个字符追加到destination指向的字符串末尾，再追加一个 \0 字符） - If the length of the C string in source is less than num, only the content up to the terminating null-character is copied.（如果source 指向的字符串的长度小于num的时候，只会将字符串中到\0 的内容追加到destination指向的字符串末尾）。
代码1：
#include<stdio.h>
#include <string.h>
int main()
{
char arr1[20] = "hello\0xxxxxxxxxxx";
char arr2[] = "world";
strncat(arr1, arr2, 4);
//printf("%s\n", arr1);
return 0;
}
调试过程：
运行结果：
代码2：
#include<stdio.h>
#include <string.h>
int main()
{
char arr1[20] = "hello\0xxxxxxxxxxx";
char arr2[] = "world";
strncat(arr1, arr2, 7);
//printf("%s\n", arr1);
return 0;
}
调试过程：
运行结果：
代码三：
#include<stdio.h>
#include <string.h>
int main()
{
char arr1[20] = "hello";
char arr2[] = "world";
strncat(arr1, arr2, 4);
printf("%s\n", arr1);
return 0;
}
运行结果:
9. strncmp函数的使用
int strncmp ( const char * str1, const char * str2, size_t num );
- 比较str1和str2的前num个字符，如果相等就继续往后比较，最多比较num个字母，如果提前发现不一样，就提前结束，大的字符所在的字符串大于另外一个。如果num个字符都相等，就是相等返回0.
#include<stdio.h>
#include <string.h>
int main()
{
char arr1[] = "abcdef";
char arr2[] = "abcq";
int ret = strncmp(arr1, arr2, 4);
printf("%d\n", ret);
return 0;
}
运行结果：
总结：
10. strstr的使用和模拟实现
1 char * strstr ( const char * str1, const char * str2);
- Returns a pointer to the first occurrence of str2 in str1, or a null pointer if str2 is not part of str1.（函数返回字符串str2在字符串str1中第一次出现的位置）。
- The matching process does not include the terminating null-characters, but it stops there.（字符串的比较匹配不包含 \0 字符，以 \0 作为结束标志）。
10.1 strstr的使用
#include<stdio.h>
#include <string.h>
int main()
{
char arr1[] = "abcdefabcdef";
char arr2[] = "def";
char* ret = strstr(arr1, arr2);
if (ret != NULL)
printf("%s\n", ret);
else
printf("找不到\n");
return 0;
}
运行结果：
10.2 strstr模拟实现
//测试用例1
//abcdef
//cde
//测试用例2
//abcdef
//cbq
//测试用例3
//abbbcdef
//bbc
//测试用例4
//abcdef
//abcdef
暴力求解法：
#include<stdio.h>
#include <string.h>
#include <assert.h>
char* my_strstr(const char* str1, const char* str2)
{
const char* cur = str1;
const char* s1 = NULL;
const char* s2 = NULL;
assert(str1 && str2);
if (*str2 == '\0') //str2是个空字符串
{
return (char*)str1;
}
while (*cur)
{
s1 = cur;
s2 = str2;
while (*s1 && *s2 && *s1 == *s2)
{
s1++;
s2++;
}
if (*s2 == '\0')
{
return (char*)cur;
}
cur++;
}
return NULL; //找不到就返回空指针
}
int main()
{
char arr1[] = "abbbcdef";
char arr2[] = "bbc";
char* ret = my_strstr(arr1, arr2); //函数返回值的类型是起始地址或者空指针
if (ret != NULL)
printf("%s\n", ret);
else
printf("找不到\n");
return 0;
}
运行结果：
11. strtok函数的使用
char * strtok ( char * str, const char * sep);
- sep参数指向一个字符串，定义了用作分隔符的字符集合
- 第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。
- strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针（起始地址）。（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
- strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
- strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
- 如果字符串中不存在更多的标记，则返回 NULL 指针。
图示1：
图示2：
图示3：
代码测试：
#include<string.h>
#include <stdio.h>
int main()
{
char arr[] = "zhangsan@163.com#hehe";
char arr2[30] = {0}; //zhangsan\0163\0com
strcpy(arr2, arr);
const char* p = "@.#";
char* s = NULL;
// 初始化部分只执行一次
for (s = strtok(arr2, p); s != NULL; s=strtok(NULL, p)) //s !=NULL,说明s 确实指向了第一个字段
{
printf("%s\n", s);
}
//char *s = strtok(arr2, p); //返回标记的起始地址
//printf("%s\n", s);
//s = strtok(NULL, p);
//printf("%s\n", s);
//s = strtok(NULL, p);
//printf("%s\n", s);
return 0;
}
运行结果：
12. strerror函数的使用
char * strerror ( int errnum );
- strerror函数可以把参数部分错误码对应的错误信息的字符串地址返回来。
- 在不同的系统和C语言标准库的实现中都规定了一些错误码，一般是放在 errno.h 这个头文件中说明的，C语言程序启动的时候就会使用一个全局的变量errno来记录程序的当前错误码，只不过程序启动的时候errno是0，表示没有错误，当我们在使用标准库中的函数的时候发生了某种错误，就会将对应的错误码，存放在errno中，而一个错误码的数字是整数很难理解是什么意思，所以每一个错误码都是有对应的错误信息的。strerror函数就可以将错误对应的错误信息字符串的地址返回。
#include <stdio.h>
#include <string.h>
#include <errno.h>
int main()
{
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d: %s\n",i, strerror(i));
}
return 0;
}
运行结果：
用法：
一旦打开失败就会有一个错误码的信息放进errno里面去
#include <stdio.h>
#include <string.h>
#include <errno.h>
int main()
{
FILE* pFile;
pFile = fopen("unexist.txt", "r"); //这个文件不存在，以读的形式打开，一旦打开失败就会有一个错误码的信息放进errno里面去
if (pFile == NULL)
printf("Error opening file unexist.ent: %s\n", strerror(errno)); //把这个错误码对应的错误信息打印出来
else
printf("打开文件成功\n");
return 0;
}
运行结果：
- 也可以了解一下perror函数，直接将错误信息打印出来。perror函数打印完参数部分的字符串后，再打印一个冒号和一个空格，再打印错误信息。
代码测试：
#include <stdio.h>
#include <string.h>
#include <errno.h>
int main()
{
FILE* pFile;
pFile = fopen("unexist.ent", "r");
if (pFile == NULL)
//printf("Error opening file unexist.ent: %s\n", strerror(errno));
perror("Error opening file unexist.ent");
return 0;
}
运行结果：
13. memcpy使用和模拟实现
void * memcpy ( void * destination, const void * source, size_t num );
- 函数memcpy从source的位置开始向后复制num个字节的数据到destination指向的内存位置。
- 这个函数在遇到 ‘\0’ 的时候并不会停下来。
- 如果source和destination有任何的重叠，复制的结果都是未定义的。
- 直接把source 里面的数据拷贝到destination 里面去，拷贝num 个字节
- 返回的是目标起始空间的地址
13.1 memcpy 的使用
拷贝整形数组 代码1：
#include <stdio.h>
#include <string.h>
int main()
{
int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2[10] = {0};
//将arr1中的1 2 3 4 5，拷贝到arr2中
memcpy(arr2, arr1, 5*sizeof(int));
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", arr2[i]);
}
return 0;
}
运行结果：
代码2：
#include <stdio.h>
#include <string.h>
int main()
{
int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2[10] = { 0 };
//将arr1中的4 5 6 7 8，拷贝到arr2中
memcpy(arr2, arr1+3, 5 * sizeof(int));
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", arr2[i]);
}
return 0;
}
运行结果：
拷贝字符数组 代码如下：
#include <stdio.h>
#include <string.h>
int main()
{
char arr1[10] = "he\0lo bit";
char arr2[10] = { 0 };
memcpy(arr2, arr1, 5);
int i = 0;
for (i = 0; i < 5; i++)
{
printf("%c ", arr2[i]);
}
return 0;
}
运行结果：
13.2 memcpy的模拟实现
#include <stdio.h>
#include <string.h>
#include <assert.h>
void* my_memcpy(void* dest, const void* src, size_t num)
{
void* ret = dest;
assert(dest && src);
while (num--) //先使用后--
{
*(char*)dest = *(char*)src; //强制类型转换是临时的效果
dest = (char*)dest+1;
src = (char*)src + 1;
}
return ret;
}
int main()
{
int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2[10] = { 0 };
//将arr1中的4 5 6 7 8，拷贝到arr2中
my_memcpy(arr2, arr1+3, 5 * sizeof(int));
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", arr2[i]);
}
return 0;
}
运行结果：
14. memmove使用和模拟实现
void * memmove ( void * destination, const void * source, size_t num );
- 和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
- 如果源空间和目标空间出现重叠，就得使用memmove函数处理。
14.1memmove的使用
#include <stdio.h>
#include <string.h>
int main()
{
int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
memmove(arr1+2, arr1, 5 * sizeof(int));
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", arr1[i]);
}
return 0;
}
运行结果：
14.2 memmove的模拟实现
#include <stdio.h>
#include <string.h>
#include <assert.h>
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;
}
int main()
{
int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
my_memmove(arr1+2, arr1, 5 * sizeof(int));
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", arr1[i]);
}
return 0;
}
运行结果：
15. memset函数的使用
void * memset ( void * ptr, int value, size_t num );
- memset是用来设置内存的，将内存中的值以字节为单位设置成想要的内容。
- 将ptr指向的内存块的前num个字节设置为指定的值(解释为unsigned char)。
#include <stdio.h>
#include <string.h>
int main()
{
char arr[15] = "hello world";
memset(arr, 'x', 5);
//memset 在设置的时候，是以字节为单位来设置的
//
printf("%s\n", arr);
return 0;
}
运行结果：
16. memcmp函数的使用
int memcmp ( const void * ptr1, const void * ptr2, size_t num );
- 比较从ptr1和ptr2指针指向的位置开始，向后的num个字节
返回值：
代码测试：
#include <stdio.h>
#include <string.h>
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2[] = { 1,2,3,4,8 };
int ret = memcmp(arr1, arr2, 17);
printf("%d\n", ret);
return 0;
}
运行结果：
完
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
