C语言中的字符函数和字符串函数以及内存操作函数

编程语言 2023-09-08 18:55:28 阅读次数: 0

前言

C语言中对字符和字符串的处理很是频繁，但是C语言本身是没有字符串类型的，字符串通常放在 常量字符串 中或者 字符数组 中。 字符串常量 适用于那些对它不做修改的字符串函数.

1.库函数介绍

求字符串长度

  • strlen
    长度不受限制的字符串函数
  • strcpy
  • strcmp
  • strcat
    长度受限制的字符串函数
  • strncpy
  • strncmp
  • strncat
    字符串查找
  • strstr
  • strtok
    错误信息报告
  • sterror
  • perror

字符分类函数
在这里插入图片描述

内存操作函数

  • memcpy
  • memcmp
  • memmove
  • memset

strlen

size_t strlen ( const char * str );

定义：求字符串长度
头文件 ： <string.h>

注：

  • 字符串以 ‘\0’ 作为结束标志，strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包含 ‘\0’ )。
  • 参数指向的字符串必须要以 ‘\0’ 结束。
  • 函数的返回值为size_t（无符号的）

例：

#include<stdio.h>
#include<string.h>
 
int main()
{
    
    
	char arr[] = "hello world";
	
	printf("%d\n", strlen(arr));
 
	return 0;
}

strcpy

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

定义：拷贝字符串
头文件：<string.h>

注：

  • strcpy函数的作用是将strSource(包括结束空字符)复制到strDestination指定的位置。复制或追加字符串时不执行溢出检查（需要自己判断strDestination空间>=strSource空间）。
  • strSource：源头字符串 strDestination 目标字符串
  • 源字符串必须以 ‘\0’ 结束。
  • 目标空间必须足够大，以确保能存放源字符串。
  • 目标空间必须可变
  • 简单理解为是把原指针指向的内容拷贝到目标指针的空间上去
  • Char*在这里的作用是：当把源头数据拷贝过去的时候，我们期望目标空间发生变化，可能会使用目标空间的内容，所以需要返回的是目标空间的起始地址
  • const：变量和文件本身都有读写的权限，由const修饰时缩小变量的权限，让变量只能读不能写。也是为了提高代码的安全性。

例：

#include<string.h>
#include<stdio.h>
 
int main()
{
    
    
	char arr1[] = "abcdef";
	char arr2[] = "xxxxxx";
	
	strcpy(arr2, arr1);
 
	printf("%s\n", arr2);
 
	return 0;
}

strcmp

int strcmp ( const char * str1, const char * str2 );

定义：比较字符串
头文件：<string.h>
注：

  • 标准规定：
    第一个字符串大于第二个字符串，则返回大于0的数字
    第一个字符串等于第二个字符串，则返回0
    第一个字符串小于第二个字符串，则返回小于0的数字

  • 比较的不是字符串的长度
    比较字符串对应位置上的字符的大小/asscii码值
    如果相同就比较下一对，直到不同或遇到\0
    例：

#include<stdio.h>
#include<string.h>

int main()
{
    
    
	char arr1[] = "abcdef";
	char arr2[] = "abcdfg";

	printf("%d\n", strcmp(arr1, arr2));

	return 0;
}

strcat

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

定义：追加字符串
头文件：<string.h>

注：

  • 参数：strDestination：以\0结尾的目标字符串
    strSource：以\0结尾的源字符串
  • 源字符串必须以 ‘\0’ 结束。
  • 目标空间必须有足够的大，能容纳下源字符串的内容。
  • 目标空间必须可修改。
  • strcat函数将strSource附加到strDestination后，并以空字符结束字符串。strSource的初始字符覆盖strDestination的终止NULL字符。复制或追加字符串时不执行溢出检查。如果源字符串和目标字符串重叠，则strcat的行为未定义。

例：

#include<stdio.h>
#include<string.h>

int main()
{
    
    
	char arr1[20] = "abc";
	char arr2[] = "def"; 

	printf("%s\n", strcat(arr1, arr2));

	return 0;
}

strncpy

char * strncpy ( char * destination, const char * source, size_t count );

