一、设计目的、功能与要求
1．采用段式管理方案实施内存分配和回收。能够处理以下的情形：
⑴ 在完成指定分配算法基础上还可以选择其它分配算法进行模拟设计；
⑵ 能够输入给定的内存大小，进程的个数，每个进程的段数及段大小；
⑶ 当某进程提出申请空间的大小后，显示能否满足申请，以及为该进程分配资源后有关内存空间使用的情况；
⑷ 显示回收后内存空间的使用情况（注意回收后的合并）。
2．设计报告内容应说明：
⑴ 目的、功能与要求（明确该选题的作用并列出所选功能及要求）；
⑵ 问题的详细描述、需求分析（分析说明相关算法原理及具体的实验内容）；
⑶ 数据结构、功能设计（给出功能结构图、处理流程图）；
⑷ 开发平台及源程序的主要部分（对主要代码段附文字注释）；
⑸ 测试用例，运行结果与运行情况分析；
⑹ 自我评价与总结：
i）你认为你完成的设计哪些地方做得比较好或比较出色；
ii）什么地方做得不太好，以后如何改正；
iii）从本设计得到的收获（在编写，调试，执行过程中的经验和教训）；
v）完成本题是否有其他方法（如果有，简要说明该方法）；
v）对实验题的评价和改进意见，请你推荐设计题目。
二、源代码及运行结果
memory_manager.h
#pragma once
#include<vector>
#include<string>
#include<algorithm>
#include<iostream>
using namespace std;
// 每个进程的段
struct Segment {
int segment_id; // 段号
int start_address; // 段起始地址
int size; // 段长
};
// 进程
struct Process {
string process_id; // 进程名
vector<Segment> segment_table; // 进程的段表
};
// 空闲区
struct FreePartition {
int start_address; // 空闲区起始地址
int size; // 空闲区大小
};
// 内存空间
struct MemoryBlock {
int start_address; // 分区首地址
int end_address; // 分区尾地址
int size; // 分区大小
string status; // 分区状态
string process_id; // 被占用的进程号，若没被占用则为空字符
string segment_id; // 被占用的对应进程的段号，若没被占用则为空字符
};
// 内存情况表和分区空闲表和进程表
int total_memory, process_count;
vector<Process> Processes;
vector<FreePartition> FreePartitions;
vector<MemoryBlock> MemoryBlocks;
// 通用函数声明
void showMenu(string algorithmType);
void clearAll(vector<MemoryBlock>& MemoryBlocks, vector<FreePartition>& FreePartitions, vector<Process> Processes);
void clearFreePartition(vector<FreePartition>& FreePartitions);
void printInfo();
bool compare(const FreePartition& lhs, const FreePartition& rhs, string algorithm);
void sortBySize(vector<FreePartition>& FreePartitions, string algorithmType);
void getFreePartitons(std::vector<FreePartition>& FreePartitions, std::vector<MemoryBlock>& MemoryBlocks, string algorithmType);
void allocatePartition(vector<MemoryBlock>& MemoryBlocks, vector<FreePartition>& FreePartitions, string algorithmType);
void deAllocatePartition(vector<MemoryBlock>& MemoryBlocks, vector<FreePartition>& FreePartitions, string algorithmType);
void init();
void updaetSegmentTable(string type, Process p, Segment s);
// 动态分区算法函数说明
void dynamicPartition(string algorithm);memory_manager.cpp
#include"memory_manager.h"
int main() {
int option;
do {
cout << "================== 段式存储管理的分配与回收 ==================\n";
cout << "1. 初始化 \n2. 最先适应算法 \n3. 最佳适应算法\n4. 最坏适应算法\n5. 退出\n";
cout << "请输入你的选择: ";
cin >> option;
cout << "==============================================" << endl;
switch (option) {
case 1: {
system("cls");
init();
break;
}
case 2: {
system("cls");
dynamicPartition("最先适应算法");
break;
}
case 3: {
system("cls");
dynamicPartition("最佳适应算法");
break;
}
case 4:
system("cls");
dynamicPartition("最坏适应算法");
break;
case 5:
cout << "程序退出！" << endl;
return 0;
break;
default:
system("cls");
cout << "无效输入，请重新输入！" << endl;
break;
}
} while (option != 5);
return 0;
}
// 动态分区算法
void dynamicPartition(string algorithm) {
int option;
do {
showMenu(algorithm);
cin >> option;
cout << "==============================================" << endl;
switch (option)
{
case 1:
sortBySize(FreePartitions, algorithm);
printInfo();
break;
case 2:
allocatePartition(MemoryBlocks, FreePartitions, algorithm);
break;
case 3:
deAllocatePartition(MemoryBlocks, FreePartitions, algorithm);
break;
case 4:
system("cls");
return;
default:
system("cls");
cout << "无效输入，请重新输入！" << endl;
break;
}
} while (option != 4);
}
// 输出菜单
void showMenu(string algorithmType) {
cout << "================ " << algorithmType << " ================\n";
cout << "1. 查看每个进程的段表，内存使用情况以及空闲区表 \n2. 分配内存\n3. 回收内存\n4. 返回\n";
cout << "请输入你的选择: ";
}
// 初始化内存空间和空闲分区表和进程表
void init() {
clearAll(MemoryBlocks, FreePartitions,Processes);
cout << "=================== 初始化 ===================\n";
cout << "请输入内存总大小：";
cin >> total_memory;
cout << "请输入进程的个数：";
cin >> process_count;
// 初始化进程表
for (int i = 0; i < process_count; i++)
{
// 初始化每个进程的段表
Process process;
string process_id;
cout << "请输入第 " << i + 1 << " 个进程的进程名：";
cin >> process_id;
process.process_id = process_id;
int segmentCount;
cout << "请输入进程 " + process.process_id << " 的段数：";
cin >> segmentCount;
// 初始化段表
for (size_t i = 0; i < segmentCount; i++)
{
int start_address, segmentSize;
Segment segment;
MemoryBlock m;
segment.segment_id = i + 1;
cout << "请输入进程 " + process.process_id << " 的"<<"第 "<< segment.segment_id <<" 段的起始地址和大小：";
cin >> start_address >> segmentSize;
segment.start_address = start_address;
segment.size = segmentSize;
// 初始化内存块
m = { segment.start_address, segment.start_address + segmentSize - 1,segmentSize ,"占用",process.process_id,to_string(segment.segment_id) };
MemoryBlocks.push_back(m);
process.segment_table.push_back(segment);
}
Processes.push_back(process);
}
sort(MemoryBlocks.begin(), MemoryBlocks.end(), [](const MemoryBlock& a, const MemoryBlock& b) {
return a.start_address < b.start_address;
});
// 添加不在头尾的空闲内存块
vector<MemoryBlock> temp;
for (size_t i = 0; i < MemoryBlocks.size() - 1; i++) {
int free_start_address = MemoryBlocks[i].end_address + 1;
int free_end_address = MemoryBlocks[i + 1].start_address - 1;
if (free_start_address < free_end_address) {
MemoryBlock free_memory_block = { free_start_address, free_end_address, free_end_address - free_start_address + 1, "空闲", "", "" };
temp.push_back(free_memory_block);
}
}
MemoryBlocks.insert(MemoryBlocks.end(), temp.begin(), temp.end());
sort(MemoryBlocks.begin(), MemoryBlocks.end(), [](const MemoryBlock& a, const MemoryBlock& b) {
return a.start_address < b.start_address;
});
// 添加最后一块空闲内存块
if (MemoryBlocks.back().end_address != total_memory - 1) {
MemoryBlock m = { MemoryBlocks.back().end_address + 1, total_memory - 1, total_memory - MemoryBlocks.back().end_address - 1, "空闲", "", "" };
MemoryBlocks.push_back(m);
}
// 添加从0开始的空闲内存块
if (MemoryBlocks.front().start_address != 0) {
MemoryBlock m = { 0, MemoryBlocks.front().start_address - 1, MemoryBlocks.front().start_address, "空闲", "", "" };
MemoryBlocks.push_back(m);
}
sort(MemoryBlocks.begin(), MemoryBlocks.end(), [](const MemoryBlock& a, const MemoryBlock& b) {
return a.start_address < b.start_address;
});
// 获取空闲区
for (MemoryBlock m : MemoryBlocks) {
if (m.status == "空闲")
{
FreePartition f = { m.start_address,m.size };
FreePartitions.push_back(f);
}
}
printInfo();
}
// 清空内存空间和空闲分区表和进程表
void clearAll(vector<MemoryBlock>& MemoryBlocks, vector<FreePartition>& FreePartitions,vector<Process> Processes) {
MemoryBlocks.clear();
FreePartitions.clear();
Processes.clear();
}
// 清空空闲分区表
void clearFreePartition(vector<FreePartition>& FreePartitions) {
FreePartitions.clear();
}
//
// 打印内存使用情况以及空闲区表
void printInfo() {
for (Process p : Processes) {
cout << "************** " << p.process_id <<"进程的段表" << " **************";
cout << "\n段号\t\t段起始地址\t\t段长" << endl;
for (size_t i = 0; i < p.segment_table.size(); i++)
{
cout << p.segment_table[i].segment_id << "\t\t" << p.segment_table[i].start_address << "\t\t\t" << p.segment_table[i].size << endl;
}
cout << endl << endl;
}
cout << "************** " << "内存空间使用情况" << " **************";
cout << "\n区号\t\t首地址\t\t尾地址\t\t大小\t\t状态\t\t占用进程号\t\t占用段号" << endl;
for (int i = 0; i < MemoryBlocks.size(); i++) {
cout << i << "\t\t" << MemoryBlocks[i].start_address << "\t\t"
<< MemoryBlocks[i].end_address << "\t\t" << MemoryBlocks[i].size << "\t\t"
<< MemoryBlocks[i].status << "\t\t" << MemoryBlocks[i].process_id <<"\t\t\t"
<< MemoryBlocks[i].segment_id << endl;
}
cout << endl;
if (FreePartitions.size() > 0) {
cout << "****************** " << "空闲区表" << " ******************\n";
cout << "首地址\t\t大小" << endl;
for (FreePartition f : FreePartitions) {
cout << f.start_address << "\t\t" << f.size << endl;
}
cout << endl;
}
else {
cout << "空闲区表为空！" << endl;
}
cout << "==============================================" << endl << endl;
}
// 不同算法的比较规则
bool compare(const FreePartition& lhs, const FreePartition& rhs, string algorithmType) {
if (algorithmType == "最佳适应算法")
return lhs.size < rhs.size;
else if (algorithmType == "最坏适应算法")
return lhs.size > rhs.size;
else if (algorithmType == "最先适应算法")
return lhs.start_address <= rhs.start_address;
return false;
}
void sortBySize(vector<FreePartition>& FreePartitions, string algorithmType) {
sort(FreePartitions.begin(), FreePartitions.end(),
[algorithmType](const FreePartition& lhs, const FreePartition& rhs) {
return compare(lhs, rhs, algorithmType);
});
}
// 从内存表中获取空闲区
void getFreePartitons(vector<FreePartition>& FreePartitions, vector<MemoryBlock>& MemoryBlocks, string algorithmType)
{
// 修改空闲区表，并重新排序
clearFreePartition(FreePartitions);
for (MemoryBlock m : MemoryBlocks) {
if (m.status == "空闲")
{
FreePartition f = { m.start_address,m.size };
FreePartitions.push_back(f);
}
}
sortBySize(FreePartitions, algorithmType);
}
//分配分区
void allocatePartition(vector<MemoryBlock>& MemoryBlocks, vector<FreePartition>& FreePartitions, string algorithmType) {
Process p;
Segment s;
cout << endl << endl;
cout << "================== 分配分区 ==================" << endl;
cout << "请输入要为哪个进程的哪个段分配多大的内存：";
cin >> p.process_id >> s.segment_id >> s.size;
cout << endl;
sortBySize(FreePartitions, "最坏适应算法");
if (s.size > FreePartitions[0].size) {
cout << "所需内存大于空闲区的最大内存，无法分配！" << endl;
}
if (FreePartitions.size() == 0) {
cout << "空闲分区表为空！" << endl;
printInfo();
return;
}
else {
sortBySize(FreePartitions, algorithmType);
for (FreePartition f : FreePartitions) {
int target_start_address = f.start_address;
auto m_it = find_if(MemoryBlocks.begin(), MemoryBlocks.end(),
[target_start_address](const MemoryBlock& mb) {
return mb.start_address == target_start_address;
});
if (f.size > s.size) {
if (m_it != MemoryBlocks.end()) {
// 修改进程表和段表
s.start_address = m_it->start_address;
updaetSegmentTable("添加段", p, s);
// 修改内存表
int temp = m_it->end_address;
m_it->end_address = m_it->start_address + s.size - 1;
m_it->size = s.size;
m_it->status = "占用";
m_it->process_id = p.process_id;
m_it->segment_id = to_string(s.segment_id);
// 修改空闲表
MemoryBlock m = { m_it->end_address + 1,temp,temp - m_it->start_address - s.size + 1,"空闲","",""};
MemoryBlocks.insert(m_it + 1, m);
}
break;
}
else if (f.size == s.size) {
// 修改进程表和段表
s.start_address = m_it->start_address;
updaetSegmentTable("添加段", p, s);
m_it->status = "占用";
m_it->process_id = p.process_id;
m_it->segment_id = to_string(s.segment_id);
break;
}
}
}
getFreePartitons(FreePartitions, MemoryBlocks, algorithmType);
sortBySize(FreePartitions, algorithmType);
printInfo();
}
//回收分区
void deAllocatePartition(vector<MemoryBlock>& MemoryBlocks, vector<FreePartition>& FreePartitions, string algorithmType) {
int id;
cout << endl << endl;
Process p;
Segment s;
cout << "================== 回收分区 ==================" << endl;
cout << "请输入要回收哪个进程的哪个段：";
cin >> p.process_id >> s.segment_id;
// 在内存空间找到对应进程号和段号的位置1
auto m_it = find_if(MemoryBlocks.begin(), MemoryBlocks.end(),
[p, s](const MemoryBlock& mb) {
return mb.process_id == p.process_id && mb.segment_id == to_string(s.segment_id);
});
// 更新段表
updaetSegmentTable("删除段", p, s);
// 释放位置不在第一个分区也不在最后一个分区
if (m_it != MemoryBlocks.end() - 1 && m_it != MemoryBlocks.begin()) {
// 修改内存空间
// 上下能合并
if ((m_it - 1)->status == "空闲" && (m_it + 1)->status == "空闲") {
(m_it - 1)->size = (m_it + 1)->end_address - (m_it - 1)->start_address + 1;
(m_it - 1)->end_address = (m_it + 1)->end_address;
auto next_it = m_it + 1;
MemoryBlocks.erase(m_it, next_it + 1);
}
// 上不能合并，下能合并
else if ((m_it - 1)->status != "空闲" && (m_it + 1)->status == "空闲") {
m_it->size = (m_it + 1)->end_address - m_it->start_address + 1;
m_it->end_address = (m_it + 1)->end_address;
m_it->status = "空闲";
m_it->process_id = "";
m_it->segment_id = "";
MemoryBlocks.erase(m_it + 1);
}
// 上能合并，下不能合并
else if ((m_it - 1)->status == "空闲" && (m_it + 1)->status != "空闲") {
(m_it - 1)->size = m_it->end_address - (m_it - 1)->start_address + 1;
(m_it - 1)->end_address = m_it->end_address;
MemoryBlocks.erase(m_it);
}
// 上下都不能合并
else {
m_it->status = "空闲";
m_it->process_id = "";
m_it->segment_id = "";
}
}
// 释放位置在第一个分区
else if (m_it == MemoryBlocks.begin()) {
// 下能合并
if ((m_it + 1)->status == "空闲") {
m_it->size = (m_it + 1)->end_address - m_it->start_address + 1;
m_it->end_address = (m_it + 1)->end_address;
m_it->status = "空闲";
m_it->process_id = "";
m_it->segment_id = "";
MemoryBlocks.erase(m_it + 1);
}
// 下不能合并
else
{
m_it->status = "空闲";
m_it->process_id = "";
m_it->segment_id = "";
}
}
// 释放位置在最后一个分区
else if (m_it == MemoryBlocks.end() - 1) {
// 上能合并
if ((m_it - 1)->status == "空闲") {
(m_it - 1)->size = m_it->end_address - (m_it - 1)->start_address + 1;
(m_it - 1)->end_address = m_it->end_address;
MemoryBlocks.erase(m_it);
}
// 上不能合并
else
{
m_it->status = "空闲";
m_it->process_id = "";
m_it->segment_id = "";
}
}
getFreePartitons(FreePartitions, MemoryBlocks, algorithmType);
sortBySize(FreePartitions, algorithmType);
printInfo();
}
void updaetSegmentTable(string type,Process p,Segment s) {
if (type == "添加段") {
// 如果进程表中已有该进程则只需修改段表,否则在进程表中增添新进程
auto p_it = find_if(Processes.begin(), Processes.end(), [&](const Process& temp) { return temp.process_id == p.process_id; });
if (p_it != Processes.end()) {
p_it->segment_table.push_back(s);
}
else {
p.segment_table.push_back(s);
Processes.push_back(p);
}
}
else{
auto p_it = find_if(Processes.begin(), Processes.end(), [&](const Process& temp) { return temp.process_id == p.process_id; });
if (p_it != Processes.end()) {
auto m_it = find_if(p_it->segment_table.begin(), p_it->segment_table.end(), [&](const Segment& temp) { return temp.segment_id == s.segment_id; });
p_it->segment_table.erase(m_it);
}
else {
cout << "要释放的段不存在！" << endl;
}
}
}运行结果演示视频：
模拟设计段式存储管理的分配与回收
三、课程设计完整资料（包括实验报告等）
链接: https://pan.baidu.com/s/1W9X3aUWLyttjXPzRHjZpdQ?pwd=d3uw 提取码: d3uw 复制这段内容后打开百度网盘手机App，操作更方便哦
5091
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
