size_t strlen ( const char * str );
1.字符串已经 ‘\0’ 作为结束标志,strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数(不包含 ‘\0’ )。
2.参数指向的字符串必须要以 ‘\0’ 结束。
3.注意函数的返回值为size_t,是无符号的( 易错 )
#include
#include
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);
int 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) ? my_strlen(str + 1) : 0;
}
char* strcpy(char* destination,const char* source);
功能:
strcpy函数将strSource(包括终止的空字符)复制到strDestination指定的位置。复制或追加字符串时不执行溢出检查。如果源字符串和目标字符串重叠,strcpy的行为是未定义的。
使用:
#include
#include
int main()
{
char arr1[20] = "poiu";
char arr2[] = "lkj";
strcpy(arr1, arr2);
printf("%s\n", arr1);
}
注意事项:
1.源字符串必须以 ‘\0’ 结束。
2.会将源字符串中的 ‘\0’ 拷贝到目标空间。
3.目标空间必须足够大,以确保能存放源字符串。
4.目标空间必须可变。
5.模拟实现
#include
#include
#include
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’ , 退出循环
char* strcat(char* destination,const char* source);
功能:
strcat函数将strSource追加到strDestination,并用空字符终止字符串。strSource的初始字符覆盖strDestination的终止空字符。复制或追加字符串时不执行溢出检查。如果源字符串和目标字符串重叠,strcat的行为是未定义的。
注意事项:
1.源字符串必须以 ‘\0’ 结束。
2.目标空间必须有足够的大,能容纳下源字符串的内容
3.目标空间必须可变。
4 .不能自已给自己追加
5 . 模拟实现
#include
#include
#include
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));
}
int strcmp ( const char * str1, const char * str2 );
功能:
strcmp函数按字典顺序比较string1和string2,并返回一个表示它们之间关系的值。
此函数开始比较每个字符串的第一个字符。如果它们彼此相等,那么继续执行比较,直到字符不同或找到终止的空字符为止
标准规定:
第一个字符串大于第二个字符串,则返回大于0的数字
第一个字符串等于第二个字符串,则返回0
第一个字符串小于第二个字符串,则返回小于0的数字
模拟实现
#include
#include
#include
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);
}
char * strncpy ( char * destination, const char * source,size_t count);
功能:
strncpy函数将strSource的初始计数字符复制到strDest并返回strDest。如果count小于或等于strSource的长度,则不会将空字符自动附加到复制的字符串中。如果count大于strSource的长度,则目标字符串将填充长度count以内的空字符。如果源字符串和目标字符串重叠,strncpy的行为是未定义的。
模拟实现:
#include
#include
#include
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的地址.
char * strncat ( char * destination, const char * source,size_t count);
功能:
从字符串追加字符
将源的前num个字符附加到目标,再加上一个终止的空字符。
如果source中的C字符串长度小于num,则只复制到终止空字符之前的内容。
模拟实现
#include
#include
#include
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));
}
int strncmp( const char *string1, const char *string2, size_t count );
功能:
比较两个字符串的字符
比较C字符串str1和C字符串str2的最多count个字符。
此函数开始比较每个字符串的第一个字符。如果它们彼此相等,则继续比较,直到字符不同,直到到达一个终止的空字符,或者直到两个字符串中的count字符匹配为止,以先发生的为准。
使用:
#include
#include
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]);
}
}
}
char *strstr( const char *str1, const char *str2 );
功能:
返回指向str1中第一个出现的str2的指针,如果str2不是str1的一部分,则返回空指针。
使用:
#include
#include
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
#include
#include
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");
}
}
char * strtok ( char * str, const char * sep );
sep参数是个字符串,定义了用作分隔符的字符集合
第一个参数指定一个字符串,它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。
strtok函数找到str中的下一个标记,并将其用 \0 结尾,返回一个指向这个标记的指针。(注:strtok函数会改变被操作的字符串,所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。)
strtok函数的第一个参数不为 NULL ,函数将找到str中第一个标记,strtok函数将保存它在字符串中的位置。
strtok函数的第一个参数为 NULL ,函数将在同一个字符串中被保存的位置开始,查找下一个标记。
使用:
#include
#include
int main()
{
char arr1[] = "[email protected]";
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
char *strerror( int errnum );
功能:
strerror函数将errnum映射到错误消息字符串,并返回指向该字符串的指针
使用:
库函数在使用时,如果发生错误,都会有对应的错误码,这些错误码会被存放在一个全局变量 errno中,使用时需要引用 #include
#include
#include
#include // 必须包含的头文件
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
#include
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;
}
void *memcpy( void *dest, const void *src, size_t count );
功能:
memcpy函数将src的count字节复制到dest。如果源和目标重叠,此函数不能确保在覆盖之前复制重叠区域中的原始源字节。使用memmove处理重叠区域。
模拟实现:
#include
#include
#include
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);
}
void *memmove( void *dest, const void *src, size_t count );
功能:
memmove函数将count字节的字符从src复制到dest。如果源区域和目标区域的某些区域重叠,memmove将确保在覆盖之前复制重叠区域中的原始源字节。
模拟实现:
#include
#include
#include
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);
}
int memcmp( const void *buf1, const void *buf2, size_t count );
功能:
memcmp函数比较buf1和buf2的第一个计数字节,并返回一个指示它们之间关系的值。
使用:
#include
#include
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;
}