void* mymemcpy( void* dest, const void* src, size_t count )

最新推荐文章于 2023-03-20 19:46:10 发布
转载 最新推荐文章于 2023-03-20 19:46:10 发布 · 1.3k 阅读 · 0
文章标签：

#null #算法 #优化

本文深入探讨了memcpy函数的高效实现方法，包括防止地址重叠、指针类型转换及优化分支预测，通过特殊技巧减少跳转和提升指令执行效率。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

void* mymemcpy( void* dest, const void* src, size_t count )
{
        assert(dest!=NULL);
        assert(src!=NULL);
        char* pdest=(char*)dest;
        char* psrc=(char*)src;
        if(psrc<pdest&&psrc+count>pdest)
        {
                psrc=psrc+count-1;
                pdest=pdest+count-1;
                while(count-->0)
                        *pdest--=*psrc--;
         }
         else
         {
                while(count-->0)
                       *pdest++=*psrc++;
          }
          return dest;
}

注意防止地址有重叠部分，还有指针类型转换，这是常规实现方法；

void* mymemcpy( void* dest, const void* src, size_t count )  

{                                                                                  

    char* d = (char*)dest;                                                 

    const char* s = (const char*)src ;                                 

    int n = (count + 7) / 8; // count > 0 assumed                   

    switch( count & 7 )                                                      

    {                                                                              

    case 0:  do {  *d++ = *s++;                                         

    case 7:        *d++ = *s++;                                           

    case 6:        *d++ = *s++;                                           

    case 5:        *d++ = *s++;                                           

    case 4:        *d++ = *s++;                                           

    case 3:        *d++ = *s++;                                           

    case 2:        *d++ = *s++;                                           

    case 1:        *d++ = *s++;                                           

               } while (--n > 0);                                             

    }                                                                              

    return dest;                                                                

}

这程序写的太变态了，乍一看，不知所云，细看一下，琢磨一下还可以：

摘自原贴:

int n = (count + 7) / 8;计算要复制的轮数（每轮复制8位），剩下的余数位数也要复制进去。
count & 7控制要复制余数位数，while (--n > 0)控制轮数。
比如count = 9，则n = 2，count & 7 = 1，要复制2轮，程序跳到case1执行，复制一位之后，再循环一轮，复制8位.

为何这么实现:引用上面帖子后面的评论:

每8个字节拷贝省7个跳转（AMD处理器内部分支预测算法是“假定全都跳转”，因此这里也就是相当于省了7个时钟周期）；把swith和do循环凑到一起，多少省几个字节的空间…… 
但使用32位或64位指令，可以得到更大的优化效果，代码还要精炼得多。 
说实在话：除非内存小到极点、并且无法增加的系统，写出这样的程序纯属作孽……



