visual c++实现内存分配与回收，完整代码

下面是一个简单的示例，演示如何使用Visual C++实现内存分配和回收：

#include <iostream>
#include <cstdlib>

using namespace std;

int main() {
  // 分配10个整数的内存空间
  int* ptr = (int*)malloc(sizeof(int) * 10);
  
  // 检查是否成功分配内存
  if (ptr == NULL) {
    cout << "内存分配失败！" << endl;
    exit(1);
  }
  
  // 使用分配的内存空间
  for (int i = 0; i < 10; i++) {
    ptr[i] = i;
    cout << "ptr[" << i << "] = " << ptr[i] << endl;
  }
  
  // 释放分配的内存空间
  free(ptr);
  
  return 0;
}

这段代码首先使用了`malloc()`函数来分配10个整数的内存空间。如果分配失败，程序将会退出。然后，程序使用了分配的内存空间，并在最后使用`free()`函数来释放分配的内存空间。

相关问题

visual c++实现内存分配与回收，要求有退出系统，显示分区，分配分区，回收分区功能，给出完整代码

下面是一个简单的 Visual C++ 实现内存分配与回收的示例程序，包括退出系统、显示分区、分配分区和回收分区功能：

#include <iostream>
#include <iomanip>
#include <vector>

using namespace std;

struct MemoryBlock {
    int id;
    int size;
    bool is_free;
};

vector<MemoryBlock> memory;  // 内存块列表

// 初始化内存
void init_memory(int size) {
    memory.clear();
    MemoryBlock block = { 1, size, true };
    memory.push_back(block);
}

// 显示内存分区
void display_memory() {
    cout << "Memory Block List:" << endl;
    cout << setw(5) << "ID" << setw(10) << "Size" << setw(15) << "Status" << endl;
    for (int i = 0; i < memory.size(); i++) {
        MemoryBlock block = memory[i];
        cout << setw(5) << block.id << setw(10) << block.size << setw(15) << (block.is_free ? "Free" : "Used") << endl;
    }
}

// 分配内存
int allocate_memory(int size) {
    for (int i = 0; i < memory.size(); i++) {
        MemoryBlock block = memory[i];
        if (block.is_free && block.size >= size) {
            // 分配内存
            int id = memory.size() + 1;
            MemoryBlock new_block = { id, size, false };
            memory.insert(memory.begin() + i, new_block);
            // 更新剩余内存块
            int remaining_size = block.size - size;
            if (remaining_size > 0) {
                MemoryBlock remaining_block = { id + 1, remaining_size, true };
                memory.insert(memory.begin() + i + 1, remaining_block);
            }
            memory.erase(memory.begin() + i + 1);
            return id;
        }
    }
    return -1;  // 分配失败
}

// 回收内存
bool free_memory(int id) {
    for (int i = 0; i < memory.size(); i++) {
        MemoryBlock block = memory[i];
        if (block.id == id && !block.is_free) {
            // 回收内存
            block.is_free = true;
            memory[i] = block;
            // 合并空闲内存块
            int prev_index = i - 1;
            int next_index = i + 1;
            if (prev_index >= 0 && memory[prev_index].is_free) {
                MemoryBlock prev_block = memory[prev_index];
                prev_block.size += block.size;
                memory[prev_index] = prev_block;
                memory.erase(memory.begin() + i);
                i = prev_index;
            }
            if (next_index < memory.size() && memory[next_index].is_free) {
                MemoryBlock next_block = memory[next_index];
                block.size += next_block.size;
                memory[i] = block;
                memory.erase(memory.begin() + next_index);
            }
            return true;
        }
    }
    return false;  // 回收失败
}

int main() {
    int size;
    cout << "Enter memory size: ";
    cin >> size;
    init_memory(size);
    while (true) {
        display_memory();
        cout << endl;
        cout << "1. Allocate memory" << endl;
        cout << "2. Free memory" << endl;
        cout << "3. Exit system" << endl;
        int choice;
        cout << "Enter your choice: ";
        cin >> choice;
        switch (choice) {
        case 1:
            int alloc_size;
            cout << "Enter allocation size: ";
            cin >> alloc_size;
            int id = allocate_memory(alloc_size);
            if (id == -1) {
                cout << "Failed to allocate memory" << endl;
            } else {
                cout << "Allocated memory ID: " << id << endl;
            }
            break;
        case 2:
            int free_id;
            cout << "Enter memory ID to free: ";
            cin >> free_id;
            if (free_memory(free_id)) {
                cout << "Memory freed successfully" << endl;
            } else {
                cout << "Failed to free memory" << endl;
            }
            break;
        case 3:
            cout << "Exiting system..." << endl;
            return 0;
        default:
            cout << "Invalid choice" << endl;
            break;
        }
    }
    return 0;
}

