《计算机操作系统》第四章-存储器管理

前言

大家好！今天给大家带来《计算机操作系统》第四章 ------ 存储器管理的全面解析。存储器管理是操作系统核心模块之一，直接决定了程序能否高效、安全地运行。本文会从基础概念到代码实现，用通俗易懂的语言拆解每个知识点，还会附上可直接运行的 C++代码，帮助大家彻底吃透这一章！

4.1 存储器的层次结构

核心概念

存储器的层次结构是为了解决「速度快的存储器贵、容量小，容量大的存储器速度慢、便宜」的矛盾，操作系统通过分层管理让 CPU 既能快速访问数据，又能使用大容量存储。

层次架构

核心要点

1. 越靠近 CPU 的存储层级，速度越快、容量越小、单位成本越高；
2. 操作系统的存储器管理主要针对主存储器（内存） ，虚拟存储器是内存 + 外存的抽象层；
3. 层次结构的核心目标：用低成本实现接近高速缓存的访问速度、接近硬盘的存储容量。

---

4.2 程序的装入和链接

核心概念

程序从「磁盘上的可执行文件」到「内存中运行的进程」，需要经过装入 （Load）和链接（Link）两个核心步骤：

• 链接：将多个目标文件、库文件合并为一个可执行文件（静态链接 / 动态链接）；
• 装入：将可执行文件加载到内存，分配地址空间（绝对装入 / 可重定位装入 / 动态运行时装入）。

装入流程

代码实现（C++98 模拟程序装入过程）

#include <iostream>
#include <vector>
#include <string>
// 严格兼容C++98标准，无任何C++11特性
using namespace std;

// 定义目标文件结构体
struct ObjectFile {
    string name;       // 目标文件名
    vector<int> code;  // 机器码（简化为整数数组）
    vector<int> data;  // 数据段（简化为整数数组）
};

// 定义可执行文件结构体
struct ExecFile {
    string name;               // 可执行文件名
    vector<int> text_segment;  // 代码段
    vector<int> data_segment;  // 数据段
    int base_addr;             // 装入的基地址
};

// 静态链接：合并多个目标文件为可执行文件（C++98兼容版）
ExecFile static_link(const vector<ObjectFile>& objs, const string& exec_name) {
    ExecFile exec;
    exec.name = exec_name;
    exec.base_addr = 0; // 初始基地址为0
    
    // C++98不支持范围for循环，改用下标循环
    for (size_t i = 0; i < objs.size(); ++i) {
        const ObjectFile& obj = objs[i];
        // 合并代码段
        exec.text_segment.insert(exec.text_segment.end(), obj.code.begin(), obj.code.end());
        // 合并数据段
        exec.data_segment.insert(exec.data_segment.end(), obj.data.begin(), obj.data.end());
    }
    
    return exec;
}

// 可重定位装入：将可执行文件加载到指定内存地址
void relocate_load(ExecFile& exec, int new_base_addr) {
    exec.base_addr = new_base_addr;
    cout << "可执行文件[" << exec.name << "]装入内存，基地址：" << new_base_addr << endl;
    // 模拟地址重定位：代码段地址 = 基地址 + 偏移量
    cout << "代码段地址重定位结果：" << endl;
    for (size_t i = 0; i < exec.text_segment.size(); ++i) {
        int old_addr = exec.text_segment[i];
        exec.text_segment[i] = new_base_addr + static_cast<int>(i); // 偏移量为索引
        cout << "  原地址：" << old_addr << " → 新地址：" << exec.text_segment[i] << endl;
    }
}

