C语言----string函数和memory函数

已于 2022-04-22 18:08:28 修改
阅读量758 收藏 3
点赞数
分类专栏： C 文章标签： c++
于 2021-06-07 12:21:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41420788/article/details/117652732
版权

string函数和memory函数

1.字符串函数

头文件<string.h>
strlen()
strcpy()
strcat()
strcmp()
strncpy()
strncat()
strncmp()
strstr()
strtok()
strerror()

1）strlen()

size_t strlen ( const char * str );
返回类型为无符号整形
所以当遇到strlen("hi")-strlen("hello");结果会是一个正数 可以用if(strlen("hi")-strlen("hello")>0)来验证

模拟实现strlen

#include <stdio.h>
#include <assert.h>
int my_strlen(const char* dest)
{
	int count=0;
	assert(dest);
	while(*dest!='\0')
	{
		dest++;
		count++;
	}
	return count;
}

2）strcpy()

char * strcpy ( char * destination, const char * source );
源字符串必须以 '\0' 结束。
会将源字符串中的 '\0' 拷贝到目标空间。
目标空间必须足够大，以确保能存放源字符串。
目标空间必须可变

模拟实现strcpy()

#include <stdio.h>
#include <assert.h>
char* my_strcpy(char*dest ,const char*src)
{
	assert(dest!=NULL);
	assert(src);
	char* ret=dest;
	while((*dest++ = *src++))
	{
		;
	}
	return ret;
}

3）strcat()

char * strcat ( char * destination, const char * source );
源字符串必须以 '\0' 结束。
目标空间必须有足够的大，能容纳下源字符串的内容。
目标空间必须可修改

注意：

当字符串自己给自己追加时，函数先覆盖掉目标地址的‘\0’，所以会无限追加下去，为了安全我们选用strncat()

模拟实现strcat()

#include <stdio.h>
#include <assert.h>
char* my_strcat(char* dest, const char*src)
{
	char* ret= dest;
	assert(dest && src);
	while(*dest)
	{
		dest++;
	}
	while((*dest++)=(*src++))
	{
		;
	}
	return ret;
}

4）strcmp()

int strcmp ( const char * str1, const char * str2 );
规定：
1. 第一个字符串大于第二个字符串，则返回大于0的数字
2. 第一个字符串等于第二个字符串，则返回0
3. 第一个字符串小于第二个字符串，则返回小于0的数字

模拟实现strcmp()

#include <stdio.h>
#include <assert.h>
int my_strcmp(const char* s1, const char* s2)
{
	while(*s1==*s2)
	{
		if(*s1=='\0')
		{
			return 0;
		}
		s1++;
		s2++;
	}
	// if(*s1>*s2)
	// {
	// 	return 1;
	// }
	// else
	// {
	// 	return -1;
	// }
	return *s1-*s2;
}

5）strncpy()

char * strncpy ( char * destination, const char * source, size_t num );
拷贝num个字符从源字符串到目标空间。
如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个

库函数实现

char * __cdecl strncpy (
        char * dest,
        const char * source,
        size_t count
        )
{
        char *start = dest;

        while (count && (*dest++ = *source++) != '\0')    
        /* copy string */
                count--;

        if (count)   /* pad out with zeroes */
                while (--count)
                        *dest++ = '\0';

        return(start);
}

6）strncat()

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

库函数实现

char * __cdecl strncat (
        char * front,
        const char * back,
        size_t count
        )
{
        char *start = front;

        while (*front++)
                ;
        front--;

        while (count--)
                if ((*front++ = *back++) == 0)
                        return(start);

        *front = '\0';
        return(start);
}

7）strncmp()

int strncmp ( const char * str1, const char * str2, size_t num );
比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完。

库函数实现

int __cdecl strncmp
(
    const char *first,
    const char *last,
    size_t      count
)
{
    size_t x = 0;

    if (!count)
    {
        return 0;
    }

    /*
     * This explicit guard needed to deal correctly with boundary
     * cases: strings shorter than 4 bytes and strings longer than
     * UINT_MAX-4 bytes .
     */
    if( count >= 4 )
    {
        /* unroll by four */
        for (; x < count-4; x+=4)
        {
            first+=4;
            last +=4;

            if (*(first-4) == 0 || *(first-4) != *(last-4))
            {
                return(*(unsigned char *)(first-4) - *(unsigned char *)(last-4));
            }

            if (*(first-3) == 0 || *(first-3) != *(last-3))
            {
                return(*(unsigned char *)(first-3) - *(unsigned char *)(last-3));
            }

            if (*(first-2) == 0 || *(first-2) != *(last-2))
            {
                return(*(unsigned char *)(first-2) - *(unsigned char *)(last-2));
            }

            if (*(first-1) == 0 || *(first-1) != *(last-1))
            {
                return(*(unsigned char *)(first-1) - *(unsigned char *)(last-1));
            }
        }
    }

    /* residual loop */
    for (; x < count; x++)
    {
        if (*first == 0 || *first != *last)
        {
            return(*(unsigned char *)first - *(unsigned char *)last);
        }
        first+=1;
        last+=1;
    }

    return 0;
}