zhaozidong86
关注
memcpy / memmove模拟实现
Erica_ou的博客
07-30 384
memcopy实现   memcpy函数的功能是从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中。   需要注意的是：   memcopy只能实现源内容与目标内容在内存上没有重叠的情况，当源与目标的空间占用可能会发生重叠memcopy就不能完成正常的工作。   由于memcopy实现的是内存间的拷贝，那么它的偏移量就是一个字节，与传入的参数指针所指...
第十五讲：C语言内存函数
2301_79761834的博客
05-22 2304
第十五讲：C语言内存函数
void *memcpy(void *__dest, __const void *__src, size_t __n)
RToax
10-10 707
// SPDX-License-Identifier: GPL-2.0 /* * arch/arm/boot/compressed/string.c * * Small subset of simple string routines */ #include <linux/string.h> void *memcpy(void *__dest, __const void ...
用C语言实现my_memcpy
qq_62941717的博客
04-14 504
memcpy void* memcpy(char* dest, const void* src , size_t num); memcpy从src指向的位置开始，拷贝num个字节到dest指向的位置， 当src指向的内容为'\0'时，拷贝也不会停止。 当遇到重叠拷贝时，库memcpy函数也会拷贝成功，my_memcpy则不会。 void* 无类型指针，可以存放任何类型的地址，但不能进行解引用操作 和 加减整数操作，，，通过指针名，指针名是地址，可以比大小 #include<s...
memcpy函数
热门推荐
一新新的小白的博客
03-28 1万+
【FROM MSDN && 百科】 原型： 　void *memcpy(void *dest, const void *src, size_t n); #include<string.h> 功能：从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中 Cop...
my_memcpy()函数
LIN_xuewen的博客
03-22 714
文章目录前言一、memcpy是什么？二、my_memcpy()1.函数的实现总结 前言 memcpy()函数可以拷贝任何类型的数组，不只限于字符串，但是注意，如果拷贝的长度不能超过源头的长度，如果超过源头的长度就会越界访问，拷贝进目标数组里的可能有随机值。 一、memcpy是什么？ memcpy()函数是可以拷贝任意类型的数组，目标数组的大小一定要足够放入拷贝长度的大小。 二、my_memcpy() 1.函数的实现 代码如下（示例）： void* my_memcpy(void* dest, con..
5.编程实现memcpy.docx
11-21
void *mymemcpy(void *dest, const void *src, size_t count) { if (dest == NULL || src == NULL) return NULL; char *pdest = static_cast*>(dest); const char *psrc = static_cast<const char*>(src); int n...
memcpy的平替函数
05-13
errno_t memcpy_s(void *dest, rsize_t destsz, const void *src, rsize_t count); ``` *示例*： ```c char dest[10]; memcpy_s(dest, sizeof(dest), src, 10); //自动检测缓冲区边界[^2] ``` --- ### 二...
C++面试题集.pdf
10-10
void *mymemcpy(void *dest, const void *src, size_t count) { char* pdest = static_cast*>(dest); const char* psrc = static_cast<const char*>(src); if (pdest > psrc && pdest < psrc + count) { for (size_t...
mymemcpy
cindywry的博客
09-21 318
memcpy函数将n个字符从源对象复制到目标对象。如果源对象和目标对象重叠，则memcpy的行为是未定义的。在memcpy中，我们需要传递源和目标缓冲区的地址以及要复制的字节数(n) void* memcpy(void *dst, const void *src, Size_t num) { assert(dst !=NULL && src !=NULL &&...
C语言模拟实现memcpy函数
KamikazePilot的博客
02-22 470
memcpy函数： void *memcpy(void *dest, const void *src, size_t count); 因为这里进行的是内存拷贝，要保证这个函数能接收各种类型的数据，所以这里的函数返回值和接收类型都是void*类型，和之前模拟实现qsort函数的思路相同。 需要将传进来的指针强制类型转换成 char * 类型，因为char类型字符只存储一个字节，并且count指的需要拷贝的字节数量，转换成char*类型是最佳选择。 #define _CRT_SECURE_NO_WA
浅谈my_memcpy()函数的实现
weeks
03-22 1633
my_memcpy(str1,str2) 函数用于把str2 字符串拷贝到 str1 中去，存在两种情况的拷贝 一种是由内存覆盖，另一种是无内存覆盖 一.内存不重叠情况 二.内存重叠情况 /**************************************** * File Name : my_memcyp.c * Creat
void *memcpy(void *dst,void const *src,size_t len):从src的起始位置复制len个字节到dst的内存起始位置。可以用这种方法复制任何类型的值。
罗小黑の窝
03-21 2105
void *memcpy(void *dst,void const *src,size_t len):从src的起始位置复制len个字节到dst的内存起始位置。可以用这种方法复制任何类型的值。第3个参数指定复制值的长度（以字节计）。 对于内存覆盖的问题，只有在以下两种情况下，内存没有发生覆盖： 第一种情况： 第二种情况： 这种情况下直接拷贝就可以。 内存覆盖的话从后向前拷
【C语言】内存操作函数详解：memcpy、memmove与memset的原理与实现
卜及中的博客
03-20 621
介绍c语言中memcpy函数和memmove函数的使用与模拟实现
【C语言】memcpy函数的实现
liuxiaoqian_的专栏
05-21 2771
1函数原型 void *memcpy(void *dest, const void *src, size_t n); 2功能 从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中 3所需头文件 C语言中使用#include ; C++中使用#include 和#include 都可以。 4返回值 函数返回指向dest的指针。 5说明 1.s
void* memcpy(void* src, void* dest, size_t len)
wenmin_shu的专栏
09-30 1259
关键重点考虑：防止dest 地址和 src 地址 重合 按字节(Byte)拷贝实现的memcpy void *my_memcpy_byte(void *dst, const void *src, int n) { if (dst == NULL || src == NULL || n &lt;= 0) return NULL; char * pdst = (char *)dst; ...
c语言memcpy函数源代码,memcpy函数-memcpy函数,C语言
weixin_35878217的博客
05-21 5745
本教程分享：《memcpy函数》，memcpy是memorycopy的缩写，意为内存复制，在写C语言程序的时候，我们常常会用到它。它的函原型如下：.void*memcpy;.如果dest存在数据，将会被覆盖。memcpy函数的返回值是dest的指针。memcpy函数定义在string.h头文件里。memcpy函数memcpy指的是C和C++使用的内存拷贝函数，函数原型为void *memcpy(v...
#include "malloc.h" #include <string.h> // 内部内存池（32字节对齐，便于DMA操作） __align(32) u8 mem1base[MEM1_MAX_SIZE]; // 内存管理表（记录每个内存块的状态） u16 mem1mapbase[MEM1_ALLOC_TABLE_SIZE]; void my_mem_init(u8 memx); u8 my_mem_perused(u8 memx); // 内存管理参数常量数组 const u32 memtblsize[SRAMBANK] = {MEM1_ALLOC_TABLE_SIZE}; // 管理表大小 const u32 memblksize[SRAMBANK] = {MEM1_BLOCK_SIZE}; // 内存块大小 const u32 memsize[SRAMBANK] = {MEM1_MAX_SIZE}; // 内存池总大小 // 全局内存管理设备实例 struct _m_mallco_dev mallco_dev = { my_mem_init, // 指向初始化函数 my_mem_perused, // 指向内存使用率函数 {mem1base}, // 内存池基地址（仅内部内存） {mem1mapbase}, // 内存管理表基地址 {0} // 初始化状态（0=未初始化） }; // 内存复制函数（内部使用） void mymemcpy(void *des, void *src, u32 n) { u8 *xdes = des; u8 *xsrc = src; while(n--)*xdes++=*xsrc++; // 逐字节复制 } // 内存设置函数（内部使用） void mymemset(void *s, u8 c, u32 count) { u8 *xs = s; while(count--)*xs++=c; // 逐字节设置 } // 内存池初始化（内部调用） void my_mem_init(u8 memx) { // 清零内存管理表（初始化所有块为空闲） mymemset(mallco_dev.memmap[memx], 0, memtblsize[memx]*2); // 标记内存池已初始化 mallco_dev.memrdy[memx]=1; } // 获取内存池使用率（内部调用） u8 my_mem_perused(u8 memx) { u32 used=0; // 遍历管理表，统计已用块数 for(u32 i=0;i<memtblsize[memx];i++) { if(mallco_dev.memmap[memx][i])used++; } // 计算并返回使用百分比 return (used*100)/(memtblsize[memx]); } // 内存分配核心算法（内部调用） u32 my_mem_malloc(u8 memx,u32 size) { signed long offset=0; u32 nmemb; // 需要的内存块数 u32 cmemb=0; // 当前找到的连续空闲块数 // 检查内存池是否初始化 if(!mallco_dev.memrdy[memx])mallco_dev.init(memx); // 计算需要的内存块数（向上取整） nmemb=size/memblksize[memx]; if(size%memblksize[memx])nmemb++; // 从内存池尾部向前搜索连续空闲块 for(offset=memtblsize[memx]-1;offset>=0;offset--) { if(!mallco_dev.memmap[memx][offset])cmemb++; // 空闲块计数 else cmemb=0; // 中断连续 // 找到足够的连续空闲块 if(cmemb==nmemb) { // 标记这些块为已分配（存储分配块数） for(u32 i=0;i<nmemb;i++) { mallco_dev.memmap[memx][offset+i]=nmemb; } return (offset*memblksize[memx]); // 返回偏移地址 } } return 0XFFFFFFFF; // 分配失败（内存不足） } // 内存释放（内部调用） u8 my_mem_free(u8 memx,u32 offset) { // 检查内存池是否初始化 if(!mallco_dev.memrdy[memx]) { mallco_dev.init(memx); return 1; // 返回未初始化错误 } // 检查偏移是否有效 if(offset<memsize[memx]) { // 计算块索引 int index=offset/memblksize[memx]; // 获取该块分配时记录的块数 int nmemb=mallco_dev.memmap[memx][index]; // 释放连续的内存块（标记为空闲） for(int i=0;i<nmemb;i++) { mallco_dev.memmap[memx][index+i]=0; } return 0; // 成功 } return 2; // 偏移超出范围 } // 释放内存（用户接口） void myfree(u8 memx,void *ptr) { if(ptr==NULL)return; // 空指针检查 // 计算偏移量（地址 - 基地址） u32 offset=(u32)ptr-(u32)mallco_dev.membase[memx]; my_mem_free(memx,offset); // 调用内部释放 } // 分配内存（用户接口） void *mymalloc(u8 memx,u32 size) { // 调用内部分配函数获取偏移 u32 offset=my_mem_malloc(memx,size); if(offset==0XFFFFFFFF)return NULL; // 分配失败 else return (void*)((u32)mallco_dev.membase[memx]+offset); // 返回绝对地址 }#ifndef __MALLOC_H #define __MALLOC_H #include "stm32f10x.h" // 内存池定义：STM32F103C8T6只有内部RAM（20KB），不包含外部RAM #define SRAMIN 0 // 内部内存池编号 #define SRAMBANK 1 // 内存池数量（仅使用1个） // 内存管理参数调整（适配C8T6的20KB RAM） #define MEM1_BLOCK_SIZE 32 // 内存块大小设为32字节（提高小内存分配效率） #define MEM1_MAX_SIZE 12 * 1024 // 分配给内存管理的最大内存（12KB，保留8KB给堆栈和系统） #define MEM1_ALLOC_TABLE_SIZE (MEM1_MAX_SIZE/MEM1_BLOCK_SIZE) // 管理表大小 // 内存管理设备结构体 struct _m_mallco_dev { void (*init)(u8); // 初始化函数指针 u8 (*perused)(u8); // 内存使用率计算函数指针 u8 *membase[SRAMBANK]; // 内存池基地址数组 u16 *memmap[SRAMBANK]; // 内存池管理表基地址数组 u8 memrdy[SRAMBANK]; // 内存池初始化状态标志 }; extern struct _m_mallco_dev mallco_dev; // 声明全局内存管理设备 // 用户接口函数声明 void myfree(u8 memx, void *ptr); // 释放内存（外部调用） void *mymalloc(u8 memx, u32 size); // 分配内存（外部调用） u8 my_mem_perused(u8 memx); // 获取内存使用率（外部调用） #endif #include "RingBuffer.h" #include <stdlib.h> #include <string.h> // RingBuffer.h #ifndef min #define min(a, b) (((a) < (b)) ? (a) : (b)) #endif // 判断一个数是否是2的幂（环形缓冲区要求） static bool is_power_of_2(uint32_t x) { return (x != 0) && ((x & (x - 1)) == 0); } // 向上取整到2的幂（确保缓冲区大小符合要求） static uint32_t roundup_pow_of_two(uint32_t x) { uint32_t b = 1; // 从1开始 // 找到不小于x的最小2的幂 while (b < x) { b <<= 1; // 左移一位（相当于×2） } return b; } // 创建并初始化环形缓冲区 RingBuffer *RingBuffer_Malloc(uint32_t size) { // 分配管理结构体内存 RingBuffer *fifo = RING_BUFFER_MALLOC(sizeof(RingBuffer)); if(!fifo) return NULL; // 分配失败 // 调整大小为2的幂 if(!is_power_of_2(size)) size = roundup_pow_of_two(size); // 分配缓冲区内存 fifo->buffer = RING_BUFFER_MALLOC(size); if(!fifo->buffer) { RING_BUFFER_FREE(fifo); return NULL; // 分配失败 } // 初始化结构体成员 fifo->size = size; fifo->in = fifo->out = 0; fifo->use_dma = false; // 默认不启用DMA return fifo; } // 释放环形缓冲区 void RingBuffer_Free(RingBuffer *fifo) { if(fifo) { RING_BUFFER_FREE(fifo->buffer); // 先释放缓冲区 RING_BUFFER_FREE(fifo); // 再释放结构体 } } // 向环形缓冲区写入数据 uint32_t RingBuffer_In(RingBuffer *fifo, void *in, uint32_t len) { // 参数检查 if(!fifo || !in) return 0; // 计算实际可写入长度（取请求长度和可用空间的最小值） len = min(len, RingBuffer_Avail(fifo)); if(len == 0) return 0; // 计算第一部分长度（从写索引到缓冲区末尾） uint32_t l = min(len, fifo->size - (fifo->in & (fifo->size - 1))); // 复制第一部分数据 memcpy(fifo->buffer + (fifo->in & (fifo->size - 1)), in, l); // 复制剩余部分数据（从缓冲区开头继续） if(len > l) { memcpy(fifo->buffer, (uint8_t *)in + l, len - l); } // 原子更新写索引（缓冲区大小是2的幂，自然溢出安全） fifo->in += len; return len; // 返回实际写入字节数 } // 从环形缓冲区读取数据 uint32_t RingBuffer_Out(RingBuffer *fifo, void *out, uint32_t len) { // 参数检查 if(!fifo || !out) return 0; // 计算实际可读取长度（取请求长度和已用空间的最小值） len = min(len, RingBuffer_Len(fifo)); if(len == 0) return 0; // 计算第一部分长度（从读索引到缓冲区末尾） uint32_t l = min(len, fifo->size - (fifo->out & (fifo->size - 1))); // 复制第一部分数据 memcpy(out, fifo->buffer + (fifo->out & (fifo->size - 1)), l); // 复制剩余部分数据（从缓冲区开头继续） if(len > l) { memcpy((uint8_t *)out + l, fifo->buffer, len - l); } // 原子更新读索引 fifo->out += len; return len; // 返回实际读取字节数 } // DMA初始化（预留功能） void RingBuffer_InitDMA(RingBuffer *fifo, DMA_Channel_TypeDef *dma_tx, DMA_Channel_TypeDef *dma_rx) { if(!fifo) return; fifo->use_dma = true; // 启用DMA标志 // 此处实现DMA配置代码 // 实际项目中需配置DMA通道、地址、长度等参数 // 启用USART的DMA请求等 } #ifndef __RINGBUFFER_H #define __RINGBUFFER_H #include <stdint.h> #include <stdbool.h> #include "malloc.h" // 使用自定义内存管理 // 定义内存分配宏（使用内部内存池） #define RING_BUFFER_MALLOC(size) mymalloc(SRAMIN, size) #define RING_BUFFER_FREE(block) myfree(SRAMIN, block) // 环形缓冲区结构体 typedef struct { uint8_t *buffer; // 缓冲区基地址 uint32_t size; // 缓冲区大小（必须是2的幂） volatile uint32_t in; // 写索引（生产者位置）volatile防止编译器优化 volatile uint32_t out; // 读索引（消费者位置）volatile防止编译器优化 bool use_dma; // DMA使用标志（预留扩展） } RingBuffer; // 函数声明 RingBuffer *RingBuffer_Malloc(uint32_t size); // 创建环形缓冲区 void RingBuffer_Free(RingBuffer *fifo); // 释放环形缓冲区 uint32_t RingBuffer_In(RingBuffer *fifo, void *in, uint32_t len); // 写入数据 uint32_t RingBuffer_Out(RingBuffer *fifo, void *out, uint32_t len); // 读取数据 void RingBuffer_InitDMA(RingBuffer *fifo, DMA_Channel_TypeDef *dma_tx, DMA_Channel_TypeDef *dma_rx); // DMA初始化（预留） // 内联辅助函数 static inline void RingBuffer_Reset(RingBuffer *fifo) { fifo->in = fifo->out = 0; // 重置缓冲区 } static inline uint32_t RingBuffer_Size(RingBuffer *fifo) { return fifo->size; // 返回缓冲区容量 } static inline uint32_t RingBuffer_Len(RingBuffer *fifo) { return fifo->in - fifo->out; // 已用空间（无锁，仅适用单生产者单消费者） } static inline uint32_t RingBuffer_Avail(RingBuffer *fifo) { return fifo->size - RingBuffer_Len(fifo); // 可用空间 } static inline bool RingBuffer_IsEmpty(RingBuffer *fifo) { return (RingBuffer_Len(fifo) == 0); // 缓冲区是否为空 } static inline bool RingBuffer_IsFull(RingBuffer *fifo) { return (RingBuffer_Avail(fifo) == 0); // 缓冲区是否已满 } #endif /* __RINGBUFFER_H */ 这些代码是否正确，有没有逻辑错误，能否实现环形缓冲区
最新发布
07-16
uint32_t l = min(len, fifo->size - (fifo->out & (fifo->size - 1))); memcpy(out, ..., l); // 第一部分复制 // 剩余部分从缓冲区开头复制 if(len > l) memcpy(out + l, ..., len - l); fifo->out += ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值