主存空间的分配和回收，

#include "iostream.h"
#include "iomanip.h"

#define nofreearea 2
#define noadequacyarea 3
#define allocated 4

#define noprocess 2
#define nosuchprocess 3
#define reclaimed 4

typedef struct TUN
{
int address;
int size;
char name;
struct TUN *next;
} usedarea , *usedtable;

typedef struct TFN
{
int address;
int size;
struct TFN *next;
} freearea, *freetable;

usedtable usedTable = NULL;
freetable freeTable = NULL;

int alloc( char processname , int processsize )
{

if( freeTable == NULL )
return 1;
freetable p = freeTable;
freetable q = p;

while( p != NULL && p->size < processsize )
{
q = p;
p = p->next;
}

if( p == NULL )
return 3;

usedtable x = new usedarea;
x->address = p->address;
x->size = processsize;
x->name = processname;
x->next = NULL;

if( p->size > processsize )
{
p->size -= processsize;
p->address += processsize;
}

else
{
if( p == freeTable )
freeTable = NULL;
else
q->next = p->next;
delete p;
}

usedtable r = usedTable;
usedtable t = r;

while( r != NULL && r->address < x->address )
{
t = r;
r = r->next;
}

if( usedTable == NULL )
usedTable = x;
else
{
x->next = r;
t->next = x;
}

return 4;
}

int Reclaim( char processname )
{
if( usedTable == NULL )
return 1;
usedtable p = usedTable;
usedtable q = p;
while( p != NULL && p->name != processname )
{
q = p;
p = p->next;
}

if( p == NULL )
return 3;

freetable r = freeTable;
freetable t = r;
freetable x;
while( r != NULL && r->address < p->address )
{
t = r;
r = r->next;
}

x = new freearea;
x->address = p->address;
x->size = p->size;
x->next = NULL;

if( r == freeTable )
{
x->next = r;
freeTable = x;
t = freeTable;
}
else
{
x->next = r;
t->next = x;
}

while( t->next != NULL && t->address + t->size == t->next->address )
{
t->size += t->next->size;
r = t->next;
t->next = t->next->next;
delete r;
}

if( p == usedTable )
{
usedTable = usedTable->next;
}
else
q->next = p->next;
delete p;

return 4;
}

int Init()
{
freeTable = new freearea;
freeTable->address = 0;
freeTable->size = 128;
freeTable->next = NULL;
return 1;
}

void processrequest()
{
char processname;
int processsize;
cout<<"...................."<<endl;
cout<<"作业名: ";
cin >> processname;
cout<<"作业长度: ";
cin >> processsize;
if(processsize<=128)
{int i;
if( alloc( processname , processsize) == 4 )
{
i=i+processsize;
if(i>128)
{cout<<"该作业超出空间"<<endl;
}
if(i<=128)
cout<<"该作业已成功获得所需空间"<<endl;
i=i+processsize;
cout<<"........................................"<<endl;

}
else
cout<<"该作业超出空间,没有获得所需空间"<<endl;
cout<<"........................................"<<endl;
return;
}
if(processsize>128)
{cout<<"该作业超出空间"<<endl;
cout<<"........................................"<<endl;
}

}

void processreclaim()
{
int processname;
cout<<"...................."<<endl;
cout<<"作业名: ";
cin >>processname;
int result = Reclaim( processname );
if( result == 4 )
cout<<"该作业已成功回收"<<endl;
else if( result == 2 || result == 1 )
cout<<"系统没有作业或该作业不存在"<<endl;
cout<<"...................."<<endl;

}

void freeTablePrint()
{
cout<<endl<<endl<<endl<<"***********************************"<<endl;
cout<<setw(10)<<"address"<<setw(10)<<"length"<<setw(10)<<"state"<<endl<<endl;
freetable p = freeTable;
usedtable q = usedTable;
int x , y;
while( p || q )
{
if( p )
x = p->address;
else
x = 0x7fffffff;
if( q )
y = q->address;
else
y = 0x7fffffff;

if( x < y )
{
cout<<setw(10)<<p->address<<setw(10)<<p->size<<setw(10)<<"空闲"<<endl;
p = p->next;
}
if( x > y )
{
cout<<setw(10)<<q->address<<setw(10)<<q->size<<setw(10)<<"已分配"<<setw(10)<<"ID="<<q->name<<endl;
q = q->next;
}
}
cout<<endl<<endl<<endl<<"************************************"<<endl<<endl<<endl;

}