int main() {
    // 1. 模拟编译生成目标文件（C++98兼容：用push_back初始化vector）
    ObjectFile obj1, obj2;
    obj1.name = "main.o";
    // 替代列表初始化：逐个添加元素
    obj1.code.push_back(1001);
    obj1.code.push_back(1002);
    obj1.code.push_back(1003);
    obj1.data.push_back(10);
    obj1.data.push_back(20);
    obj1.data.push_back(30);
    
    obj2.name = "utils.o";
    obj2.code.push_back(2001);
    obj2.code.push_back(2002);
    obj2.data.push_back(40);
    obj2.data.push_back(50);

    // 2. 静态链接
    vector<ObjectFile> objs;
    objs.push_back(obj1);
    objs.push_back(obj2);
    ExecFile exec = static_link(objs, "app.exe");
    cout << "静态链接完成，生成可执行文件：" << exec.name << endl;

    // 3. 可重定位装入（基地址设为0x1000）
    relocate_load(exec, 0x1000);

    return 0;
}

代码说明

1. 用ObjectFile模拟编译后的目标文件，包含代码段和数据段；
2. static_link函数模拟静态链接，合并多个目标文件的段；
3. relocate_load函数模拟可重定位装入，将可执行文件加载到指定基地址并完成地址重定位；
4. 代码完全兼容 C++98 标准，可直接编译运行（g++ 编译命令：g++ -std=c++98 load_link.cpp -o load_link）。

运行结果

---

4.3 连续分配存储管理方式

核心概念

连续分配是最基础的内存管理方式，要求给进程分配连续的内存空间，主要分为：

• 单一连续分配：内存分为系统区和用户区，仅支持单进程（早期 OS）；
• 固定分区分配：将内存划分为多个固定大小的分区，每个分区装一个进程；
• 动态分区分配：根据进程大小动态划分连续内存（首次适应 / 最佳适应 / 最坏适应算法）。

动态分区分配流程

代码实现（C++98 模拟动态分区分配）

#include <iostream>
#include <vector>
#include <string>
#include <climits>
#include <algorithm>  // sort函数必需的头文件
// 严格遵循C++98标准
using namespace std;

// 定义空闲分区结构体
struct FreeBlock {
    int start_addr;  // 分区起始地址
    int size;        // 分区大小
    FreeBlock(int s, int sz) : start_addr(s), size(sz) {}
};

// ========== 关键修改：将比较结构体移到全局作用域 ==========
// C++98不允许函数内局部类型作为sort的模板参数
struct CompareBlock {
    bool operator()(const FreeBlock& a, const FreeBlock& b) {
        return a.start_addr < b.start_addr;
    }
};

// 定义进程结构体
struct Process {
    string pid;      // 进程ID
    int size;        // 所需内存大小
    int alloc_addr;  // 分配的起始地址
    Process(string p, int sz) : pid(p), size(sz), alloc_addr(-1) {}
};

// 空闲分区表（全局）
vector<FreeBlock> free_blocks;

// 首次适应算法：找第一个足够大的空闲分区
int first_fit(int req_size) {
    // 显式转换size_t为int，避免无符号/有符号比较警告
    for (int i = 0; i < static_cast<int>(free_blocks.size()); ++i) {
        if (free_blocks[i].size >= req_size) {
            return i; // 返回分区索引
        }
    }
    return -1; // 无可用分区
}

// 最佳适应算法：找最小的足够大的空闲分区
int best_fit(int req_size) {
    int best_idx = -1;
    int min_size = INT_MAX;
    // 显式转换size_t为int，避免警告
    for (int i = 0; i < static_cast<int>(free_blocks.size()); ++i) {
        if (free_blocks[i].size >= req_size && free_blocks[i].size < min_size) {
            min_size = free_blocks[i].size;
            best_idx = i;
        }
    }
    return best_idx;
}