定义：拷贝字符串
头文件：<string.h>

注：

  • count：要复制的字符数
  • 拷贝num个字符从源字符串到目标空间。
  • 如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。

例：

#include<stdio.h>
#include<string.h>

int main()
{
    
    
	char arr1[] = "abcdef";
	char arr2[] = "xxxxxx";

	printf("%s\n", strncpy(arr2, arr1, 3));

	return 0;
}

strncmp

int strncmp ( const char * str1, const char * str2, size_t count );

定义：比较两个字符串
头文件：<string.h>

注：

  • 比较到出现另个字符不一样或者一个字符串结束或者count个字符全部比较完

例：

#include<stdio.h>
#include<string.h>

int main()
{
    
    
	char arr1[20] = "ab";
	char arr2[] = "abcdef";

	printf("%d\n", strncmp(arr1, arr2, 3));

	return 0;
}

strncat

char * strncat ( char * destination, const char * source, size_t num );

定义：追加字符串
头文件：<string.h>

注：

  • strncat函数最多将strSource的第一个count字符追加到strDest。strSource的初始字符覆盖strDest的终止null字符。如果strSource中在添加count字符之前出现空字符，strncat将追加strSource中的所有字符，直到空字符。如果count大于strSource的长度，则使用strSource的长度代替count。结果字符串以空字符结束。如果复制发生在重叠的字符串之间，则行为未定义。

例：

#include<stdio.h>
#include<string.h>

int main()
{
    
    
	char arr1[20] = "abc";
	char arr2[] = "def"; 

	printf("%s\n", strncat(arr1, arr2,1));

	return 0;
}

综上所述，可以小小的总结一下就是：
在这里插入图片描述
strstr

char *strstr( const char *string, const char *strCharSet );

定义：查找子字符串。
头文件：<string.h>

注：

  • 函数中的每一个都返回一个指向strCharSet在string中第一次出现的指针，如果strCharSet没有出现在string中，则返回NULL。如果strCharSet指向一个长度为零的字符串，则返回string。

例：

#include<stdio.h>
#include<string.h>

int main()
{
    
    
	char arr1[] = "abcdef";
	char arr2[] = "cdef";

	printf("%s\n", strstr(arr1, arr2));

	return 0;
}

strtok

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

定义：查找字符串中的下一个标记 / 通过字符串中的特殊符号分割字符串
头文件：<string.h>

注：

  • sep参数是个字符串，定义了用作分隔符的字符集合
  • 第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。
  • strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
  • strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
  • strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
  • 如果字符串中不存在更多的标记，则返回 NULL 指针。

例：

#include<stdio.h>
#include<string.h>

int main()
{
    
    
	char arr1[] = "[email protected]";

	char buf[20] = {
    
     0 };

	strcpy(buf, arr1);

	const char* sep = "@.";


	//写法①
	printf("%s\n", strtok(buf, sep));
	printf("%s\n", strtok(NULL, sep));
	printf("%s\n", strtok(NULL, sep));

	//写法②
	char* str = NULL;
	for (str = strtok(buf, sep); str != NULL; str = strtok(NULL, sep))
	{
    
    
		printf("%s\n", str);
	}

	//strtok会从字符串首字符开始寻找，找到分隔符后，会把分隔符置成\0（NULL),并取出首字符到\0之前的元素
	//下次访问的时候会从NULL的位置继续向后访问，直至再次访问到分割符，置成NULL，取出
	//其中，strtok的实现应该是有一个静态变量的指针保存着NULL的位置

	return 0;
}

strerror

char * strerror ( int errnum );

定义：返回错误码，所对应的错误信息
头文件：<string.h>

注：

  • strerro返回指向错误消息字符串的指针。
  • strerror不会打印消息，需要调用输出函数，例如printf。

例：

#include<stdio.h>
#include<string.h>
#include<errno.h>

int main()
{
    
    

	strerror(errno);//errno(错误码）:全局变量 ，需要头文件<errno.h>

	//补：
    // 0 :No error   无错误信息
    // 1 :Operation not permitted  操作被拒绝
    // 2 :No such file or directory 无文件
    // 3 :No such process  无进程
    // 4 :Interrupted function call 函数调用中断
    //...

	return 0;
}