void main()
{
Init();
int choose;
bool exitFlag = false;
while( !exitFlag )
{

cout<<"************************0 - 退出 ************************"<<endl;
cout<<"************************1 - 分配主存 ************************"<<endl;
cout<<"************************2 - 回收主存 ************************"<<endl;
cout<<"************************3 - 显示主存 ************************"<<endl<<endl<<endl;
cout<<"************************选择所要执行的操作:";
cin>>choose;
switch( choose )
{
case 0:
exitFlag = true;
break;
case 1:
processrequest();
break;
case 2:
processreclaim();
break;
case 3:
freeTablePrint();
break;
}
}
}

#include <iostream.h>
#include <stdio.h>
#include <string.h>

struct program
{
char name[30];
long start;
long length;
struct program *next;
};

struct space
{
long start;
long length;
struct space *next;
};

void creat();
void allot();
void back();
void callback(program *r);
void sort(space *L);
void sort(program *S);
void display(space *L);
void display(program *S);

space *L;
program *S;

void creat()
{
L=new space;
space *p=new space;
p->start=0;
p->length=128;
p->next=NULL;
L->next=p;
S=new program;
S->next=NULL;
}
void allot()
{
program *q;
q=new program;
cout<<"请输入进程名和占用空间大小:"<<endl;
cin>>q->name>>q->length;
if(q->length<=0)
{
cout<<"进程空间大小错误."<<endl;
delete q;
return;
}
space *p,*r;
p=L;
r=p;
while(p->next!=NULL&&p->next->length<q->length)
{
r=p;
p=p->next;
}
if(p->next==NULL)
{
cout<<"占用空间过大，分配失败"<<endl;
delete q;
return;
}
else
{
q->start=p->next->start;
q->next=S->next;
S->next=q;

p->next->length-=q->length;
if(p->next->length!=0)
p->next->start+=q->length;
else
{
if(p->next->next!=NULL)
p->next=p->next->next;
else
{
r->next=NULL;
delete p->next;
}
}
}
display(L);
display(S);
}
void back()
{
char name[30];
cout<<"输入要回收的进程名：";
cin>>name;
program *p;
p=S;
while(p->next!=NULL)
{
if(strcmp(p->next->name, name)==0)
{
callback(p);
return;
}
p=p->next;
}
if(p->next==NULL)
cout<<"此进程不存在,内存回收失败"<<endl;

}
void callback(program *t)
{
program *r;
r=t->next;
space *p,*q;
long n;
n=r->length;
if(L->next==NULL)
{
space *w=new space;
w->start=0;
w->length=n;
w->next=NULL;
L->next=w;
t->next=r->next;
delete r;
cout<<"此进程内存回收完毕."<<endl;
display(L);
display(S);
return;
}
p=L->next;
while(p!=NULL&&p->start<r->start)
{
q=p;
p=p->next;
}
if((q->start+q->length==r->start)&&(r->start+n==p->start)) //上下均空
{
q->next=p->next;
q->length=q->length+p->length+n;
t->next=r->next;
delete r;
}
else if(r->start+n==p->start) //下邻空
{
p->start-=n;
p->length+=n;
t->next=r->next;
delete r;
}
else if(q->start+q->length==r->start)
{
q->length+=n;
t->next=r->next;
delete r;
}
else
{
space *sp=new space;
sp->start=r->start;
sp->length=n;
sp->next=L->next;
L->next=sp;
t->next=r->next;
delete r;
}
cout<<"此进程内存回收完毕."<<endl;
display(L);
display(S);
}
void display(space *L)
{
sort(L);
space *p=L->next;
cout<<endl<<"空闲区情况："<<endl;
if(p==NULL)
{ cout<<"无空闲区了."<<endl; return;}
while(p!=NULL)
{
cout<<"起始地址:"<<p->start<<" 长度:"<<p->length<<endl;
p=p->next;
}
}
void display(program *S)
{
sort(S);
program *p=S->next;
cout<<endl<<"进程内存分配情况："<<endl;
if(p==NULL)
{ cout<<"内存中无进程."<<endl; return;}
while(p!=NULL)
{
cout<<"进程名:"<<p->name<<" 起始地址:"<<p->start<<" 长度:"<<p->length<<endl;
p=p->next;
}
cout<<endl;
}
void sort(space *L) //链表排序
{
space *p=L->next, *q, *r;
if(p!=NULL)
{
r=p->next;
p->next=NULL;
p=r;
while(p!=NULL)
{
r=p->next;
q=L;
while(q->next!=NULL&&q->next->start<p->start)
q=q->next;
p->next=q->next;
q->next=p;
p=r;
}
}
}
void sort(program *S) //链表排序
{
program *p=S->next, *q, *r;
if(p!=NULL)
{
r=p->next;
p->next=NULL;
p=r;
while(p!=NULL)
{
r=p->next;
q=S;
while(q->next!=NULL&&q->next->start<p->start)
q=q->next;
p->next=q->next;
q->next=p;
p=r;
}
}
}