// 分配内存
bool allocate_memory(Process& p, int algo_type) {
    int idx = -1;
    // 0=首次适应，1=最佳适应
    if (algo_type == 0) {
        idx = first_fit(p.size);
    } else if (algo_type == 1) {
        idx = best_fit(p.size);
    }

    if (idx == -1) {
        cout << "进程[" << p.pid << "]分配内存失败：无足够空闲分区" << endl;
        return false;
    }

    // 分配内存
    FreeBlock& block = free_blocks[idx];
    p.alloc_addr = block.start_addr;
    cout << "进程[" << p.pid << "]分配成功：起始地址=" << block.start_addr 
         << "，大小=" << p.size << endl;

    // 更新空闲分区表（分割分区）
    if (block.size > p.size) {
        // 剩余空间形成新的空闲分区
        free_blocks.push_back(FreeBlock(block.start_addr + p.size, block.size - p.size));
    }
    // 删除已分配的分区
    free_blocks.erase(free_blocks.begin() + idx);

    return true;
}

// 释放内存并合并相邻空闲分区
void free_memory(Process& p) {
    if (p.alloc_addr == -1) {
        cout << "进程[" << p.pid << "]未分配内存，无需释放" << endl;
        return;
    }

    // 添加释放的分区到空闲表
    free_blocks.push_back(FreeBlock(p.alloc_addr, p.size));
    cout << "进程[" << p.pid << "]释放内存：起始地址=" << p.alloc_addr 
         << "，大小=" << p.size << endl;
    p.alloc_addr = -1;

    // 合并相邻空闲分区（简化版：按起始地址排序后合并）
    // ========== 关键修改：使用全局的CompareBlock ==========
    sort(free_blocks.begin(), free_blocks.end(), CompareBlock());

    // 合并逻辑
    // 显式转换size_t为int，避免循环条件警告
    for (int i = 0; i < static_cast<int>(free_blocks.size()) - 1; ) {
        FreeBlock& curr = free_blocks[i];
        FreeBlock& next = free_blocks[i+1];
        if (curr.start_addr + curr.size == next.start_addr) {
            // 合并两个分区
            curr.size += next.size;
            free_blocks.erase(free_blocks.begin() + i + 1);
        } else {
            i++;
        }
    }

    // 打印合并后的空闲分区表
    cout << "合并后空闲分区表：" << endl;
    for (size_t i = 0; i < free_blocks.size(); ++i) {
        cout << "  分区" << i+1 << "：起始地址=" << free_blocks[i].start_addr 
             << "，大小=" << free_blocks[i].size << endl;
    }
}

// 打印空闲分区表
void print_free_blocks() {
    cout << "当前空闲分区表：" << endl;
    for (size_t i = 0; i < free_blocks.size(); ++i) {
        cout << "  分区" << i+1 << "：起始地址=" << free_blocks[i].start_addr 
             << "，大小=" << free_blocks[i].size << endl;
    }
}

int main() {
    // 初始化空闲分区：总内存0~1000，初始为一个大分区
    free_blocks.push_back(FreeBlock(0, 1000));
    cout << "初始空闲分区表：" << endl;
    print_free_blocks();

    // 创建进程
    Process p1("P1", 200);
    Process p2("P2", 300);
    Process p3("P3", 400);

    // 首次适应算法分配P1
    cout << "\n--- 首次适应分配P1（200）---" << endl;
    allocate_memory(p1, 0);
    print_free_blocks();

    // 最佳适应算法分配P2
    cout << "\n--- 最佳适应分配P2（300）---" << endl;
    allocate_memory(p2, 1);
    print_free_blocks();

    // 释放P1
    cout << "\n--- 释放P1 ---" << endl;
    free_memory(p1);

    // 最佳适应算法分配P3
    cout << "\n--- 最佳适应分配P3（400）---" << endl;
    allocate_memory(p3, 1);
    print_free_blocks();

    return 0;
}

代码说明

1. FreeBlock模拟空闲分区，Process模拟进程；
2. 实现了首次适应 和最佳适应两种核心分配算法；
3. 释放内存时自动合并相邻空闲分区（解决内存碎片问题）；
4. 代码兼容 C++98：使用vector、自定义排序比较函数（C++98 不支持 lambda）、INT_MAX等；
5. 编译命令：g++ -std=c++98 continuous_alloc.cpp -o continuous_alloc。

运行结果

---

