用c模拟实现memmove函数

可以使用以下代码来模拟实现memmove函数：

void *memmove(void *dest, const void *src, size_t n) {
char *d = dest;
const char *s = src;
if (d < s) {
while (n--) {
*d++ = *s++;
}
} else {
char *lasts = s + (n - 1);
char *lastd = d + (n - 1);
while (n--) {
*lastd-- = *lasts--;
}
}
return dest;
}

相关问题

用c语言编写一个内存连续分配模拟程序

好的，这是一个内存连续分配模拟程序的思路：

1. 定义内存块结构体，包括起始地址、结束地址、是否被占用等信息。
2. 定义分配函数，输入需要分配的内存大小，返回分配内存的起始地址。分配时需要遍历所有未被占用的内存块，找到第一个大小足够的内存块进行分配，并标记为已占用。
3. 定义释放函数，输入内存块的起始地址，将该内存块标记为未占用。
4. 定义打印函数，遍历所有内存块，输出每个内存块的起始地址、结束地址、大小和是否被占用等信息。

以下是一个基于这个思路的 C 语言代码示例：

#include <stdio.h>
#include <stdlib.h>

#define MEM_SIZE 1024  // 内存大小
#define BLOCK_SIZE sizeof(struct block)  // 内存块大小

struct block {
    void *start;  // 起始地址
    void *end;    // 结束地址
    int size;     // 大小
    int used;     // 是否被占用，1 表示已占用，0 表示未占用
};

void *mem_start;  // 内存起始地址
struct block *mem_blocks;  // 内存块数组
int mem_blocks_num;  // 内存块数量

void init_mem() {
    mem_start = malloc(MEM_SIZE);  // 分配内存
    mem_blocks_num = 1;
    mem_blocks = malloc(mem_blocks_num * BLOCK_SIZE);  // 初始化内存块数组
    mem_blocks[0].start = mem_start;
    mem_blocks[0].end = mem_start + MEM_SIZE;
    mem_blocks[0].size = MEM_SIZE;
    mem_blocks[0].used = 0;
}

void *alloc_mem(int size) {
    int i;
    void *start = NULL;
    for (i = 0; i < mem_blocks_num; i++) {
        if (!mem_blocks[i].used && mem_blocks[i].size >= size) {
            start = mem_blocks[i].start;
            mem_blocks[i].used = 1;
            if (mem_blocks[i].size > size) {
                // 如果内存块大小大于所需大小，则拆分成两个内存块
                mem_blocks_num++;
                mem_blocks = realloc(mem_blocks, mem_blocks_num * BLOCK_SIZE);
                memmove(&mem_blocks[i+2], &mem_blocks[i+1], (mem_blocks_num-i-2) * BLOCK_SIZE);
                mem_blocks[i+1].start = start + size;
                mem_blocks[i+1].end = mem_blocks[i].end;
                mem_blocks[i+1].size = mem_blocks[i].size - size;
                mem_blocks[i+1].used = 0;
                mem_blocks[i].end = start + size;
                mem_blocks[i].size = size;
            }
            break;
        }
    }
    return start;
}

void free_mem(void *start) {
    int i;
    for (i = 0; i < mem_blocks_num; i++) {
        if (mem_blocks[i].start == start) {
            mem_blocks[i].used = 0;
            // 如果前一个内存块未被占用，则合并成一个内存块
            if (i > 0 && !mem_blocks[i-1].used) {
                mem_blocks[i-1].end = mem_blocks[i].end;
                mem_blocks[i-1].size += mem_blocks[i].size;
                mem_blocks_num--;
                memmove(&mem_blocks[i], &mem_blocks[i+1], (mem_blocks_num-i) * BLOCK_SIZE);
                i--;
            }
            // 如果后一个内存块未被占用，则合并成一个内存块
            if (i < mem_blocks_num-1 && !mem_blocks[i+1].used) {
                mem_blocks[i].end = mem_blocks[i+1].end;
                mem_blocks[i].size += mem_blocks[i+1].size;
                mem_blocks_num--;
                memmove(&mem_blocks[i+1], &mem_blocks[i+2], (mem_blocks_num-i-1) * BLOCK_SIZE);
            }
            break;
        }
    }
}

void print_mem() {
    int i;
    printf("Memory:\n");
    for (i = 0; i < mem_blocks_num; i++) {
        printf("%p-%p %d bytes %s\n",
               mem_blocks[i].start,
               mem_blocks[i].end,
               mem_blocks[i].size,
               mem_blocks[i].used ? "(used)" : "(free)");
    }
}

int main() {
    init_mem();

    void *p1 = alloc_mem(100);
    void *p2 = alloc_mem(200);
    void *p3 = alloc_mem(300);
    print_mem();

    free_mem(p2);
    print_mem();

    void *p4 = alloc_mem(150);
    print_mem();

    free_mem(p1);
    free_mem(p3);
    free_mem(p4);
    print_mem();

    free(mem_start);
    free(mem_blocks);
    return 0;
}

这个程序使用了一个结构体数组来表示内存块，分配时遍历数组找到第一个空闲的内存块进行分配，释放时将指定内存块标记为空闲，并尝试将相邻的空闲内存块合并成一个内存块，打印时输出所有内存块的信息。

用C语言模拟实现memmove

memmove()函数是C语言中的标准库函数，它可以将一块内存中的数据复制到另一块内存中，与memcpy()函数不同的是，memmove()函数可以处理两个内存区域重叠的情况。

下面是用C语言模拟实现memmove()函数的代码：

void *memmove(void *dest, const void *src, size_t n) {
    char *d = dest;
    const char *s = src;
    if (d > s) {
        while (n--) {
            *(d + n) = *(s + n);
        }
    } else if (d < s) {
        for (size_t i = 0; i < n; i++) {
            *(d + i) = *(s + i);
        }
    }
    return dest;
}

该函数的实现方法为，先将要复制的目标地址和源地址分别强制转换为char型指针，这是因为char型指针是一个字节一个字节进行存储的，可以直接进行指针运算。

然后，判断目标地址和源地址的位置关系，如果目标地址在源地址之后，就从最后一个字节开始向前复制；否则，就从第一个字节开始向后复制。最后，返回目标地址的指针。

这样就实现了用C语言模拟memmove()函数的功能。