void main()
{
creat();
int a;
cout<<" 内存分配与回收模拟"<<endl;
cout<<"1:分配内存"<<endl;
cout<<"2:回收内存"<<endl;
cout<<"0:退出"<<endl;
while(1)
{
cout<<endl<<"请按键选择：";
cin>>a;
if(a>2||a<0)
{
cout<<endl<<"输入错误，请重新输入：";
continue;
}
switch(a)
{
case 1: allot(); break;
case 2: back(); break;
case 0: goto end;
}
}
end:
getchar();
}

#include "iostream.h"
#include "iomanip.h"

#define ERR_NOFREEAREA 1
#define ERR_NOADEQUACYAREA 2
#define ERR_ALLOCATED 4

#define ERR_NOJOBS 1
#define ERR_NOSUCHJOB 2
#define ERR_RECLAIMED 4

typedef struct tagUsedNode
{
long address;
long length;
int flag; //作业名
struct tagUsedNode *next;
} USED_AREA , *USED_TABLE;

typedef struct tagFreeNode
{
long address;
long length;
struct tagFreeNode *next;
} FREE_AREA , *FREE_TABLE;

//空闲区、作业区链表
USED_TABLE usedTable = NULL;
FREE_TABLE freeTable = NULL;

//给作业分配空间
//jobname: 作业名
//jobsize: 作业所需空间大小
int Allocate( int jobname , long jobsize )
{
//如果没有空闲区
if( freeTable == NULL )
return ERR_NOFREEAREA;
FREE_TABLE p = freeTable;
FREE_TABLE q = p;
//找首次适应空闲区
while( p != NULL && p->length < jobsize )
{
q = p;
p = p->next;
}
//如果找不到有足够空间的分区
if( p == NULL )
return ERR_NOADEQUACYAREA;

USED_TABLE x = new USED_AREA;
x->address = p->address;
x->length = jobsize;
x->flag = jobname;
x->next = NULL;

//如果该分区大于作业需求，空间大小减去作业大小
if( p->length > jobsize )
{
p->length -= jobsize;
p->address += jobsize;
}
//如果该分区等于作业大小，删除该分区
else
{
if( p == freeTable )
freeTable = NULL;
else
q->next = p->next;
delete p;
}
//作业加入“作业表”中
USED_TABLE r = usedTable;
USED_TABLE t = r;

while( r != NULL && r->address < x->address )
{
t = r;
r = r->next;
}

if( usedTable == NULL )
usedTable = x;
else
{
x->next = r;
t->next = x;
}

return ERR_ALLOCATED;
}

//回收作业空间
//jobname: 作业名
int Reclaim( int jobname )
{
if( usedTable == NULL )
return ERR_NOJOBS;
USED_TABLE p = usedTable;
USED_TABLE q = p;
while( p != NULL && p->flag != jobname )
{
q = p;
p = p->next;
}
//如果没有该作业
if( p == NULL )
return ERR_NOSUCHJOB;
//回收后的空间加入到空闲区
FREE_TABLE r = freeTable;
FREE_TABLE t = r;
FREE_TABLE x;
while( r != NULL && r->address < p->address )
{
t = r;
r = r->next;
}

x = new FREE_AREA;
x->address = p->address;
x->length = p->length;
x->next = NULL;

if( r == freeTable )
{
x->next = r;
freeTable = x;
t = freeTable;
}
else
{
x->next = r;
t->next = x;
}
//合并分区
while( t->next != NULL && t->address + t->length == t->next->address )
{
t->length += t->next->length;
r = t->next;
t->next = t->next->next;
delete r;
}
//删除该作业
if( p == usedTable )
{
usedTable = usedTable->next;
}
else
q->next = p->next;
delete p;

return ERR_RECLAIMED;
}

int Init()
{
freeTable = new FREE_AREA;
freeTable->address = 0;
freeTable->length = 1024;
freeTable->next = NULL;
return 1;
}

void jobrequest()
{
int jobname;
int jobsize;

cout<<"...................."<<endl;
cout<<"作业名: ";
cin >> jobname;
cout<<"作业长度: ";
cin >> jobsize;

if( Allocate( jobname , jobsize ) == ERR_ALLOCATED )
cout<<"该作业已成功获得所需空间"<<endl;
else
cout<<"该作业没有获得所需空间"<<endl;
cout<<"...................."<<endl;
}