4.4 对换 (Swapping)

核心概念

对换（也叫交换）是解决内存不足的核心技术：

• 内存紧张时，将暂时不运行的进程完整换出到外存（交换区），释放内存；
• 需要运行时，再将进程换入到内存；
• 核心目标：提高内存利用率，支持更多进程并发。

对换流程

代码实现（C++98 模拟对换机制）

#include <iostream>
#include <vector>
#include <string>
#include <queue>
// 严格C++98标准
using namespace std;

// 进程状态枚举（C++98不支持enum class，用普通枚举）
enum ProcessState {
    RUNNING,  // 内存中运行
    WAITING,  // 等待换入
    SWAPPED   // 换出到外存
};

// 进程结构体
struct Process {
    string pid;      // 进程ID
    int size;        // 内存大小
    int priority;    // 优先级（数值越小优先级越高）
    int run_time;    // 已运行时间
    ProcessState state; // 状态
    Process(string p, int sz, int pri) : pid(p), size(sz), priority(pri), run_time(0), state(WAITING) {}
};

// 内存结构体
struct Memory {
    int total_size;  // 总大小
    int used_size;   // 已用大小
    vector<Process*> running_procs; // 内存中的进程
    Memory(int sz) : total_size(sz), used_size(0) {}
};

// 外存交换区
struct SwapArea {
    int total_size;  // 总大小
    int used_size;   // 已用大小
    vector<Process*> swapped_procs; // 换出的进程
    SwapArea(int sz) : total_size(sz), used_size(0) {}
};

// 选择换出进程（按优先级：优先级低的先换出；优先级相同则运行时间长的先换出）
Process* select_swap_out_proc(Memory& mem) {
    Process* swap_proc = NULL;
    int max_priority = -1;
    int max_run_time = -1;
    // ========== 修复：替换C++11范围for为C++98迭代器循环 ==========
    for (vector<Process*>::iterator it = mem.running_procs.begin(); it != mem.running_procs.end(); ++it) {
        Process* p = *it;
        if (p->priority > max_priority || (p->priority == max_priority && p->run_time > max_run_time)) {
            max_priority = p->priority;
            max_run_time = p->run_time;
            swap_proc = p;
        }
    }
    return swap_proc;
}

// 换出进程到外存
bool swap_out(Memory& mem, SwapArea& swap, Process* p) {
    if (swap.used_size + p->size > swap.total_size) {
        cout << "交换区空间不足，换出进程[" << p->pid << "]失败" << endl;
        return false;
    }

    // 从内存移除
    for (vector<Process*>::iterator it = mem.running_procs.begin(); it != mem.running_procs.end(); ++it) {
        if ((*it)->pid == p->pid) {
            mem.running_procs.erase(it);
            break;
        }
    }
    mem.used_size -= p->size;
    p->state = SWAPPED;

    // 加入交换区
    swap.swapped_procs.push_back(p);
    swap.used_size += p->size;

    cout << "进程[" << p->pid << "]换出成功！内存释放：" << p->size << "，交换区占用：" << swap.used_size << endl;
    return true;
}

// 换入进程到内存
bool swap_in(Memory& mem, SwapArea& swap, Process* p) {
    if (mem.used_size + p->size > mem.total_size) {
        // 内存不足，先换出一个进程
        Process* swap_out_proc = select_swap_out_proc(mem);
        if (swap_out_proc == NULL) {
            cout << "无可用进程换出，换入进程[" << p->pid << "]失败" << endl;
            return false;
        }
        if (!swap_out(mem, swap, swap_out_proc)) {
            return false;
        }
    }

    // 从交换区移除
    for (vector<Process*>::iterator it = swap.swapped_procs.begin(); it != swap.swapped_procs.end(); ++it) {
        if ((*it)->pid == p->pid) {
            swap.swapped_procs.erase(it);
            break;
        }
    }
    swap.used_size -= p->size;
    p->state = RUNNING;

    // 加入内存
    mem.running_procs.push_back(p);
    mem.used_size += p->size;

    cout << "进程[" << p->pid << "]换入成功！内存占用：" << mem.used_size << endl;
    return true;
}

