05网寒假作业答案百度优化是什么意思
目录
前言：
1.求字符串长度
strlen
注：
模拟实现strlen：
1.计数器
2.不创建临时变量的计数器
3.指针-指针
2.长度不受限制的字符串函数
strcpy
注：
模拟 strcpy函数
strcat
注：
模拟strcat函数
strcmp
注：
编辑
模拟strcmp函数:
3.长度受限制的字符串函数
strncpy
注:
strncat
strncmp
4.字符串查找
strstr
模拟strstr：
strtok
注：
错误信息报告
strerror
内存操作函数
memcpy
模拟memcpy函数：
memmove
注：
模拟memmove函数：
memcmp
注：
前言：
C语言中对字符和字符串的处理很是频繁，但是C语言本身是没有字符串类型的，字符串通常放在 常量字符串 中或者 字符数组 中。字符串常量 适用于那些对它不做修改的字符串函数。
查询字符串函数的详细信息：cplusplus.com - The C++ Resources Network
https://legacy.cplusplus.com/
1.求字符串长度
strlen
size_t strlen ( const char * str );
注：
- 字符串已经 '\0' 作为结束标志，strlen函数返回的是在字符串中 '\0' 前面出现的字符个数（不包 含 '\0' )。
- 参数指向的字符串必须要以 '\0' 结束。
- ☆ 注意函数的返回值为size_t，是无符号的。 ☆
#include <stdio.h>int main()
{const char*str1 = "abcdef"; // 6const char*str2 = "abc"; // 3if(strlen(str2)-strlen(str1)>0){printf("str2>str1\n");} else{printf("srt1>str2\n");}return 0;
}模拟实现strlen：
1.计数器
int my_strlen(const char * str)
{int count = 0;while(*str){count++;str++;}return count;
}2.不创建临时变量的计数器
int my_strlen(const char * str)
{if(*str == '\0')return 0;elsereturn 1+my_strlen(str+1);
}3.指针-指针
int my_strlen(char *s)
{char *p = s;while(*p != ‘\0’ )p++;return p-s;
}2.长度不受限制的字符串函数
strcpy
char* strcpy ( char * destination , const char * source );
注：
- 源字符串必须以 '\0' 结束。
- 会将源字符串中的 '\0' 拷贝到目标空间。
- 目标空间必须足够大，以确保能存放源字符串。
- 目标空间必须可变。
注意 \0 的位置 和监视中显示的结果。
模拟 strcpy函数
char *my_strcpy(char *dest, const char*src)
{ char *ret = dest;assert(dest != NULL);assert(src != NULL);while((*dest++ = *src++)){;}return ret;
}strcat
char * strcat ( char * destination, const char * source );
注：
- 源字符串必须以 '\0' 结束。
- 目标空间必须有足够的大，能容纳下源字符串的内容。
- 目标空间必须可修改。
模拟strcat函数
char *my_strcat(char *dest, const char*src)
{char *ret = dest;assert(dest != NULL);assert(src != NULL);
//assert(dest && src)while(*dest) //找目标空间的\0{dest++;}while((*dest++ = *src++)) //追加{;}return ret;
}strcmp
int strcmp ( const char * str1, const char * str2 );
注：
- 两个字符串对比的是ASCLL值，不是比较字符串的长度.
- 第一个字符串大于第二个字符串，则返回大于0的数字.
- 第一个字符串等于第二个字符串，则返回0.
- 第一个字符串小于第二个字符串，则返回小于0的数字.
(在vs环境下:
//> 1 // < -1 // = 0)
模拟strcmp函数:
int my_strcmp (const char * src, const char * dst)
{int ret = 0 ;assert(src != NULL);assert(dest != NULL);while( ! (ret = *(unsigned char *)src - *(unsigned char *)dst) && *dst)++src, ++dst;if ( ret < 0 )ret = -1 ;else if ( ret > 0 )ret = 1 ;return( ret );
}3.长度受限制的字符串函数
strncpy
char * strncpy ( char * destination, const char * source, size_t num );
注:
- 拷贝num个字符从源字符串到目标空间。
- 如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。
strncat
char * strncat ( char * destination, const char * source, size_t num );
strncmp
int strncmp ( const char * str1, const char * str2, size_t num );
4.字符串查找
strstr
char * strstr ( const char *str1, const char * str2);
模拟strstr：
char * strstr (const char * str1, const char * str2)
{char *cp = (char *) str1;char *s1, *s2;if ( !*str2 )return((char *)str1);while (*cp){s1 = cp;s2 = (char *) str2;while ( *s1 && *s2 && !(*s1-*s2) )s1++, s2++;if (!*s2)return(cp);cp++;}return(NULL);
}strtok
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[] = "xiaoming@163.com";const char* p = "@ .";char str[20] = { 0 };strcpy(str, arr);char* ret = NULL;for (ret = strtok(str, p); ret != NULL; ret = strtok(NULL, p)){printf("%s\n", ret);}
return 0;
}
错误信息报告
strerror
char * strerror ( int errnum );
在C语言库函数运行的时候，如果发生错误，就会将错误码存在一个变量中，这个变量就是errno。
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<string.h>
#include<errno.h> //errno的头文件
int main()
{FILE* pf=fopen("text.txt", "r"); //fopen()打开文件 ，r只读if (pf == NULL){printf("%s\n", strerror(errno)); //打印错误信息}return 0;
} 结果：
很明显说明没有这个文件！！
内存操作函数
memcpy
void * memcpy ( void * destination, const void * source, size_t num );
strcpy是拷贝字符串，不能拷贝整型数组这种，所以用memcpy！
int main()
{int arr1[20]={1,2,3,4,5,6,7,8};int arr2[20]={0};
memcpy(arr2,arr1,20); //把arr1中的前20个字节拷进arr2中，结果显示arr2[20]={1,2,3,4,5};
return 0;
//如果想从2开始拷贝，就 memcpy(arr2,arr1+2,20);
}模拟memcpy函数：
void * memcpy ( void * dst, const void * src, size_t count)
{void * ret = dst;assert(dst);assert(src);/** copy from lower addresses to higher addresses*/while (count--) {*(char *)dst = *(char *)src;dst = (char *)dst + 1;src = (char *)src + 1;}return(ret);
}memmove
void * memmove ( void * destination, const void * source, size_t num );
注：
- 和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
- 如果源空间和目标空间出现重叠，就得使用memmove函数处理。
通过监视，可以看到把arr1+2的后20个字节覆盖到arr1里面去，就是把3，4，5，6，7覆盖到arrr1里面就变成：3，4，5，6，7，6，7
模拟memmove函数：
void * memmove ( void * dst, const void * src, size_t count)
{void * ret = dst;if (dst <= src || (char *)dst >= ((char *)src + count)) {/** Non-Overlapping Buffers
* copy from lower addresses to higher addresses*/while (count--) {*(char *)dst = *(char *)src;dst = (char *)dst + 1;src = (char *)src + 1;}
//从前-->后}else {/** Overlapping Buffers* copy from higher addresses to lower addresses*/dst = (char *)dst + count - 1;src = (char *)src + count - 1;while (count--) {*(char *)dst = *(char *)src;dst = (char *)dst - 1;src = (char *)src - 1;}}return(ret);
}memcmp
int memcmp ( const void * ptr1 , const void * ptr2 , size_t num );
比较从ptr1和ptr2指针开始的num个字节！
注：
- 第一个字符串大于第二个字符串，则返回大于0的数字.
- 第一个字符串等于第二个字符串，则返回0.
- 第一个字符串小于第二个字符串，则返回小于0的数字.
int main()
{int arr1[]={1,2,3}; //01 00 00 00 02 00 00 00 00 03 00 00 00int arr2[]={1,2,5}; //01 00 00 00 02 00 00 00 00 05 00 00 00
memcmp(arr1,arr2,9);
}结果是-1。