void jobreclaim()
{
int jobname;
cout<<"...................."<<endl;
cout<<"作业名: ";
cin >>jobname;
int result = Reclaim( jobname );
if( result == ERR_RECLAIMED )
cout<<"该作业已成功回收"<<endl;
else if( result == ERR_NOSUCHJOB || result == ERR_NOJOBS )
cout<<"系统没有作业或该作业不存在"<<endl;
cout<<"...................."<<endl;
}

void freeTablePrint()
{
cout<<"........................................"<<endl;
cout<<setw(10)<<"address"<<setw(10)<<"length"<<setw(10)<<"state"<<endl<<endl;
FREE_TABLE p = freeTable;
USED_TABLE q = usedTable;
int x , y;
while( p || q )
{
if( p )
x = p->address;
else
x = 0x7fffffff;
if( q )
y = q->address;
else
y = 0x7fffffff;

if( x < y )
{
cout<<setw(10)<<p->address<<setw(10)<<p->length<<setw(10)<<"空闲"<<endl;
p = p->next;
}
if( x > y )
{
cout<<setw(10)<<q->address<<setw(10)<<q->length<<setw(10)<<"已分配"<<setw(10)<<"ID="<<q->flag<<endl;
q = q->next;
}
}
cout<<"........................................"<<endl;

}

void main()
{
Init();

int choose;
bool exitFlag = false;
while( !exitFlag )
{
cout<<"选择功能项 ( 0 - 退出 1 - 分配主存 2 - 回收主存 3 - 显示主存 )"<<endl;
cout<<"?>";
cin>>choose;
switch( choose )
{
case 0:
exitFlag = true;
break;
case 1:
jobrequest();
break;
case 2:
jobreclaim();
break;
case 3:
freeTablePrint();
break;
}
}
}