8）strstr()

const char * strstr ( const char * str1, const char * str2 );
char * strstr ( char * str1, const char * str2 );
Returns a pointer to the first occurrence of str2 in str1, or a null pointer if str2 is not part of str1.
如果找到了就返回arr2的首字符地址如果没找到就返回空指针

模拟实现strstr()

#include <stdio.h>
#include <assert.h>
char* my_strstr(const char* str1,const char* str2)
{
	assert(str1 && str2);
	const char* s1=str1;
	const char* s2=str2;
	const char* cp = str1;//cp记录str1相同的首字符
	if(*s2=='\0')
	{
		return (char*)str1;
	}
	while(*cp)
	{
		s1 = cp;
		s2=str2;
		while(*s1 && *s2 && (*s1 == *s2))
		{
			s1++;
			s2++;
		}
		if(*s2 == '\0')
		{
			return (char*)cp;
		}
		cp++;
	}
	return NULL;
}

9）strtok()

char * strtok ( char * str, const char * sep );
sep参数是个字符串，定义了用作分隔符的字符集合
第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。
strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
如果字符串中不存在更多的标记，则返回 NULL 指针
注意：strtok是不可重入的，strseq是可重入的（strtok_r是strtok的可重入版本）
注：摘自Linux内核2.6.29，说明了这个函数已经不再使用，由速度更快的strsep代替

库函数实现

#include	<string.h>

#ifdef _PIC16
far char *
strtok(register far char * s1, register const char * s2)
#else /* _PIC16 */
char *
strtok(register char * s1, register const char * s2)
#endif /* _PIC16 */

{
#ifdef _PIC16
	static far char *	sp;
#else /* _PIC16 */
	static char *	sp;
#endif /* _PIC16 */

	if(!s1)
		s1 = sp;
	if(!s1)
		return NULL;
	s1 += strspn(s1, s2);	/* skip leading delimiters */
	if(!*s1)
		return sp = NULL;
	sp = s1 + strcspn(s1, s2);
	if(*sp)
		*sp++ = 0;
	else
		sp = 0;
	return s1;
}

10）strerror()

char * strerror ( int errnum );
返回错误码，所对应的错误信息
#include <errno.h>是必须包含的头文件

例：printf (“Error opening file unexist.ent: %s\n”,strerror(errno));
int errno全局错误码

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;
}

输出No such file or directory

其他

double atof( const char *string );
char转int

模拟实现

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
//VALID 表示结果合法
//INVALID 表示结果非法
enum State
{
 VALID,//0
 INVALID//1
};
//默认结果可能非法，当正确转换后再改为合法
enum State state = INVALID;
​
int my_atoi(char *str)
{
 int flag = 1;
 long long ret = 0;
 assert(str);
 state = INVALID;
  //跳过空白字符
 while(isspace(*str))
 {
 	str++;
 }
 if(*str == '\0')
 {
 	return 0;
 }
  //跳过正负号
 if(*str == '+')
 {
 	str++;
 }
 else if(*str == '-')
 {
 	flag = -1;
 	str++;
 }
  //开始转换数字字符直到非数字字符
 while(isdigit(*str))
 {
	ret = ret * 10 + flag * (*str-'0');
	if((ret > INT_MAX) || (ret < INT_MIN))
	{
		return 0;
	}
	str++;
 }
  //正常停止
 if(*str == '\0')
 {
  state = VALID;
  return (int)ret;
 }
 else
 {
    //遇到非数字字符
  return (int)ret;
 }
}
​
int main()
{
 	char *p = "-1212212121212";
 	printf("%d\n", my_atoi(p));
 	return 0;
}

2.字符操作函数

–

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 );
字符转换大小写

3.内存函数

–
memcpy()
memmove()
memcmp()
memset()

1）memcpy()

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

  1. C99规定函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
  2. 这个函数在遇到 '\0' 的时候并不会停下来。如果source和destination有任何的重叠，复制的结果都是未定义的
  3. 在VS中memcpy可以像memmove一样实现重叠部分复制，C99中并未要求此功能