该程序使用 `vector` 存储内存块列表，实现了初始化内存、显示内存分区、分配内存和回收内存的功能。在分配内存时，程序会查找空闲内存块并分配给用户请求的大小，如果剩余空间不足，则会将剩余部分分割成新的内存块。在回收内存时，程序会查找与用户请求的内存块相邻的空闲内存块并进行合并。

visual c++中用 c 语言实现内存分配与回收，要求有退出系统，显示分区，分配分区和回收分区功能，给出完整的可运行成功的代码

下面是一个简单的实现内存分配与回收的 C 语言程序，包含了退出系统、显示分区、分配分区和回收分区等功能：

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

#define MAX_SIZE 1024

// 内存分区结构体
typedef struct {
    int start;  // 分区起始地址
    int size;   // 分区大小
    int status; // 分区状态（0-空闲，1-已分配）
} MemBlock;

MemBlock mem_blocks[MAX_SIZE]; // 内存分区数组
int block_num = 0;             // 内存分区数量

// 初始化内存分区
void init_mem_blocks() {
    mem_blocks[0].start = 0;
    mem_blocks[0].size = MAX_SIZE;
    mem_blocks[0].status = 0;
    block_num = 1;
}

// 显示内存分区
void show_mem_blocks() {
    printf("Memory Blocks:\n");
    printf("Start Address\tSize\tStatus\n");
    for (int i = 0; i < block_num; i++) {
        printf("%d\t\t%d\t%d\n", mem_blocks[i].start, mem_blocks[i].size, mem_blocks[i].status);
    }
}

// 分配内存
int allocate_mem(int size) {
    int i;
    for (i = 0; i < block_num; i++) {
        if (mem_blocks[i].status == 0 && mem_blocks[i].size >= size) {
            // 找到空闲分区，分配内存
            mem_blocks[i].status = 1;
            if (mem_blocks[i].size > size) {
                // 分裂分区
                mem_blocks[block_num].start = mem_blocks[i].start + size;
                mem_blocks[block_num].size = mem_blocks[i].size - size;
                mem_blocks[block_num].status = 0;
                mem_blocks[i].size = size;
                block_num++;
            }
            return mem_blocks[i].start;
        }
    }
    return -1; // 没有可用分区
}

// 释放内存
void free_mem(int start) {
    for (int i = 0; i < block_num; i++) {
        if (mem_blocks[i].start == start) {
            // 找到要释放的分区
            mem_blocks[i].status = 0;
            if (i > 0 && mem_blocks[i-1].status == 0) {
                // 合并前面的空闲分区
                mem_blocks[i-1].size += mem_blocks[i].size;
                for (int j = i; j < block_num - 1; j++) {
                    mem_blocks[j] = mem_blocks[j+1];
                }
                block_num--;
                i--;
            }
            if (i < block_num - 1 && mem_blocks[i+1].status == 0) {
                // 合并后面的空闲分区
                mem_blocks[i].size += mem_blocks[i+1].size;
                for (int j = i+1; j < block_num - 1; j++) {
                    mem_blocks[j] = mem_blocks[j+1];
                }
                block_num--;
            }
            break;
        }
    }
}

int main() {
    int choice, size, start;
    init_mem_blocks(); // 初始化内存分区

    do {
        printf("\n1. Show memory blocks\n");
        printf("2. Allocate memory\n");
        printf("3. Free memory\n");
        printf("4. Exit\n");
        printf("Enter your choice: ");
        scanf("%d", &choice);

        switch (choice) {
            case 1:
                show_mem_blocks();
                break;
            case 2:
                printf("Enter the size to allocate: ");
                scanf("%d", &size);
                start = allocate_mem(size);
                if (start == -1) {
                    printf("Failed to allocate memory.\n");
                } else {
                    printf("Memory allocated at address %d.\n", start);
                }
                break;
            case 3:
                printf("Enter the start address to free: ");
                scanf("%d", &start);
                free_mem(start);
                printf("Memory freed.\n");
                break;
            case 4:
                printf("Exiting...\n");
                break;
            default:
                printf("Invalid choice.\n");
        }
    } while (choice != 4);

    return 0;
}

该程序使用内存分区结构体来表示内存分区，包含了分区起始地址、分区大小和分区状态等信息。在初始化内存分区时，只有一个完整的空闲分区。在分配内存时，先找到第一个满足要求的空闲分区，如果分配后剩余空间大于零，则将剩余部分分裂成一个新的空闲分区。在释放内存时，如果相邻的空闲分区可以合并，则将它们合并成一个更大的空闲分区。

该程序可以通过菜单选择功能，包括显示内存分区、分配内存、释放内存和退出系统。