文章目录
求字符串长度
strlen
size_t strlen ( const char * str );
1.字符串已经 ‘\0’ 作为结束标志，strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包含 ‘\0’ )。
2.参数指向的字符串必须要以 ‘\0’ 结束。
3.注意函数的返回值为size_t，是无符号的（ 易错 ）
#include<stdio.h>
#include<string.h>
int main()
{
if (strlen("abc") - strlen("abcdef") > 0)
{
printf(" > \n");
}
else
{
printf(" < \n");
}
}
// 输出结果为 >
由于strlen函数的返回值类型为size_t , 两个无符号整形相减得到的仍是无符号数 ， -3被当成无符号数，补码即为原码，最高位为数值位 ， 是一个很大的正数，所以输出结果为 >
4.模拟实现
// 第一种
size_t my_strlen(const char* str)
{
assert(str);
size_t count = 0;
while (*str)
{
count++;
str++;
}
return count;
}
// 第二种
size_t my_strlen(const char* str)
{
assert(str);
const char* eos = str;
while (*str)
{
str++;
}
return str - eos;
}
// 第三种
size_t my_strlen(const char* str)
{
assert(str);
return (*str) ? 1 + my_strlen(str + 1) : 0;
}
长度不受限制的字符串函数
1.strcpy
char* strcpy(char* destination,const char* source);
功能:
strcpy函数将strSource（包括终止的空字符）复制到strDestination指定的位置。复制或追加字符串时不执行溢出检查。如果源字符串和目标字符串重叠，strcpy的行为是未定义的。
使用:
#include<stdio.h>
#include<string.h>
int main()
{
char arr1[20] = "poiu";
char arr2[] = "lkj";
strcpy(arr1, arr2);
printf("%s\n", arr1);
}
注意事项:
1.源字符串必须以 ‘\0’ 结束。
2.会将源字符串中的 ‘\0’ 拷贝到目标空间。
3.目标空间必须足够大，以确保能存放源字符串。
4.目标空间必须可变。
5.模拟实现
#include<stdio.h>
#include<string.h>
#include<assert.h>
char* my_strcpy(char* dest, const char* src)
{
assert(dest && src);
char* ret = dest;
while (*dest++ = *src++); // 拷贝字符串，包括'\0'
return ret; // 返回目标空间的起始位置
}
int main()
{
char arr1[20] = "poiu";
char arr2[] = "lkj";
printf("%s\n", my_strcpy(arr1, arr2));
}
while (*dest++ = *src++);
该代码相当于 *(dest++) = *(src++) ,将*src的内容赋值给 *dest , 然后src++ , dest++ , 循环直到 *src = ‘\0’ , 退出循环
2.strcat
char* strcat(char* destination,const char* source);
功能:
strcat函数将strSource追加到strDestination，并用空字符终止字符串。strSource的初始字符覆盖strDestination的终止空字符。复制或追加字符串时不执行溢出检查。如果源字符串和目标字符串重叠，strcat的行为是未定义的。
注意事项:
1.源字符串必须以 ‘\0’ 结束。
2.目标空间必须有足够的大，能容纳下源字符串的内容
3.目标空间必须可变。
4 .不能自已给自己追加
5 . 模拟实现
#include<stdio.h>
#include<string.h>
#include<assert.h>
char* my_strcat(char* dest, const char* src)
{
assert(dest && src);
char* ret = dest;
while (*dest) // 1.找到目标空间的 \0
{
dest++;
}
while (*dest++ = *src++); // 2.追加
return ret;
}
int main()
{
char arr1[20] = "hello ";
char arr2[] = "world";
printf("%s\n", my_strcat(arr1, arr2));
}
3.strcmp
int strcmp ( const char * str1, const char * str2 );
功能:
strcmp函数按字典顺序比较string1和string2，并返回一个表示它们之间关系的值。
此函数开始比较每个字符串的第一个字符。如果它们彼此相等，那么继续执行比较，直到字符不同或找到终止的空字符为止
标准规定：
第一个字符串大于第二个字符串，则返回大于0的数字
第一个字符串等于第二个字符串，则返回0
第一个字符串小于第二个字符串，则返回小于0的数字
模拟实现
#include<stdio.h>
#include<string.h>
#include<assert.h>
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("abcq", "abcd");
printf("%d\n", ret);
}
长度受限制的字符串函数介绍
1.strncpy
char * strncpy ( char * destination, const char * source,size_t count);
功能:
strncpy函数将strSource的初始计数字符复制到strDest并返回strDest。如果count小于或等于strSource的长度，则不会将空字符自动附加到复制的字符串中。如果count大于strSource的长度，则目标字符串将填充长度count以内的空字符。如果源字符串和目标字符串重叠，strncpy的行为是未定义的。
模拟实现:
#include<stdio.h>
#include<string.h>
#include<assert.h>
char* my_strncpy(char* dest, const char* src, size_t count)
{
assert(dest && src);
char* start = dest;
while (count && (*dest++ = *src++))
{
count--;
}
if (count)
{
while (--count)
{
*dest++ = '\0';
}
}
return start;
}
int main()
{
char arr1[10] = "**********";
char arr2[] = "abc";
printf("%s\n", my_strncpy(arr1, arr2, 5));
}
若 count 小于或 等于 Strsrc 的长度，则while循环里的两个条件，count会先减为0，退出循环，然后返回 Strdest的地址
若count 大于Strsrc的长度，(*dest++ = *src++)会先变为0，退出循环，因为在判断该表达式为假时，已经将一个’ \0’拷贝到 Strdest中，故接下来只需要循环(count - 1)次 补’ \0 '的操作，然后返回 Strdest的地址.
2.strncat
char * strncat ( char * destination, const char * source,size_t count);
功能:
从字符串追加字符
将源的前num个字符附加到目标，再加上一个终止的空字符。
如果source中的C字符串长度小于num，则只复制到终止空字符之前的内容。
模拟实现
#include<stdio.h>
#include<string.h>
#include<assert.h>
char* my_strncat(char* dest, const char* src, size_t count)
{
assert(dest && src);
char* start = dest;
while (*dest)
{
dest++;
}
while (count--)
{
if ((*dest++ = *src++) == 0)
return start;
}
*dest = '\0';
return start;
}
int main()
{
char arr1[20] = "hello \0******";
char arr2[] = "world";
printf("%s\n", my_strncat(arr1, arr2, 5));
}
3.strncmp
int strncmp( const char *string1, const char *string2, size_t count );
功能:
比较两个字符串的字符
比较C字符串str1和C字符串str2的最多count个字符。
此函数开始比较每个字符串的第一个字符。如果它们彼此相等，则继续比较，直到字符不同，直到到达一个终止的空字符，或者直到两个字符串中的count字符匹配为止，以先发生的为准。
使用:
#include <stdio.h>
#include <string.h>
int main()
{
char str[][5] = { "R2D2" , "C3PO" , "R2A6" };
int n;
puts("Looking for R2 astromech droids...");
for (n = 0; n < 3; n++)
{
if (strncmp(str[n], "R2xx", 2) == 0)
{
printf("found %s\n", str[n]);
}
}
}
字符串查找
1.strstr
char *strstr( const char *str1, const char *str2 );
功能:
返回指向str1中第一个出现的str2的指针，如果str2不是str1的一部分，则返回空指针。
使用:
#include <stdio.h>
#include <string.h>
int main()
{
char str[] = "This is a simple string";
char* pch = strstr(str, "simple");
strncpy(pch, "sample", 6);
puts(str);
}
// 输出结果为
// This is a sample string
模拟实现:
#include <stdio.h>
#include <string.h>
#include<assert.h>
char* my_strstr(const char* s1, const char* s2)
{
assert(s1 && s2);
if(*s2 == '\0')
return (char*)s1;
const char* cp = s1;
while (*cp)
{
const char* p1 = cp;
const char* p2 = s2;
while ((*p1) && (*p2) && (*p1 == *p2))
{
p1++;
p2++;
}
if (*p2 == '\0')
return (char*)cp;
cp++;
}
return NULL;
}
int main()
{
char arr1[] = "abbbcdef";
char arr2[] = "bcd";
char* ret = my_strstr(arr1, arr2);
if (ret != NULL)
{
printf("%s\n", ret);
}
else
{
printf("找不到字串\n");
}
}
2.strtok
char * strtok ( char * str, const char * sep );
sep参数是个字符串，定义了用作分隔符的字符集合
第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。
strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
使用:
#include<stdio.h>
#include<string.h>
int main()
{
char arr1[] = "luanyiping@33492586487.com";
char arr2[30] = { 0 };
strcpy(arr2, arr1);
char* p = "@.";
char* ret = NULL;
for (ret = strtok(arr2, p); ret != NULL; ret = strtok(NULL, p))
{
printf("%s\n", ret);
}
}
// 打印结果
// luanyiping
// 33492586487
// com
错误信息报告
strerror
char *strerror( int errnum );
功能:
strerror函数将errnum映射到错误消息字符串，并返回指向该字符串的指针
使用:
库函数在使用时，如果发生错误，都会有对应的错误码，这些错误码会被存放在一个全局变量 errno中，使用时需要引用 #include<errno.h>
#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));
//errno: Last error number
return 0;
}
字符分类函数
字符转换:
int tolower(int c);
int toupper(int c);
使用:
#include <stdio.h>
#include <ctype.h>
int main ()
{
int i=0;
char str[]="Test String.\n";
char c;
while (str[i])
{
c=str[i];
if (isupper(c))
c=tolower(c);
putchar (c);
i++;
}
return 0;
}
内存操作函数
1.memcpy
void *memcpy( void *dest, const void *src, size_t count );
功能:
memcpy函数将src的count字节复制到dest。如果源和目标重叠，此函数不能确保在覆盖之前复制重叠区域中的原始源字节。使用memmove处理重叠区域。
模拟实现:
#include <stdio.h>
#include <string.h>
#include<assert.h>
void* my_memcpy(void* dest, const void* src, size_t count)
{
assert(dest && src);
void* start = dest;
while (count--)
{
*(char*)dest = *(char*)src;
++(char*)dest;
++(char*)src;
}
return start;
}
int main()
{
int arr1[] = { 1,2,3,4,5,6 };
int arr2[] = { 0 };
my_memcpy(arr2, arr1, 16);
}
2.memmove
void *memmove( void *dest, const void *src, size_t count );
功能:
memmove函数将count字节的字符从src复制到dest。如果源区域和目标区域的某些区域重叠，memmove将确保在覆盖之前复制重叠区域中的原始源字节。
模拟实现:
#include <stdio.h>
#include <string.h>
#include<assert.h>
void* my_memmove(void* dest, const void* src, size_t count)
{
assert(dest && src);
void* start = dest;
if (dest < src)
{
// 从前向后拷贝
while (count--)
{
*(char*)dest = *(char*)src;
++(char*)dest;
++(char*)src;
}
}
else
{
// 从后向前拷贝
while (count--)
{
*((char*)dest + count) = *((char*)src + count);
}
}
return start;
}
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9,10};
my_memmove(arr + 2,arr,16);
}
3.memcmp
int memcmp( const void *buf1, const void *buf2, size_t count );
功能:
memcmp函数比较buf1和buf2的第一个计数字节，并返回一个指示它们之间关系的值。
使用:
#include <stdio.h>
#include <string.h>
int main ()
{
char buffer1[] = "DWgaOtP12df0";
char buffer2[] = "DWGAOTP12DF0";
int n;
n=memcmp ( buffer1, buffer2, sizeof(buffer1) );
if (n>0)
printf ("'%s' is greater than '%s'.\n",buffer1,buffer2);
else if (n<0)
printf ("'%s' is less than '%s'.\n",buffer1,buffer2);
else
printf ("'%s' is the same as '%s'.\n",buffer1,buffer2);
return 0;
}
996
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