// 打印系统状态
void print_system_state(Memory& mem, SwapArea& swap) {
    cout << "\n=== 系统状态 ===" << endl;
    cout << "内存：总大小=" << mem.total_size << "，已用=" << mem.used_size << endl;
    cout << "  运行中进程：";
    // ========== 修复：替换C++11范围for为C++98迭代器循环 ==========
    for (vector<Process*>::iterator it = mem.running_procs.begin(); it != mem.running_procs.end(); ++it) {
        Process* p = *it;
        cout << p->pid << "(" << p->size << ") ";
    }
    cout << endl;

    cout << "交换区：总大小=" << swap.total_size << "，已用=" << swap.used_size << endl;
    cout << "  换出进程：";
    // ========== 修复：替换C++11范围for为C++98迭代器循环 ==========
    for (vector<Process*>::iterator it = swap.swapped_procs.begin(); it != swap.swapped_procs.end(); ++it) {
        Process* p = *it;
        cout << p->pid << "(" << p->size << ") ";
    }
    cout << "\n=================\n" << endl;
}

int main() {
    // 初始化内存（总大小1000）和交换区（总大小2000）
    Memory mem(1000);
    SwapArea swap(2000);

    // 创建进程
    Process p1("P1", 300, 1);  // 高优先级
    Process p2("P2", 400, 2);  // 中优先级
    Process p3("P3", 500, 3);  // 低优先级

    // 换入P1
    cout << "--- 换入P1（300）---" << endl;
    swap_in(mem, swap, &p1);
    print_system_state(mem, swap);

    // 换入P2
    cout << "--- 换入P2（400）---" << endl;
    swap_in(mem, swap, &p2);
    print_system_state(mem, swap);

    // 换入P3（内存不足，触发换出）
    cout << "--- 换入P3（500）---" << endl;
    p2.run_time = 10; // P2运行时间长，优先换出
    swap_in(mem, swap, &p3);
    print_system_state(mem, swap);

    // 换入P2
    cout << "--- 换入P2（400）---" << endl;
    swap_in(mem, swap, &p2);
    print_system_state(mem, swap);

    return 0;
}

代码说明

1. 定义Process结构体，包含优先级、运行时间、状态等核心属性；
2. Memory模拟内存，SwapArea模拟外存交换区；
3. swap_out实现进程换出，swap_in实现进程换入（内存不足时自动触发换出）；
4. 换出策略：优先换出优先级低、运行时间长的进程；
5. 编译命令：g++ -std=c++98 swapping.cpp -o swapping。

运行结果

---

4.5 分页存储管理方式

核心概念

分页是解决连续分配「内存碎片」问题的核心方案：

• 内存划分为固定大小的页框（Page Frame）（如 4KB）；
• 进程地址空间划分为大小相同的页（Page）；
• 进程的页可以离散分配到内存的页框中，通过页表映射页和页框的对应关系；
• 核心优势：无外部碎片，仅少量内部碎片（最后一页未占满的部分）。

分页架构

代码实现（C++98 模拟分页存储管理）

#include <iostream>
#include <vector>
#include <string>
#include <map>
// C++98标准
using namespace std;

// 页大小（固定为4KB）
const int PAGE_SIZE = 4096;

// 页表项结构体
struct PageTableEntry {
    int frame_num;   // 页框号
    bool valid;      // 有效位（是否在内存中）
    PageTableEntry() : frame_num(-1), valid(false) {}
};

// 进程结构体
struct Process {
    string pid;                  // 进程ID
    int size;                    // 进程大小
    vector<PageTableEntry> pt;   // 页表
    Process(string p, int sz) : pid(p), size(sz) {
        // 计算页数：向上取整
        int page_count = (sz + PAGE_SIZE - 1) / PAGE_SIZE;
        pt.resize(page_count); // 初始化页表
    }
};