模拟实现memcpy()

#include <stdio.h>
#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;
}

2）memmove()

void * memmove ( void * destination, const void * source, size_t num );
和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
如果源空间和目标空间出现重叠，就得使用memmove函数处理。

模拟实现memmove()

#include<stdio.h>
#include <assert.h>
void* my_memmove(void* dest, const void* src, size_t num)
{
	void* ret=dest;
	assert(dest && src);
	//从前向后copy(my_memcpy)
	if(dest<src)
	{
		while(num--)
		{
			*(char*)dest = *(char*)src;
			dest=(char*)dest+1;
			src=(char*)src+1;
		}
	//从后向前copy
	}
	else{
		while(num--)
		{
			*((char*)dest+num) = *((char*)src+num);
		}
	}
	return ret;
}

3）memcmp()

int memcmp ( const void * ptr1,const void * ptr2,size_t num );
比较从ptr1和ptr2指针开始的num个字节

库函数实现

#include	<string.h>
memcmp(const void *s1, const void *s2, size_t n)
{
	while(n-- != 0)  {
		if(*((const unsigned char *)s1) != *((const unsigned char *)s2))
			return *((const unsigned char *)s1) - *((const unsigned char *)s2);
		(*(const unsigned char **)&s1)++;
		(*(const unsigned char **)&s2)++;
	}
	return 0;
}

4）memset()

void * memset ( void * ptr, int value, size_t num );
设置指向ptr地址的前num个字节为value

库函数实现