perror

void perror( const char *string );

定义：打印错误信息
头文件：<stdio.h> or <stdlib.h>

例：

#include<stdio.h>
#include<string.h>

int main()
{
    
    

    perror("自定义提示信息");

    return 0;
}

可以简单看一下 perror vs strerror 二者的对比：
在这里插入图片描述
- memcpy

void *memcpy( void *dest, const void *src, size_t count );

定义：在缓冲区之间复制字符
头文件：<string.h>
注：

  • 函数memcpy从src的位置开始向后复制 count 个字节的数据到dest的内存位置。
  • 这个函数在遇到 ‘\0’ 的时候并不会停下来。
  • 如果src和dest有任何的重叠，复制的结果都是未定义的

例：

#include<stdio.h>
#include<string.h>

int main()
{
    
    
	int arr1[] = {
    
     1,2,3,4,5,6,7 };

	int arr2[20] = {
    
     0 };

	memcpy(arr2, arr1, 20);//单位是字节

	return 0;
}

- memcmp

int memcmp ( const void * ptr1, 
 const void * ptr2, 
 size_t num );

定义：比较两个缓冲区中的字符
头文件：<string.h>
注：

  • 比较从ptr1和ptr2指针开始的num个字节

例：

#include<stdio.h>
#include<string.h>

int main()
{
    
    
	int arr1[] = {
    
     1,2,3,4,5,6,7 };

	int arr2[20] = {
    
     1，2，3，4，5，6，0x00000007 };

	memcmp(arr2, arr1, 20);//单位是字节

	return 0;
}

- memmove

void * memmove ( void * destination, const void * source, size_t num );

定义：将一个缓冲区移动到另一个缓冲
头文件：<string.h>
注：

  • 和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
  • 如果源空间和目标空间出现重叠，就得使用memmove函数处理。

例：

#include<stdio.h>
#include<string.h>

int main()
{
    
    
	int arr1[] = {
    
     1,2,3,4,5,6,7 };

	memmove(arr1+3, arr1, 20);//可以实现重叠内存的拷贝

	return 0;
}

- memset
定义：将缓冲区设置为指定字符/初始化
头文件：<string.h>
注：

  • memset函数将dest的第一个计数字节设置为字符c。

例：

#include<stdio.h>
#include<string.h>

int main()
{
    
    
	int arr[] = {
    
     0x11111111,0x22222222,3,4,5 };

	memset(arr, 0, 20);//将arr前20个字节初始化成0

	return 0;
}

2.函数模拟实现

- strlen

#include<assert.h>
#include<stdio.h>
#include<string.h>

int my_strlen(char* str)
{
    
    
	assert(str);

	int count = 0;

	while (*str)
	{
    
    
		count++;
		str++;
	}

	return count;
}

int main()
{
    
    
	char arr[] = "abcdef";

	printf("%d\n", my_strlen(arr));

	return 0;
}

- strcpy

#include<assert.h>
#include<stdio.h>
#include<string.h>

char* my_strcpy(char* dest, const char* sour)
{
    
    
    assert(dest && sour);

    char* str = dest;

    while (*dest++ = *sour++)
    {
    
    
        ;
    }

    return str;
}

int main()
{
    
    
    char arr1[] = "xxxxxxxxxxx";
    char arr2[] = "abcdef";

    printf("%s\n", my_strcpy(arr1, arr2));

    return 0;
}

- strcmp

#include<assert.h>
#include<stdio.h>
#include<string.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()
{
    
    
    char arr1[] = "abcdef";
    char arr2[] = "bcdefg";

    printf("%d\n", my_strcmp(arr1, arr2));

    return 0;
}

- strcat

#include<assert.h>
#include<stdio.h>
#include<string.h>

char* my_strcat(char* dest, char* sour)
{
    
    
    assert(dest && sour);

    char* str = dest;
    
    while (*dest)
    {
    
    
        dest++;
    }

    while (*dest++ = *sour++)
    {
    
    
        ;
    }
    
    return dest;
}