// 内存页框管理器
struct FrameManager {
    int total_frames;            // 总页框数
    vector<bool> frame_used;     // 页框使用状态（true=已用）
    FrameManager(int total_size) : total_frames(total_size / PAGE_SIZE) {
        frame_used.resize(total_frames, false); // 初始全空闲
    }

    // 分配空闲页框
    int allocate_frame() {
        for (int i = 0; i < total_frames; ++i) {
            if (!frame_used[i]) {
                frame_used[i] = true;
                return i;
            }
        }
        return -1; // 无空闲页框
    }

    // 释放页框
    void free_frame(int frame_num) {
        if (frame_num >= 0 && frame_num < total_frames) {
            frame_used[frame_num] = false;
            cout << "页框" << frame_num << "释放成功" << endl;
        }
    }

    // 打印页框使用状态
    void print_frames() {
        cout << "页框使用状态（总" << total_frames << "个）：";
        for (int i = 0; i < total_frames; ++i) {
            cout << (frame_used[i] ? "1" : "0");
        }
        cout << endl;
    }
};

// 虚拟地址转物理地址
int virtual_to_physical(Process& p, int virtual_addr) {
    // 拆分虚拟地址：页号 = 虚拟地址 / 页大小，页内偏移 = 虚拟地址 % 页大小
    int page_num = virtual_addr / PAGE_SIZE;
    int offset = virtual_addr % PAGE_SIZE;

    // 检查页号是否合法
    if (page_num >= (int)p.pt.size()) {
        cout << "进程[" << p.pid << "]虚拟地址" << virtual_addr << "：页号" << page_num << "越界" << endl;
        return -1;
    }

    // 检查有效位
    PageTableEntry& pte = p.pt[page_num];
    if (!pte.valid) {
        cout << "进程[" << p.pid << "]虚拟地址" << virtual_addr << "：页" << page_num << "不在内存中（缺页）" << endl;
        return -1;
    }

    // 计算物理地址 = 页框号 * 页大小 + 页内偏移
    int physical_addr = pte.frame_num * PAGE_SIZE + offset;
    cout << "进程[" << p.pid << "]虚拟地址" << virtual_addr 
         << " → 页号" << page_num << "，偏移" << offset 
         << " → 物理地址" << physical_addr << endl;
    return physical_addr;
}

// 分配进程的页到内存页框
bool allocate_pages(Process& p, FrameManager& fm) {
    cout << "为进程[" << p.pid << "]分配页（总页数：" << p.pt.size() << "）" << endl;
    for (int i = 0; i < (int)p.pt.size(); ++i) {
        int frame = fm.allocate_frame();
        if (frame == -1) {
            cout << "页框不足，进程[" << p.pid << "]分配失败" << endl;
            // 回滚已分配的页框
            for (int j = 0; j < i; ++j) {
                fm.free_frame(p.pt[j].frame_num);
                p.pt[j].valid = false;
            }
            return false;
        }
        p.pt[i].frame_num = frame;
        p.pt[i].valid = true;
        cout << "  页" << i << " → 页框" << frame << endl;
    }
    return true;
}

int main() {
    // 初始化内存：总大小32KB → 8个页框（4KB/页）
    FrameManager fm(32 * 1024);
    cout << "初始页框状态：" << endl;
    fm.print_frames();

    // 创建进程：大小10KB → 需要3页（4+4+2）
    Process p1("P1", 10 * 1024);

    // 分配页
    cout << "\n--- 分配P1的页 ---" << endl;
    allocate_pages(p1, fm);
    fm.print_frames();

    // 虚拟地址转物理地址
    cout << "\n--- 虚拟地址转换 ---" << endl;
    virtual_to_physical(p1, 1000);   // 页0，偏移1000
    virtual_to_physical(p1, 5000);   // 页1，偏移904
    virtual_to_physical(p1, 9000);   // 页2，偏移808
    virtual_to_physical(p1, 13000);  // 页3，越界

    // 释放进程的页框
    cout << "\n--- 释放P1的页框 ---" << endl;
    for (int i = 0; i < (int)p1.pt.size(); ++i) {
        fm.free_frame(p1.pt[i].frame_num);
        p1.pt[i].valid = false;
    }
    fm.print_frames();

    return 0;
}

