求字符串长度

strlen

size_t strlen ( const char * str );

1.字符串已经 ‘’ 作为结束标志，strlen函数返回的是在字符串中 ‘’ 前面出现的字符个数（不包含 ‘’ )。

2.参数指向的字符串必须要以 ‘’ 结束。

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("%sn", arr1);
}

注意事项:

1.源字符串必须以 ‘’ 结束。

2.会将源字符串中的 ‘’ 拷贝到目标空间。

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++);
// 拷贝字符串，包括''
return ret;
// 返回目标空间的起始位置
}
int main()
{
char arr1[20] = "poiu";
char arr2[] = "lkj";
printf("%sn", my_strcpy(arr1, arr2));
}

while (*dest++ = *src++);

该代码相当于 *(dest++) = *(src++) ,将*src的内容赋值给 *dest , 然后src++ , dest++ , 循环直到 *src = ‘’ , 退出循环

2.strcat

char* strcat(char* destination,const char* source);

功能:

strcat函数将strSource追加到strDestination，并用空字符终止字符串。strSource的初始字符覆盖strDestination的终止空字符。复制或追加字符串时不执行溢出检查。如果源字符串和目标字符串重叠，strcat的行为是未定义的。

注意事项:

1.源字符串必须以 ‘’ 结束。

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.找到目标空间的 
{
dest++;
}
while (*dest++ = *src++);
//
2.追加
return ret;
}
int main()
{
char arr1[20] = "hello ";
char arr2[] = "world";
printf("%sn", 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 == '')
return 0;
str1++;
str2++;
}
return *str1 - *str2;
}
int main()
{
int ret = my_strcmp("abcq", "abcd");
printf("%dn", 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++ = '';
}
}
return start;
}
int main()
{
char arr1[10] = "**********";
char arr2[] = "abc";
printf("%sn", my_strncpy(arr1, arr2, 5));
}

若 count 小于或 等于 Strsrc 的长度，则while循环里的两个条件，count会先减为0，退出循环，然后返回 Strdest的地址

若count 大于Strsrc的长度，(*dest++ = *src++)会先变为0，退出循环，因为在判断该表达式为假时，已经将一个’ ’拷贝到 Strdest中，故接下来只需要循环(count - 1)次 补’ '的操作，然后返回 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 = '';
return start;
}
int main()
{
char arr1[20] = "hello ******";
char arr2[] = "world";
printf("%sn", 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 %sn", 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 == '')
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 == '')
return (char*)cp;
cp++;
}
return NULL;
}
int main()
{
char arr1[] = "abbbcdef";
char arr2[] = "bcd";
char* ret = my_strstr(arr1, arr2);
if (ret != NULL)
{
printf("%sn", ret);
}
else
{
printf("找不到字串n");
}
}

2.strtok

char * strtok ( char * str, const char * sep );

sep参数是个字符串，定义了用作分隔符的字符集合

第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。

strtok函数找到str中的下一个标记，并将其用 结尾，返回一个指向这个标记的指针。（注：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("%sn", 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: %sn",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;
}

最后

以上就是酷酷小蘑菇为你收集整理的常考字符串函数，内存函数总结大全求字符串长度长度不受限制的字符串函数长度受限制的字符串函数介绍字符串查找错误信息报告字符分类函数内存操作函数的全部内容，希望文章能够帮你解决常考字符串函数，内存函数总结大全求字符串长度长度不受限制的字符串函数长度受限制的字符串函数介绍字符串查找错误信息报告字符分类函数内存操作函数所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。