目录
长度不受限制的字符串函数
strlen
size_t strlen ( const char * str );
- 字符串已经 ‘\0’ 作为结束标志,strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数(不包含 ‘\0’ )。
- 参数指向的字符串必须要以 ‘\0’ 结束。
- 注意函数的返回值为size_t,是无符号的( 易错 )
int main()
{
//char arr[] = "abc\0def";
char arr[3] = { 'a', 'b', 'c' };
int len = strlen(arr);
printf("%d\n", len);
return 0;
}
易错点:
strlen函数的返回类型是size_t - 无符号整型
int main()
{
if (strlen("abc") - strlen("abcdef") > 0)
{
printf(">\n");
}
else
{
printf("<=\n");
}
return 0;
}
模拟实现strlen
1. 计数器
int my_strlen(const char* str)
{
int count = 0;
assert(str);
while (*str != '\0')
{
count++;
str++;
}
return count;
}
2. 递归
不创建临时变量,求字符串长度
int my_strlen(const char* str)
{
if (*str != '\0')
return 1 + my_strlen(str + 1);
else
return 0;
}
3. 指针-指针
#include <assert.h>
int main()
{
char arr[] = "bit";
int len = my_strlen(arr);
printf("%d\n", len);
return 0;
}
strcpy
char* strcpy(char * destination, const char * source );
- 源字符串必须以 ‘\0’ 结束。
- 会将源字符串中的 ‘\0’ 拷贝到目标空间。
- 目标空间必须足够大,以确保能存放源字符串。
- 目标空间必须可变。
模拟实现strcpy
返回的是目标空间的起始地址
char* my_strcpy(char* dest, const char*src)
{
char* ret = dest;
assert(dest && src);
while (*dest++ = *src++)
{
;
}
return ret;
}
int main()
{
char arr1[] = "hehe";
char arr2[20] = { 0 };
//my_strcpy(arr2, arr1);
//printf("%s\n", arr2);
printf("%s\n", my_strcpy(arr2, arr1));
return 0;
}
strcat
char * strcat ( char * destination, const char * source );
- 源字符串必须以 ‘\0’ 结束。
- 目标空间必须有足够的大,能容纳下源字符串的内容。
- 目标空间必须可修改。
- 字符串自己给自己追加,如何?
#include <string.h>
int main()
{
char arr1[20] = "hello \0xxxxxxxxx";
char arr2[] = "world";
//追加
strcat(arr1, arr2);
printf("%s\n", arr1);
return 0;
}
模拟实现strcat
char* my_strcat(char* dest, const char*src)
{
assert(dest && src);
char* ret = dest;
//找目标空间中的\0
while (*dest != '\0')
{
dest++;
}
//拷贝
while (*dest++ = *src++)
{
;
}
return ret;
}
int main()
{
char arr1[20] = "bit";
my_strcat(arr1, arr1);
printf("%s\n", arr1);
char arr1[20] = "hello ";
char arr2[] = "world";
//追加
my_strcat(arr1, arr2);
printf("%s\n", arr1);
return 0;
}
strcat是不适合自己给自己追加的,而strncat是可以自己给自己追加的。
因为bit\0想追加的时候\0被改成b,然后因为\0被改找不到结束标志。
strcmp
int strcmp ( const char * str1, const char * str2 );
标准规定:
- 第一个字符串大于第二个字符串,则返回大于0的数字
- 第一个字符串等于第二个字符串,则返回0
- 第一个字符串小于第二个字符串,则返回小于0的数字
int main()
{
//char* p = "abcdef";
比较2个字符串的内容的时候,不能使用==,应该使用strcmp
//if ("abcdef" == "bbcdef")//这里比较的是连个字符串首字符的地址,而并不是字符串的内容
//{
//}
char arr1[] = "abq";
char arr2[] = "abq";
int ret = strcmp(arr1, arr2);
printf("%d\n", ret);
return 0;
}
模拟实现strcmp
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;
//if (*str1 > *str2)
// return 1;
//else
// return -1;
}
int main()
{
char arr1[] = "abzqw";
char arr2[] = "abq";
/*int ret = my_strcmp(arr1, arr2);
printf("%d\n", ret);*/
if (strcmp(arr1, arr2) >0)
printf(">\n");
return 0;
}
长度受限制的字符串函数
strncpy
char * strncpy ( char * destination, const char * source, size_t num );
- 拷贝num个字符从源字符串到目标空间。
- 如果源字符串的长度小于num,则拷贝完源字符串之后,在目标的后边追加0,直到num个。
int main()
{
char arr1[] = "abcdef";
char arr2[20] = "xxxxxxxxxx";
strncpy(arr2, arr1, 3);
printf("%s\n", arr2);
return 0;
}
模拟实现strncpy
char* my_strncpy(char* dest, const char* source,size_t num)
{
assert(dest && source);
const char* p = dest;//备份一下目的地地址
while (num)//为假就退出循环,
{
if(*source!='\0')
{
*dest = *source;
dest++;
source++;
}
else
{
*dest = '\0';
dest++;
}
num--;
}
return p;
}
int main()
{
char arr1[20] = "abcdef";
char arr2[] = "egh";
char* p = my_strncpy(arr1, arr2, 3);//函数返回目的地地址
printf("%s\n", arr1);
printf("%s\n", p);
return 0;
}
strncat
char * strncat ( char * destination, const char * source, size_t num );
比strncat多了一个参数,可以指定追加的个数
源头字符串不够指定的个数,那就不够吧,strncat不会像strncpy一样帮你强行加上\0
追加时和strcat一样也会把\0放到要追加字符串的后面,你要追加5个字符,但其实放进去的是6个
返回的也是目的地地址
模拟实现strncat
char* my_strncat(char* dest, char* source, size_t num)
{
assert(dest && source);
char* p = dest;
//找到目的地的\0的位置
while (*dest)//while (*dest++)判断为假,退出循环然后dest也会再++,这样会略过\0
{
dest++;
}
//开始追加
while ((*dest++ = *source++)&& num)
{
num--;
}
return p;
}
int main()
{
char arr1[20] = "hello \0#####";
char arr2[] = "wol";
char* p = my_strncat(arr1, arr2, 5);
printf("%s\n", arr1);
printf("%s\n", p);
return 0;
}
strncmp
int strncmp ( const char * str1, const char * str2, size_t num );
- 按规定的数量比较对应字符ascll码值
- 比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完。
模拟实现strncmp
int my_strncmp(const char* s1,const char* s2, size_t num)
{
assert(s1 && s2);
while (*s1 == *s2 &&*s1 && *s2 &&--num)//相等且都不为\0
{
s1++;
s2++;
}
return *s1 - *s2;
}
int main()
{
char arr[20] = "abfde";
char* p = "abcde";
int ret=my_strncmp(arr, p,3);
printf("%d", ret);
return 0;
}
strstr
char * strstr ( const char *str1, const char * str2);
- 在一个字符串str1中找另一个字符串str2
- 找到了则返回str1中str2字符串第一次出现位置的地址,找不到则返回空指针
- 如果str2里面都是\0,那返回str1地址
模拟实现strstr
char* my_strstr(const char*str1, const char* str2)
{
char* s1 = NULL;
char* s2 = NULL;
char* cp = (char*)str1;
while (*cp)
{
s1 = cp;
s2 = (char*)str2;
while (*s1 && *s2 && *s1 == *s2)
{
s1++;
s2++;
}
if (*s2 == '\0')
{
return cp;
}
cp++;
}
return NULL;
}
int main()
{
char arr1[] = "abcdebcdf";
char arr2[] = "bcd";
char* p = my_strstr(arr1, arr2);
if (p == NULL)
{
printf("找不到\n");
}
else
{
printf("%s\n", p);
}
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 指针。
"zhongguo@yeah.net"
@. - 分割符
"192.168.3.212"
"@."
int main()
{
char arr[] = "192.168.3.212";
char buf[30] = {0};//zhongguo\0yeah\0net\0
strcpy(buf, arr);
const char* p = ".";
char* str = strtok(buf, p);//
printf("%s\n", str);
str = strtok(NULL, p);//
printf("%s\n", str);
str = strtok(NULL, p);//
printf("%s\n", str);
str = strtok(NULL, p);//
printf("%s\n", str);
return 0;
}
strtok函数将保存它在字符串中的位置,说明它有记忆功能
可以对上面的使用方法改进:
int main()
{
char arr[] = "zhongguo@yeah.net";
char buf[30] = { 0 };//zhongguo\0yeah\0net\0
strcpy(buf, arr);
//const char* buf = "zhongguo@yeah.net";
const char* p = "@.";
char* str = NULL;
for (str = strtok(buf, p); str != NULL; str=strtok(NULL, p))
{
printf("%s\n", str);
}
return 0;
}
strerror
char * strerror ( int errnum );
返回错误码,所对应的错误信息。
int main()
{
char* p = strerror(0);
printf("%s\n", p);
p = strerror(1);
printf("%s\n", p);
p = strerror(2);
printf("%s\n", p);
p = strerror(3);
printf("%s\n", p);
return 0;
}
strerror使用:
int main()
{
//打开文件
//打开文件的时候,如果文件的打开方式是"r"
//文件存在则打开成功,文件不存在打开失败
//打开文件失败的话,会返回NULL
FILE* pf = fopen("test.txt", "r");
if (pf == NULL)
{
printf("打开文件失败,原因是:%s\n", strerror(errno));
return 1;
}
//读写文件
//...
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
这个errno的变量是共用的,当你使用了两个库函数,第一个库函数调用失败,假设此时errno中错误码是3,第二个库函数调用的时候成功,那么errno中错误码被改成0,就检查不出错误了。所以使用一个库函数的时候在后面就检查,而不是等使用完库函数再检查。
还有另外一种打印错误信息的库函数:perror
perror的使用:
int main()
{
//打开文件
//打开文件的时候,如果文件的打开方式是"r"
//文件存在则打开成功,文件不存在打开失败
//打开文件失败的话,会返回NULL
FILE* pf = fopen("test.txt", "r");
if (pf == NULL)
{
perror("打开文件失败");
//printf + strerror
return 1;
}
//读写文件
//...
//关闭文件
fclose(pf);
pf = NULL;
return 0;
}
perror其实就是errno加打印,想打印的时候可以用perror,不想打印的时候用errno
先前的函数都是和字符串相关,但我们操作数据时,不仅仅是操作字符串的数据
内存函数
memcpy
void * memcpy ( void * destination, const void * source, size_t num );
- 函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
- 这个函数在遇到 ‘\0’ 的时候并不会停下来。
- 如果source和destination有任何的重叠,复制的结果都是未定义的。
void test1()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2[8] = { 0 };
//把arr1中的前5个数据拷贝到arr2中
memcpy(arr2, arr1, 20);
}
void test2()
{
float arr1[] = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f};
float arr2[8] = { 0 };
//把arr1中的前3个数据拷贝到arr2中
memcpy(arr2, arr1, 12);
}
//mempcy函数返回的是目标空间的起始地址
int main()
{
test1();
return 0;
}
模拟实现memcpy
#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;
}
void test3()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2[8] = { 0 };
//把arr1中的前5个数据拷贝到arr2中
my_memcpy(arr2, arr1, 20);
}
临时转换再++的操作,不能保证总是正确的,不建议使用。
强转再加1就可以保证正确
字符串拷贝就用字符串拷贝函数,就不要再使用通用的memcpy了,因为里面还存在类型转换,会浪费一些时间,所以没有匹配的再选择通用的。
memmove
void * memmove ( void * destination, const void * source, size_t num );
- 和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
- 如果源空间和目标空间出现重叠,就得使用memmove函数处理。
模拟实现memmove
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;
}
void test4()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
// 1 2 1 2 3 4 5 8 9 10
//my_memcpy(arr1+2, arr1, 20);
//my_memmove(arr1 + 2, arr1, 20);
//my_memmove(arr1, arr1+2, 20);
//memcpy(arr1, arr1 + 2, 20);
//memcpy(arr1 + 2, arr1, 20);
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", arr1[i]);
}
}
虽然vs库中的memcpy也能实现重叠拷贝,但不代表所有编译器上的memcpy都能实现
C语言:memcpy拷贝不重叠的内存
重叠的就交给memmove
memmove > memcpy
因为vs实现的好,所以memcpy也能实现memcpy的功能
memcmp
int memcmp ( const void * ptr1,
const void * ptr2,
size_t num );
- 比较从ptr1和ptr2指针开始的num个字节
- 如果返回值 < 0,则表示 ptr1 小于 ptr2。
- 如果返回值 > 0,则表示 ptr1 大于 ptr2。
- 如果返回值 = 0,则表示 ptr1 等于 ptr2。
void test5()
{
int arr1[] = { 1,2,3,4,7};//01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 07 00 00 00
int arr2[] = { 1,2,3,4,6};//01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 06 00 00 00
int ret = memcmp(arr1, arr2, 17);
printf("%d\n", ret);
}
注意比较17个字节是不相同的,因为小端字节序的原因
memset
void *memset(void *str, int c, size_t n)
- str – 指向要填充的内存块。
- c – 要被设置的值。该值以 int 形式传递,但是函数在填充内存块时是使用该值的无符号字符形式。
- n – 要被设置为该值的字符数。
- 返回一个指向存储区 str 的指针。
- 一个字节一个字节设置
void test6()
{
/*char arr[] = "hello world";
memset(arr, 'x', 5);
printf("%s\n", arr);*/
int arr[10] = { 0 };
//01 01 01 01
memset(arr, 1, sizeof(arr));//这种写法无法将数据的每个元素设置为1
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%x ", arr[i]);
}
}
字符分类函数
函数 | 如果他的参数符合下列条件就返回真 |
---|---|
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 | 任何可打印字符,包括图形字符和空白字符 |
字符转换:
int tolower ( int c );
int toupper ( int c );
#include <ctype.h>
void test7()
{
printf("%d\n", isdigit('6'));
printf("%d\n", isspace('2'));
printf("%d\n", islower('x'));
printf("%c\n", toupper('x'));
printf("%c\n", tolower('X'));
}
void test8()
{
char arr[128] = {0};
gets(arr);
int i = 0;
while (arr[i])
{
if (isupper(arr[i]))
{
arr[i] = tolower(arr[i]);
}
printf("%c", arr[i]);
i++;
}
}
int main()
{
//test1();
//test2();
//test3();
//test4();
//test5();
//test6();
//test7();
test8();
return 0;
}