代码说明

1. 固定页大小为 4KB，FrameManager管理内存页框的分配 / 释放；
2. Process包含页表，页表项记录页框号和有效位；
3. virtual_to_physical实现虚拟地址到物理地址的转换（核心逻辑）；
4. 模拟「缺页」「地址越界」等异常场景；
5. 编译命令：g++ -std=c++98 paging.cpp -o paging。

运行结果

---

4.6 分段存储管理方式

核心概念

分段是按程序的逻辑结构划分内存（如代码段、数据段、栈段），每个段是连续的内存块，不同段可离散分配：

• 段：有意义的逻辑单位，大小不固定（如代码段 10KB、栈段 5KB）；
• 段表：记录每个段的基地址和段长，实现虚拟地址到物理地址的映射；
• 核心优势：便于程序的共享和保护（如代码段只读、数据段可读写）。

分段架构

代码实现（C++98 模拟分段存储管理）

#include <iostream>
#include <vector>
#include <string>
#include <map>
// C++98标准
using namespace std;

// 段表项结构体
struct SegmentTableEntry {
    string seg_name;  // 段名（代码段/数据段/栈段）
    int base_addr;    // 段基地址
    int seg_size;     // 段长度
    string protect;   // 保护属性（R-只读，RW-读写，X-执行）
    bool valid;       // 有效位
    SegmentTableEntry(string name, int size, string prot) : seg_name(name), seg_size(size), protect(prot), base_addr(-1), valid(false) {}
};

// 进程结构体
struct Process {
    string pid;                          // 进程ID
    vector<SegmentTableEntry> seg_table; // 段表
    Process(string p) : pid(p) {}

    // 添加段
    void add_segment(string name, int size, string protect) {
        seg_table.push_back(SegmentTableEntry(name, size, protect));
    }
};

// 内存管理器
struct MemoryManager {
    int total_size;          // 总内存大小
    int used_size;           // 已用大小
    MemoryManager(int sz) : total_size(sz), used_size(0) {}

    // 分配连续内存段
    int allocate_segment(int size) {
        if (used_size + size > total_size) {
            return -1; // 内存不足
        }
        int base = used_size;
        used_size += size;
        return base;
    }

    // 释放段（简化版：不合并，仅标记内存可用）
    void free_segment(int base, int size) {
        cout << "释放段：基地址=" << base << "，大小=" << size << endl;
        // 实际OS中需要管理空闲分区，此处简化为打印
        used_size -= size;
    }
};

// 虚拟地址转物理地址
int virtual_to_physical(Process& p, MemoryManager& mm, int seg_num, int offset) {
    // 检查段号是否合法
    if (seg_num >= (int)p.seg_table.size()) {
        cout << "进程[" << p.pid << "]段号" << seg_num << "越界" << endl;
        return -1;
    }

    SegmentTableEntry& ste = p.seg_table[seg_num];
    // 检查有效位
    if (!ste.valid) {
        cout << "进程[" << p.pid << "]段" << ste.seg_name << "不在内存中" << endl;
        return -1;
    }

    // 检查段内偏移是否越界
    if (offset >= ste.seg_size) {
        cout << "进程[" << p.pid << "]段" << ste.seg_name << "内偏移" << offset << "越界（段长：" << ste.seg_size << "）" << endl;
        return -1;
    }

    // 计算物理地址
    int physical_addr = ste.base_addr + offset;
    cout << "进程[" << p.pid << "]段" << ste.seg_name << "（段号" << seg_num << "）偏移" << offset 
         << " → 物理地址" << physical_addr << "（保护属性：" << ste.protect << "）" << endl;
    return physical_addr;
}