int main()
{
    
    
    char arr1[10] = "abc";

    char arr2[] = "def";

    my_strcat(arr1, arr2);

    printf("%s\n", arr1);

    return 0;
}

- strstr

#include<assert.h>
#include<stdio.h>
#include<string.h>

char* my_strstr(const char* str1, const char* str2)
{
    
    
    assert(str1 && str2);

    const char* s1 = str1;
    const char* s2 = str2;

    const char* cur = str1;

    while (*cur)
    {
    
    
        s1 = cur;
        s2 = str2;

        while (*s1 && *s2 && (*s1 == *s2))
        {
    
    
            s1++;
            s2++;
        }

        if (*s2 == '\0')
        {
    
    
            return (char*)cur;
        }

        cur++;
    }

    return NULL;
}

int main()
{
    
    
    char arr1[] = "abcdef";
    char arr2[] = "cde";

    char* str = my_strstr(arr1, arr2);

    if (str == NULL)
    {
    
    
        printf("NO\n");
    }
    else
    {
    
    
        printf("YES\n");
    }

    return 0;
}

- memcpy

#include<assert.h>
#include<stdio.h>
#include<string.h>

void* my_memcpy(void* dest, const void* sour, size_t count)
{
    
    
	assert(dest && sour);

	void* ret = dest;

	while (count--)
	{
    
    
		*(char*)dest = *(char*)sour;
		dest = (char*)dest + 1;
		sour = (char*)sour + 1;
	}

	return dest;
}

int main()
{
    
    
	int arr1[] = {
    
     1,2,3,4,5,6,7,8,9,10 };
	int arr2[12] = {
    
     0 };

	int sz = sizeof(arr2) / sizeof(arr2[0]);

	my_memcpy(arr2, arr1, 20);//size_t 单位是字节

	int i = 0;
	for (i = 0; i < sz; i++)
	{
    
    
		printf("%d ", arr2[i]);
	}

	return 0;
}

- memove

思路：
在这里插入图片描述

void* my_memove(void* dest, const void* sour, size_t count)
{
    
    
	assert(dest && sour);

	void* ret = dest;

	if (dest < sour)
	{
    
    
		//前->后
		while (count--)
		{
    
    
			*(char*)dest = *(char*)sour;
			dest = (char*)dest + 1;
			sour = (char*)sour + 1;
		}
	}
	else
	{
    
    
		//后->前
		while (count--) //这里 count==20 为真 进入循环，又因为是后置-- ，所以count == 19 
		{
    
    
			*((char*)dest + count) = *((char*)sour + count); //这里每次进来count都会 --
		}
	}

	return ret;

}

int main()
{
    
    
	int arr[10] = {
    
     1,2,3,4,5,6,7,8,9,10 };
	              //1 2 1 2 3 4 5 8 9 10

	my_memove(arr + 2, arr, 20);//可以实现重叠内存的拷贝

	int sz = sizeof(arr) / sizeof(arr[0]);

	int i = 0;
	for (i = 0; i < sz; i++)
	{
    
    
		printf("%d ", arr[i]);
	}
	return 0;
}

猜你喜欢

转载自blog.csdn.net/m0_73969113/article/details/130909224
今日推荐
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
开源日报 | 工业开源项目OGG 1.0；姐姐，你要和我一起配置火狐吗；苹果AI遥遥落后？Fedora 40
开放签电子签章：停止新增，优化体验，前进更进（五一假期前工作）
开源日报 | 中学生开源前端动画引擎；全球首个Llama3 8B中文版开源模型；联想电脑恐出局；Linus讽刺AI炒作
周排行
浏览器对同一域名进行请求的最大并发连接数
React Hook之自定义Hook
【转】MyBatis缓存机制
-Java-泛型
自动化测试常用脚本-发送邮件
LeetCode#859: Buddy Strings
java、Python处理字符串
第二篇の博客
Hadoop伪分布式环境安装
SQL Server进阶（十一）临时表、表变量
每日归档
更多
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)
2024-04-20(6)
2024-04-19(5)
2024-04-18(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022