c語言allocate
A. 採用c語言實現首次適應演算法完成主存空間的分配和回收 急
有沒有具體的要求，比方說數據結構方面，我這有一個，你可以參考參考
#include"stdio.h"
#include"stdlib.h"
#define
n
10
/*假定系統允許的最大作業為n，假定模擬實驗中n值為10*/
#define
m
10
/*假定系統允許的空閑區表最大為m，假定模擬實驗中m值為10*/
#define
minisize
100
struct{
float
address;
/*已分分區起始地址*/
float
length;
/*已分分區長度，單位為位元組*/
int
flag;
/*已分配區表登記欄標志，用"0"表示空欄目*/
}used_table[n];
/*已分配區表*/
struct{
float
address;
/*空閑區起始地址*/
float
length;
/*空閑區長度，單位為位元組*/
int
flag;
/*空閑區表登記欄標志，用"0"表示空欄目，用"1"表示未分配*/
}free_table[m];
/*空閑區表*/
void
main(
)
{
int
i,a;
void
allocate(char
str,float
leg);//分配主存空間函數
void
reclaim(char
str);//回收主存函數
float
xk;
char
J;/*空閑分區表初始化：*/
free_table[0].address=10240;
free_table[0].length=102400;
free_table[0].flag=1;
for(i=1;i<m;i++)
free_table[i].flag=0;/*已分配表初始化：*/
for(i=0;i<n;i++)
used_table[i].flag=0;
while(1)
{
printf("\n選擇功能項（0-退出,1-分配主存,2-回收主存,3-顯示主存）\n");
printf("選擇功項(0~3)
:");
scanf("%d",&a);
switch(a)
{
case
0:
exit(0);
/*a=0程序結束*/
case
1:
/*a=1分配主存空間*/printf("輸入作業名J和作業所需長度xk:
");
scanf("%*c%c%f",&J,&xk);
allocate(J,xk);/*分配主存空間*/
break;
case
2:
/*a=2回收主存空間*/printf("輸入要回收分區的作業名");
scanf("%*c%c",&J);reclaim(J);/*回收主存空間*/
break;
case
3:
/*a=3顯示主存情況*//*輸出空閑區表和已分配表的內容*/
printf("輸出空閑區表：\n起始地址
分區長度
標志\n");
for(i=0;i<m;i++)
printf("%6.0f%9.0f%6d\n",free_table[i].address,free_table[i].length,
free_table[i].flag);
printf("
按任意鍵,輸出已分配區表\n");
getchar();
printf("
輸出已分配區表：\n起始地址
分區長度
標志\n");
for(i=0;i<n;i++)
if(used_table[i].flag!=0)
printf("%6.0f%9.0f%6c\n",used_table[i].address,used_table[i].length,
used_table[i].flag);
else
printf("%6.0f%9.0f%6d\n",used_table[i].address,used_table[i].length,
used_table[i].flag);
break;
default:printf("沒有該選項\n");
}/*case*/
}/*while*/
}/*主函數結束*/
int
uflag;//分配表標志
int
fflag;//空閑表標志
float
uend_address;
float
fend_address;
void
allocate(char
str,float
leg)
{
uflag=0;fflag=0;
int
k,i;float
ressize;
for(i=0;i<m;i++)
{
if(free_table[i].flag==1
&&
free_table[i].length>=leg)
{
fflag=1;break;
}
}
if(fflag==0)
printf("沒有滿足條件的空閑區\n");
else
{
ressize=free_table[i].length-leg;
for(k=0;k<n;k++)
{
if(used_table[k].flag==0)
{
if(ressize<minisize)//剩餘塊過小
{
used_table[k].length=free_table[i].length;
used_table[k].address=free_table[i].address;
used_table[k].flag=str;
free_table[i].length=0;
free_table[i].flag=0;
break;
}
else
{
used_table[k].address=free_table[i].address+ressize;
used_table[k].flag=str;
used_table[k].length=leg;
free_table[i].length=ressize;
break;
}
}
}//for結束
}
}
void
reclaim(char
str)
{
uflag=0;fflag=0;
int
k,i;
for(k=0;k<n;k++)
{
if(used_table[k].flag==str)
{
uflag=1;break;
}
}
if(uflag==0)
printf("\n找不到該作業!\n");
else
{
for(i=0;i<m;i++)
{
uend_address=used_table[k].address+used_table[k].length;
fend_address=free_table[i].address+free_table[i].length;
if(used_table[k].address==fend_address)//上鄰
{
fflag=1;
free_table[i].length=free_table[i].length+used_table[k].length;
free_table[i].flag=1;
used_table[k].flag=0;
used_table[k].length=0;
used_table[k].address=0;
printf("\n已回收!\n");
break;
}
else
{
if(free_table[i].address==uend_address)//下鄰
{
fflag=1;
free_table[i].address=used_table[k].address;
free_table[i].length=free_table[i].length+used_table[k].length;
free_table[i].flag=1;
used_table[k].flag=0;
used_table[k].length=0;
used_table[k].address=0;
printf("\n已回收!\n");
break;
}
}
}//for結束
if(fflag==0)
{
i=0;
for(i=0;i<m;i++)
{
if(free_table[i].flag==0)
{
free_table[i].address=used_table[k].address;
free_table[i].length=used_table[k].length;
free_table[i].flag=1;
used_table[k].length=0;
used_table[k].flag=0;
used_table[k].address=0;
break;
}
}
printf("\n已回收!\n");
}
}
}
B. 如何用python封裝C語言的字元串處理函數
在C語言中，字元串處理是每天都要面對的問題。我們都知道C語言中其實並沒有一種原生的字元串類型，『字元串』在C語言里只是一種特殊的以''結尾的字元數組。因此，如何將C語言與更高層次的Python語言在『字元串』處理這個問題上對接是一個有難度的問題。所幸有swig這種強大的工具。
如何封裝一個函數，它修改參數字元串的內容
假如有這樣一個C語言的函數，
<!-- lang: cpp -->
void FillZero(char* pc,size_t * piLen)
{
size_t i=0;
while(i++<*piLen/2 )
*pc++ = '0';
*pc = 0;
*piLen = i+1;
}
這個函數的功能是把字元串變成n個0。不過我們更關注函數的形式。這樣的函數，表面上看char* pc是函數的參數，可是實際上它才是函數的返回值和執行的結果。piLen這個參數既是pc的最大長度，也是新的字元串的長度。我們直接用python封裝，看看運行結果。
Type "help", "right", "credits" or "license" for more information.
>>> import cchar
>>> s='123456'
>>> cchar.FillZero(s,6)
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
TypeError: in method 'FillZero', argument 2 of type 'size_t *'
結果差強人意，不是我們想要得到的結果。函數的第二個參數為size_t* 我們很難用python來表示，而且python中也不存在既是輸入，也是輸出的參數。
swig有一個標准庫，其中有一個cstring.i文件就是用來解決C語言字元串類型的問題。
我們在.i文件中加入這樣幾行
<!-- lang: cpp -->
%include "cstring.i"
%cstring_output_withsize(char* pc,size_t* pi)
void FillZero(char* pc, size_t* pi);
然後運行看結果
Type "help", "right", "credits" or "license" for more information.
>>> import cchar
>>> cchar.FillZero(10)
'00000\x00'
>>> s=cchar.FillZero(10)
>>> print s
00000
我們看函數的變化。首先在python里， FillZero變成了只有一個參數的函數。然後函數的返回值變成了一個字元串。其實cstring_output_size其實是一個宏，通過這個宏的定義改變了函數的形式，直接在Python中得到我們想要的結果。
其實類似cstring_output_size的宏還有好幾個，我列舉一下:
cstring_output_allocate(char *s,free($1));
第一個參數是指向字元串地址的指針，第二個參數為釋放空間的方法。
大家考慮這一下這樣的函數：
void foo(char* & s)
{
s = (char*)malloc(10);
memcpy(s,"123456789",9);
}
s這個參數表面上看是輸入，實際上是函數真正的輸出。 函數中真正改變的東西是char&s指向的字元串的值。而且char&這個類型,
python或者其他腳本語言里應該都沒有對應的類型。那麼我們用cstring_output_allocate將這個函數轉換成另外一個形式的python或者其他腳本語言的函數。轉換後的函數其實是這樣的，以python為例str
foo()。
<!-- lang: cpp -->
%mole a
%include "cstring.i"
%{
void foo(char*& s);
%}
%cstring_output_allocate(char *&s, free(*$1));
void foo(char *&s);
在python中的調用：
<!-- lang: python -->
>>> import a
>>> a.foo()
'123456789'
>>>
cstring_output_maxsize(char *path, int maxpath);
第一個參數也是可以改變的字元串首地址，第二個參數為字元串的最大長度。在Python中調用的時候，只有maxpath這個參數，返回字元串。
cstring_output_allocate(char *s, free($1));
第一個參數為指向字元串首地址的指針，第二個參數為釋放指針的方法。這個宏主要是封裝一種直接在函數內部malloc空間的函數。在Python中調用時沒有參數，直接返回字元串。
cstring_output_allocate_size(char *s, int slen, free(*$1));
這個相當於前面兩個函數的組合。在函數內部malloc空間，然後將字元串長度通過slen返回。其實在調用的時候非常簡單，沒有參數，直接返回字元串。
如何處理c++的std::string
std::string是C++標准類庫STL中常見的類。在平時工作中大家肯定是沒少用。在python中如何封裝std::string? swig提供了標准庫
例如函數:
<!-- lang: cpp -->
string Repeat(const string& s)
{
return s+s;
}
只要在swig中加入這樣幾行：
<!-- lang: cpp -->
%include "std_string.i"
using namespace std;
string Repeat(const string& s);
運行結果：
Python 2.6.6 (r266:84292, Dec 27 2010, 00:02:40)
[GCC 4.4.5] on linux2
Type "help", "right", "credits" or "license" for more information.
>>> import cchar
>>> cchar.Repeat('123')
'123123'
使用起來很方便，但需要注意的是，假如函數的參數的內容是可以被修改，就不能用這種方式封裝。
例如:
<!-- lang: cpp -->
void repeat(string s)
{
s+=s;
}
這樣的函數直接使用 'std_string.i' 就是無效的。遇到這種函數，只能用C語言封裝成 void repeat(chars, int maxsize), 再用swig調用 'cstring_output_withsize' 這個宏再封裝一次了。