// 分配进程的段到内存
bool allocate_segments(Process& p, MemoryManager& mm) {
    cout << "为进程[" << p.pid << "]分配段：" << endl;
    for (int i = 0; i < (int)p.seg_table.size(); ++i) {
        SegmentTableEntry& ste = p.seg_table[i];
        int base = mm.allocate_segment(ste.seg_size);
        if (base == -1) {
            cout << "内存不足，进程[" << p.pid << "]段" << ste.seg_name << "分配失败" << endl;
            // 回滚已分配的段
            for (int j = 0; j < i; ++j) {
                mm.free_segment(p.seg_table[j].base_addr, p.seg_table[j].seg_size);
                p.seg_table[j].valid = false;
            }
            return false;
        }
        ste.base_addr = base;
        ste.valid = true;
        cout << "  段" << i << "（" << ste.seg_name << "）：基地址=" << base << "，大小=" << ste.seg_size << endl;
    }
    return true;
}

int main() {
    // 初始化内存（总大小20KB）
    MemoryManager mm(20 * 1024);
    cout << "初始内存：总大小=" << mm.total_size << "，已用=" << mm.used_size << endl;

    // 创建进程并添加段
    Process p1("P1");
    p1.add_segment("代码段", 5 * 1024, "X");    // 执行权限
    p1.add_segment("数据段", 8 * 1024, "RW");   // 读写权限
    p1.add_segment("栈段", 3 * 1024, "RW");     // 读写权限

    // 分配段
    cout << "\n--- 分配P1的段 ---" << endl;
    allocate_segments(p1, mm);
    cout << "分配后内存：已用=" << mm.used_size << endl;

    // 虚拟地址转物理地址
    cout << "\n--- 虚拟地址转换 ---" << endl;
    virtual_to_physical(p1, mm, 0, 1000);  // 代码段，偏移1000
    virtual_to_physical(p1, mm, 1, 2000);  // 数据段，偏移2000
    virtual_to_physical(p1, mm, 2, 4000);  // 栈段，偏移4000（越界）
    virtual_to_physical(p1, mm, 3, 1000);  // 段号3（越界）

    return 0;
}

代码说明

1. SegmentTableEntry包含段名、基地址、段长、保护属性等核心字段；
2. MemoryManager管理连续内存段的分配 / 释放；
3. virtual_to_physical实现分段地址转换，包含越界检查 和保护属性校验；
4. 模拟代码段（执行权限）、数据段 / 栈段（读写权限）的不同保护策略；
5. 编译命令：g++ -std=c++98 segmentation.cpp -o segmentation。

运行结果

---

习题

基础题

1. 简述存储器层次结构的设计思想，为什么需要分层管理？
2. 对比连续分配、分页、分段三种存储管理方式的优缺点。
3. 分页和分段的核心区别是什么？（提示：页是物理划分，段是逻辑划分）
4. 对换技术的核心作用是什么？换出进程的选择策略有哪些？

编程题

1. 基于本文的分页代码，实现「最坏适应算法」的页框分配策略。
2. 基于本文的分段代码，添加「段共享」功能（多个进程共享同一个代码段）。
3. 扩展对换代码，实现「按进程剩余运行时间」选择换出进程的策略。

---

总结

核心知识点回顾

1. 存储器层次结构：核心是「速度 - 容量 - 成本」的平衡，OS 主要管理主存，虚拟内存是内存 + 外存的抽象；
2. 存储管理方式 ：
   • 连续分配：简单但有外部碎片，适合早期单进程 OS；
   • 分页：离散分配，无外部碎片，按物理大小划分；
   • 分段：离散分配，按逻辑结构划分，便于共享和保护；
3. 核心技术：程序装入链接是进程运行的前提，对换技术解决内存不足问题，地址转换（分页 / 分段）是虚拟地址到物理地址的核心。