#include	<string.h>
#ifdef _PIC16
far void *
memset(far void * p1, int c, register size_t n)
#else /*  _PIC16 */
void *
memset(void * p1, int c, register size_t n)
#endif /* _PIC16 */
{

#ifdef _PIC16
	register far char *	p;
#else /*  _PIC16 */
	register char *		p;
#endif /* _PIC16 */

	p = p1;
	while(n--)
		*p++ = c;
	return p1;
}
4nc414g0n
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
字符串(string)And内存函数(memory)介绍
weixin_58389786的博客
03-25 503
1.字符串(string) strlen 意义：获得字符串长度，以'\0'为结束标志。(长度不包含'\0'); 注意：函数返回值是size_t(unsinged int) 模拟实现strlen： size_t my_strlen(char *str) { size_t count = 0; while (*str) { count++; str++; } return count; } int main() { char arr2[] = "abcdef"..
C语言内存操作函数
wwhdsg的博客
10-18 1004
头文件：#include<memory.h> 1.memcpy 作用：内存拷贝 函数原型：void *memcpy( void *dest, const void *src, size_t count );
string和memset
cpongo5
09-23 201
有些东西可能很简单，我们大家不留意。string大家都在用，string可以用memset吗？我们先来看看代码 voidfun(){stringtemp;charbuff[]="123456789";while(true){memset(&temp,'\0',sizeof(string));...
【C语言】一组内存函数——memory
mmmocen的博客
11-16 1327
一组内存函数：memcpy，memmove，memcmp，memset函数的讲解及代码示例以及它的自定义函数。
C01--C语言中内存管理的基本知识
让分享成为一种习惯，让学习成为一种乐趣^_^
03-30 304
C语言的学习中，内存管理是非常重要的，在学习之前我们有必要了解一下管内存方面的基本知识。
C语言 常用内存函数
lin的博客
07-29 1246
C语言 常用内存函数 1.memset memset在头文件memory.h中 头文件memory.h为内存操作函数头文件 memset 第一个参数是内存的首地址，第二个参数是要设置的字符，第三个参数是正数，从首地址开始设置多少个字节为第二个参数 memset多用于清空字符串 用法 memset(str,’\0’,strlen(str)); 实验代码与结果： 2.memcpy 内存复制 me...
C语言realloc函数和memcpy函数
m0_66991837的博客
03-30 845
realloc 重新分配内存空间（当一开始申请的内存不够时，需要再增加内存则可以用realloc()函数实现） 用memcpy实现 #include<stdio.h> #include<stdlib.h> #include<string.h> int main(){ int *p=NULL; int *p2=NULL; //第一次申请内存空间 p=(int*)malloc(10*sizeof(i.
C语言程序设计-银行管理系统
01-18
12. **字符串操作（String Manipulation）**: 在输入和验证用户信息时，会涉及到字符串的比较和复制。 13. **内存管理（Memory Management）`: 使用`malloc()`函数动态分配内存，为新账户创建空间。 以上是C语言...
C语言课程设计报告-教务管理系统.doc
11-29
系统的代码实现主要基于C语言，使用了多个头文件，包括stdio.h、stdlib.h、string.h、time.h和memory.h等。系统定义了多个宏，包括share、manager、outmsg、logtimemsg、star_stu和stu_msg等宏，这些宏定义了不同...
C常用的LinuxC语言函数库.rar-综合文档
05-11
在Linux环境下进行C语言编程时，常常需要利用各种函数库来增强程序的功能和效率。"C常用的Linux C语言函数库"这个压缩包文件包含了关于在Linux系统中使用C语言编程时的一些常见函数库及其功能的详细文档。这些函数库...
C语言标准函数库源码，相当全的库函数源码！
09-20
2. **字符串处理（String Handling）**：如`string.h`头文件中的函数，包括`strcpy`、`strcat`、`strcmp`等，用于字符串的复制、连接和比较。 3. **内存管理（Memory Management）**：如`stdlib.h`头文件中的函数，...
Linux平台上学C语言.rar
07-09
例如，`stdio.h`包含输入输出函数，`stdlib.h`包含内存管理和类型转换函数，`string.h`则包含字符串处理函数。Linux系统还提供了丰富的系统调用，如`fork()`用于创建子进程，`read()`和`write()`用于文件操作，`...
[学习笔记]c语言中关于内存的详解
limingyang12138的博客
11-14 796
内存的概念，如何动态申请内存，如何回收内存，内存泄漏的概念及如何防止
C语言-内存操作-memory.h头文件
Willow_Spring的博客
03-30 7402
文章目录memory 头文件memset //初始化内存memcpy //内存拷贝memmove //内存移动---处理内存重叠现象memcmp //内存比较 memory 头文件 #include <memory.h> memset //初始化内存 第一个参数：初始化内存的首地址 第二个参数：将内存初始化成什么值 第三个参数：从首地址开始多少个值设置为0 int arr[10]; int x; memset(arr,0,sizeof(arr)); for(x=0;x&lt
C语言从零开始——memory初识
fsx2550553488的博客
01-12 1396
####   1，栈段内存   #### /*         1，栈段内存：函数一旦调用结束，就释放所有内部栈内存。声明周期是临时的。作用域只在花括号内 */ #include int* func(void) { int a = 1; return &a;//warning: function returns address of local var
C语言（基础）学习笔记⑧--内存管理（Memory）
weixin_44866328的博客
05-16 639
1、进程空间 1.1 源程序/源代码/进程 程序 ：是经源码编译后的可执行文件，可执行文件可以多次被执行，比如我们可以 多次打开 office。静态概念 进程：时间概念，从可执行性文件被拉起（程序加载到内存后开始执行），到结束的这一段过程，称为进程。多次打开的 wps,每打开一次都是一个进程，当我们每关闭一个 office，则表示该进程结束。动态/时间概念 进程空间：可执行性文件被拉起后，在内存中的分布情况。 1.2 进程空间 2、栈内存 ...
C语言从零开始——memory初识(2)
fsx2550553488的博客
01-12 1404
####   代码段   #### /*         代码段：存放函数代码，字符串常量。只读，不可更改 */ #include int main(void) { char buf[] = "123456"; //栈变量 char buf1[] = "123456"; printf("buf address = %p \n",buf)
c语言memory_copy函数,C语言-内存函数的实现（二）之memmove
weixin_36073654的博客
05-20 1592
关于如何实现memmove，即内存移动，就是......C语言中的内存函数有如下这些memcpymemmovememcmpmemset下面看看memmove函数memmove为什么会需要memmove函数？intmain(){intarr[]={1,2,3,4,5,6,7,8,9,10};inti=0;//想把12345拷贝到34567上去//应该打印12123...
C++ 多态
最新发布
wxk2227814847的博客
07-10 501
多态是C++语言的三大特性之一，另两个特性是封装和继承。多态性使得对象可以根据运行时的实际类型来表现出不同的行为，从而实现灵活和可扩展的设计。在软件开发过程中，多态能够提高代码的复用性和可维护性，减少重复代码，并提供更加抽象和通用的接口。本文将详细探讨C++中的多态，包括其定义、构成、虚函数、抽象类以及实现原理，帮助读者全面理解这一重要概念。
c语言memory函数的使用
07-09
在C语言中，`<string.h>`头文件提供了许多与内存操作相关的函数，其中包括`memory`函数。这个函数用于在内存中进行块的操作，例如复制、设置和比较。 下面是`memory`函数的原型： ```c void *memcpy(void *dest, ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值