C++模拟定义管理每个进程的数据结构PCB：包含进程名称、队列指针、分配的物理内存区域（基址和长度）。每创建一个进程时，需要为其创建PCB并分配空闲内存空间，对PCB进行初始化，并加入就绪队列。创建进程时申请空白PCB。模拟触发进程状态转换的事件：采用键盘控制方法来模拟触发进程状态切换的事件

以下是一个简单的C++代码实现：

#include <iostream>
#include <string>
#include <vector>
using namespace std;

// 进程控制块
struct PCB
{
    string name;    // 进程名称
    PCB* next;      // 队列指针
    int base;       // 分配的物理内存区域基址
    int length;     // 分配的物理内存区域长度
};

// 空闲内存空间
struct FreeSpace
{
    int base;   // 基址
    int length; // 长度
};

vector<PCB*> readyQueue;        // 就绪队列
vector<FreeSpace*> freeSpaces;  // 空闲内存空间

// 初始化空闲内存空间
void initFreeSpaces()
{
    FreeSpace* space1 = new FreeSpace;
    space1->base = 0;
    space1->length = 100;
    freeSpaces.push_back(space1);

    FreeSpace* space2 = new FreeSpace;
    space2->base = 200;
    space2->length = 50;
    freeSpaces.push_back(space2);
}

// 分配空闲内存空间
int allocateMemory(int length)
{
    for (int i = 0; i < freeSpaces.size(); i++)
    {
        FreeSpace* space = freeSpaces[i];
        if (space->length >= length)
        {
            int base = space->base;
            space->base += length;
            space->length -= length;

            if (space->length == 0)
            {
                freeSpaces.erase(freeSpaces.begin() + i);
            }

            return base;
        }
    }

    return -1;  // 内存不足，分配失败
}

// 创建进程
PCB* createProcess(string name, int length)
{
    int base = allocateMemory(length);
    if (base == -1)
    {
        cout << "分配内存失败！" << endl;
        return NULL;
    }

    PCB* pcb = new PCB;
    pcb->name = name;
    pcb->base = base;
    pcb->length = length;

    // 初始化PCB并加入就绪队列
    pcb->next = NULL;
    readyQueue.push_back(pcb);

    cout << "创建进程成功！" << endl;
    return pcb;
}

// 销毁进程
void destroyProcess(PCB* pcb)
{
    // 释放分配的内存空间
    FreeSpace* space = new FreeSpace;
    space->base = pcb->base;
    space->length = pcb->length;
    freeSpaces.push_back(space);

    // 从就绪队列中删除PCB
    for (int i = 0; i < readyQueue.size(); i++)
    {
        if (readyQueue[i] == pcb)
        {
            readyQueue.erase(readyQueue.begin() + i);
            break;
        }
    }

    delete pcb;
    cout << "销毁进程成功！" << endl;
}

// 显示就绪队列
void displayReadyQueue()
{
    cout << "就绪队列：" << endl;
    for (int i = 0; i < readyQueue.size(); i++)
    {
        PCB* pcb = readyQueue[i];
        cout << "进程名称：" << pcb->name << "，基址：" << pcb->base << "，长度：" << pcb->length << endl;
    }
}

int main()
{
    initFreeSpaces();

    while (true)
    {
        cout << "请输入指令（1：创建进程，2：销毁进程，3：显示就绪队列，0：退出）：" << endl;
        int command;
        cin >> command;

        switch (command)
        {
        case 1:
            cout << "请输入进程名称和长度：" << endl;
            string name;
            int length;
            cin >> name >> length;
            createProcess(name, length);
            break;
        case 2:
            cout << "请输入要销毁的进程名称：" << endl;
            cin >> name;
            for (int i = 0; i < readyQueue.size(); i++)
            {
                PCB* pcb = readyQueue[i];
                if (pcb->name == name)
                {
                    destroyProcess(pcb);
                    break;
                }
            }
            break;
        case 3:
            displayReadyQueue();
            break;
        case 0:
            return 0;
        default:
            cout << "无效的指令！" << endl;
            break;
        }
    }

    return 0;
}

以上代码实现了一个简单的进程管理系统，可以创建和销毁进程，并显示就绪队列。通过输入不同的指令来触发进程状态转换的事件。具体实现中，空闲内存空间采用了一个简单的vector来管理，每次分配内存时从vector中寻找合适的空间，如果找不到则分配失败。同时，将创建的PCB加入就绪队列中，销毁时从就绪队列中删除。