.操作系统的定义：操作系统是合理组织计算机的工作流程、有效控制和管理计算机系统的各类资源、并方便用户使用计算机的程序集合。它是计算机最重要的系统软件。
2.操作系统的主要作用有三：管理计算机系统资源、为用户使用计算机提供接口、扩充机器的功能。
3.操作系统的三大目标：为用户使用计算机提供方便；合理的组织计算机的工作流程有效控制和管理计算机系统的各类资源。
4.操作系统的5大管理功能：处理机管理、存储器管理、设备管理、文件管理和作业管理。
5.操作系统按照系统处理任务的方式分为三种基本类型：多道批处理操作系统、分时操作系统、实时操作系统。
6.多道批处理系统的优缺点：优点：资源利用率高；系统吞吐量大；系统开销小。缺点：用户没有交互能力；作业平均周转时间长。
7.分时操作系统的特征：交互性、及时性、独占性、同时性(也叫多路性)。
8.实时操作系统的特征：稍弱的交互性、实时性、可靠性。
9.操作系统的特征：并发性、共享性、虚拟性、异步性。
10.进程的定义：进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。
11.进程的5个特性：动态性、并发性、独立性、异步性、结构特性。
12.进程与程序的区别(是在多道批处理的前提下)：(1)从定义上看，进程是程序处理数据的过程，而程序是一组指令的有序集合；(2)进程具有动态性、并发性、独立性和异步性等，而程序不具有这些特性；(3)从进程结构特性上看，它包括程序(以及数据和PCB)；(4)进程和程序并非一一对应。
13.进程管理的核心是进程的控制和调度。
14.处理机处理两种：系统态和用户态。
15.死锁的定义：所谓死锁，是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，他们都将无法推进下去。称此时系统处于死锁状态或系统产生了死锁。
16.产生死锁的原因：(1)竞争临界资源；(2)进程推进顺序不当。
17.产生死锁的必要条件：(1)互斥条件(2)占有并请求条件(3)不可剥夺条件(4)循环等待条件。
18.死锁的预防办法是在系统运行之前就采用措施，即在系统设计时确定资源分配算法，消除发生死锁的任何可能性。
19.死锁的避免是指这样一种对付死锁的办法：系统在运行过程中采用动态的资源分配策略，保证系统不进入可能导致系统陷入死锁状态的所谓不安全状态，以避免死锁发生。
20.当发生下列几种情况时，现行进程都要放弃处理机的使用，即将引起系统对进程的重新调度：(1)在分时系统中，现行进程的时间片用完了；(2)发生了外部中断；(3)进程因等待某事件或资源而阻塞；(4)现行进程运行结束或出现异常情况。
21.物理地址是指存储单元的地址编号，又称绝对地址或实地址。
22.逻辑地址是指用户程序中使用的地址，又称相对地址或虚地址。
23.静态重定位是指在程序运行之前由装入程序完成的重定位过程。
24.动态重定位是指在程序执行过程中由硬件地址变换机构实现的重定位过程。
25.静态重定位简单易实现，且程序运行快，但它往往要求程序在内存中占据一块连续的区域，且不可移动，也*多用户共享同一程序的内存副本。而动态重定位恰恰相反，它的实现需要少量的硬件支持，而且程序运行稍慢，但它往往不要求程序在内存中必须占据一块连续的区域，允许程序移动，也便于多用户共享同一程序的内存副本。
26.存储管理的功能：内存的分配与回收；地址转换；内存共享与保护；内存扩充。
27.固定分区存储管理：固定分区管理方法是把主存中可分配的用户区预先划分成若干个连续的分区，每个分区的大小可以相同，也可以不同。但是一旦划分好分区之后，主存中分区的个数就固定了，且每个分区的大小也固定不变。
28.页式存储管理具体又分为实分页和虚分页两种存储管理方式。
29.虚拟存储器是指具有请求调入和置换功能、能逻辑扩充内存的存储器系统。它有两层含义，一层是指一级存储器，它利用软，硬件技术，把内存、外存两级存储器作为一级存储器；另一层是地址空间，它是一个进程可以访问的地址空间。
30.确定何时将一个页面从外存调入内存，有一下两种方法：请求调入和预调入。
31.设备管理的分类：(1)按从属关系：系统设备和用户设备(2)按传输速率：低速设备、中速设备、高速设备(3)按使用特性：存储设备和I/O设备(4)按设备共享属性：独占设备、共享设备和虚拟设备。
32.设备管理的功能：设备分配；设备处理；实现其他功能。
33.设备管理的目标：a.提高I/O设备和CPU的利用率 b.提高I/O速度 c.为用户提供方便、同一的界面。
34.中断技术：中断是指计算机在执行期间，系统内发生了某一急需处理的事件，使得CPU暂时中止当前正在执行的程序而转去执行相应的事件处理程序，待处理完毕后又返回刚才暂停程序的被中断处继续执行。
35.缓冲技术的实现思想是在CPU和外设之间设立缓冲区，用以暂存CPU和外设之间交换的数据，从而缓和CPU与外设速度不匹配所产生的矛盾。
36.设备处理程序又称设备驱动程序，是驱动外部设备和相应的控制器等，使其可以直接和内存进行I/O操作的子程序的集合。
37.利用假脱机技术可把独占设备转变成可共享的虚拟设备，从而提高独占设备的利用率和进程的推进速度。
38.磁盘系统可分为两种基本类型：固定头磁盘和移动头磁盘。
39.磁盘驱动程序为了对盘片组中的一个物理块进行定位，需要一下3个参数：柱面号；磁头号；扇区号。
40.常用的磁盘调度算法有：先来先服务、最短寻道时间优先、扫描算法和循环扫描算法。
41.文件系统：操作系统中负责存取和管理文件信息的模块称为文件系统。
42.文件系统的功能：文件读/写管理；文件目录管理；文件存储空间管理；文件保护与共享；提供方便的接口；文件系统的可靠性与一致性。
43.文件系统的目标：实现文件的按名存取，这主要是通过文件系统的目录管理功能实现的。
44.文件的结构有两种：逻辑结构和物理结构。
45.文件的存取方式：顺序存取、随即存取、按键存取。
46.多级目录结构的优点：(1)解决了命名冲突问题；(2)提高了检索效率；(3)易于实现文件的共享和保护；(4)便于用户分类管理文件。
47.常见的文件物理结构有3种：顺序文件、链接文件和索引文件。
48.文件共享的实现方法：(1)个用户通过唯一的共享文件的路径名访问共享文件的方法；(2)利用多个目录中的不同文件名来描述同一共享文件的方法。
49.磁盘分配算法用的主要的数据结构是用来记录和跟踪磁盘上的空间块的数据结构，通常有3种：空闲文件目录、空闲块链和位示图。
50.利用空间块来存放空闲块链表的具体做法是：将所有空闲块号分成若干组，每组最后一个空闲块登记下一组快线块的块号和总数。

本文如未解决您的问题请添加抖音号：51dongshi（抖音搜索懂视），直接咨询即可。