字符串函数和内存函数
strlen
size_t strlen ( const char * str );
- 字符串以’\0’作为结束标志，strlen函数返回在字符串中’\0’之前出现的字符个数（不包含’\0’）
- 参数指向的字符串必须以’\0’结束
- 返回值是size_t（无符号整型）
模拟实现strlen
#include <stdio.h>
#include <assert.h>
//1.计数器方式
size_t my_strlen1(const char* str)
{
int count = 0;
while (*str!='\0')
{
count++;
str++;
}
return count;
}
//2.指针-指针方式
size_t my_strlen2(const char* str)
{
const char* p = str;
while (*p != '\0')
{
p++;
}
return p - str;
}
//3.递归方式
size_t my_strlen3(const char* str)
{
if (*str == '\0')
return 0;
else
return 1 + my_strlen3(str + 1);
}
int main()
{
size_t sz1 = my_strlen1("abc");
size_t sz2 = my_strlen2("abc");
size_t sz3 = my_strlen3("abc");
printf("%u\n", sz1);
printf("%u\n", sz2);
printf("%u\n", sz3);
}
strcpy
char * strcpy ( char * destination, const char * source );
- 将src指向的空间的字符串拷贝到dst处，包括’\0’
- 源字符串必须包含’\0’
- dst指向的空间必须足够大，确保能放src字符串
- dst空间必须可变
模拟实现strcpy
#include <stdio.h>
#include <assert.h>
//1.方式1
char* my_strcpy1(char* dst, const char* src)
{
//assert(dst != NULL);
//assert(src != NULL);
assert(dst && src);
char* p = dst;
while (*dst!='\0')
{
*dst = *src;
dst++;
src++;
}
*dst = *src;
return p;
}
//1.方式2
char* my_strcpy2(char* dst, const char* src)
{
//assert(dst != NULL);
//assert(src != NULL);
assert(dst && src);
char* p = dst;
while (*dst++ = *src++)
{
}
return p;
}
int main()
{
char arr1[20] = "xxxxxxxxxxx";
char arr2[] = "------";
char arr3[20] = "***********";
char arr4[] = "^^^^^^";
char* p1 = my_strcpy1(arr1, arr2);
char* p2 = my_strcpy2(arr3, arr4);
printf("%s\n", p1);
printf("%s\n", p2);
return 0;
}
strcat
char * strcat ( char * destination, const char * source );
- 将src指向的字符串追加到dst指向的空间
- 源字符串和dst指向的字符串以’\0’结尾
- 目标空间必须足够大
- 目标空间可修改
模拟实现strcat
#include <stdio.h>
#include <assert.h>
char* my_strcat1(char* dst, const char* src)
{
assert(dst && src);
char* p = dst;
while (*dst)
dst++;
while (*dst++ = *src++)//超出了范围，但我没有使用
{
}
return p;
}
int main()
{
char arr1[20] = "123";
char arr2[] = "456";
my_strcat1(arr1, arr2);
printf("%s\n", arr1);
return 0;
}
strcmp
int strcmp ( const char * str1, const char * str2 );
- 比较两个字符串的大小，只要同位置，有一个大则该字符串大，比如"abc"和"aa"，就是后者大
- 第一个字符串大于第二个字符串返回大于0的数字，小于则返回小于0的数字，等于返回0
模拟实现strcmp
#include <stdio.h>
#include <assert.h>
int my_strcmp(const char* p1, const char* p2)
{
assert(p1 && p2);
while (*p1 == *p2)
{
if (*p1 == '\0')
return 0;
p1++;
p2++;
}
return (*p1 - *p2);
//if (*p1 > *p2)
// return 1;
//else
// return -1;
}
int main()
{
char arr1[] = "abcd";
char arr2[] = "abc";
int ret = my_strcmp(arr1, arr2);
printf("%d\n", ret);
return 0;
}
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 );
- 追加指定num数量的字符到目标空间
- 先找到目标空间的’\0’，然后覆盖’\0’后，再追加
- 如果源字符的空间长度小于num，则拷贝完源字符串后，在后面追加一个0
strncmp
int strncmp ( const char * str1, const char * str2, size_t num );
- 比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完
- 如果大于返回大于0的数字，小于返回小于0的数字，等于返回0
strstr
const char * strstr ( const char * str1, const char * str2 ); char * strstr ( char * str1, const char * str2 );
- 返回指向str1中str2第一次出现的指针，如果str2不是str1的一部分，则返回空指针
模拟实现strstr
#include <stdio.h>
#include <assert.h>
char* my_strstr(char* str1, char* str2)
{
char* cp = str1;
char* s1 = 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[] = "abcdefgjaelgjaefhg";
char arr2[] = "ae";
char* ret = my_strstr(arr1, arr2);
printf("%s\n", ret);
return 0;
}
解析：3个指针，1个记录比较的起始位置，两外两个进行比较
strtok
char * strtok ( char * str, const char * delimiters );
- 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[] = "zpengwei@yeah.net@666#777";
char copy[30];
strcpy(copy, arr);
char sep[] = "@.#";
char* ret = strtok(copy, sep);
printf("%s\n", ret);
ret = strtok(NULL, sep);
printf("%s\n", ret);
ret = strtok(NULL, sep);
printf("%s\n", ret);
return 0;
//zpengwei
//yeah
//net
}
升级版本
#include <stdio.h>
#include <string.h>
int main()
{
char arr[] = "zpengwei@yeah.net@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;
}
strerror
char * strerror ( int errnum );
- 返回错误码所对应的错误信息
#include <stdio.h>
#include <string.h>
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;
}
字符分类函数
| 函数 | 符合条件就返回真 |
|---|---|
| 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 | 任何可打印字符，包括图形字符和空白字符 |
#include <stdio.h>
#include <ctype.h>
int main()
{
printf("%d\n", isupper('a'));//0
printf("%d\n", isdigit('2'));//4
printf("%c\n", tolower('A'));//a
printf("%c\n", toupper('b'));//B
return 0;
}
//将小写字母转变为大写字母
#include <stdio.h>
#include <ctype.h>
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;
}
memcpy
void * memcpy ( void * destination, const void * source, size_t num );
- 从source的位置开始复制num个字节的数据到dst中的内存位置
- memcpy是内存拷贝，会拷贝字符型、整型、结构体类型等，所以遇到’\0’不会停下来
- 如果src和dst的位置有重叠，结果是不可知的
- 以字节为单位进行拷贝
memcpy模拟实现
#include <stdio.h>
#include <string.h>
#include <assert.h>
//函数拷贝结束后，返回目标空间的起始地址
void* my_memcpy(void* dst, const void* src, size_t num)
{
assert(dst && src);
void* p = dst;
while (num--)
{
*(char*)dst = *(char*)src;//强转是临时的，所以下面还得强转
dst = (char*)dst + 1;
src = (char*)src + 1;
//(char*)dst++;//临时强转，当++时，已经回到void*
//(char*)src++;
//dst++;//void*类型，不能++
//src++;
}
return p;
}
int main()
{
int arr1[] = { 1, 2, 3, 4, 5, 6 };
int arr2[10] = { 0 };
my_memcpy(arr2, arr1, 20);
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", arr2[i]);
}
return 0;
}
memmove
- memmove函数出来的src内存空间和dst内存空间是可以重叠的
- 以字节为单位进行移动
memmove模拟实现
#include <stdio.h>
#include <string.h>
#include <assert.h>
void* my_memmove(void* dst, const void* src, size_t num)
{
assert(dst && src);
void* p = dst;
if (dst < src)
{
//从前向后拷贝
while (num--)
{
*(char*)dst = *(char*)src;
dst = (char*)dst + 1;
src = (char*)src + 1;
}
}
else
{
//从后向前拷贝
while (num--)
{
*((char*)dst + num) = *((char*)src + num);
}
}
return p;
}
int main()
{
int arr1[] = { 1, 2, 3, 4, 5, 6 };
my_memmove(arr1 + 2, arr1, 12);
int i = 0;
for (i = 0; i < 6; i++)
{
printf("%d ", arr1[i]);
}
return 0;
}
memcmp
int memcmp ( const void * ptr1, const void * ptr2, size_t num );
- 以字节为单位进行比较
- 如果ptr1指向的字节小于ptr2指向的某个字节，返回小于0的数，等于则返回0，否则返回大于0的数
memset
void * memset ( void * ptr, int value, size_t num );
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
