c語言used函數

1. c語言中如何復制數組的內容

C語言中復制數組的內容源代碼如下：

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#define SIZE 10

void show_array(const int ar[], int n);

int main()

{

int values[SIZE] = {1,2,3,4,5,6,7,8,9,10};

int target[SIZE];

double curious[SIZE / 2] =

{2.0, 2.0e5, 2.0e10, 2.0e20, 5.0e30};

puts("memcpy() used:");
puts("values (original data): ");
show_array(values, SIZE);
memcpy(target, values, SIZE * sizeof(int));
puts("target ( of values):");
show_array(target, SIZE);
puts(" Using memmove() with overlapping ranges:");
memmove(values + 2, values, 5 * sizeof(int));
puts("values -- elements 0-5 copied to 2-7:");
show_array(values, SIZE);
puts(" Using memcpy() to double to int:");
memcpy(target, curious, (SIZE / 2) * sizeof(double));
puts("target -- 5 doubles into 10 int positions:");
show_array(target, SIZE/2);
show_array(target + 5, SIZE/2);
system("pause");
return 0;
}
void show_array(const int ar[], int n)
{
int i;
for (i = 0; i < n; i++)
printf("%d ", ar[i]);
putchar(' ');
}

(1)c語言used函數擴展閱讀

1、C語言編程中，將常用的操作封裝成函數進行調用，可以大大簡化程序的編寫，而且在代碼的維護性及可讀性方面也提供了便利。

2、不同地方需要對處理後的數組內容多次進行顯示，並且很多情況下並非顯示數組裡面的全部內容，而僅僅是想觀察數組中的部分數據內容，若每次顯示時都用printf函數寫的話，可以寫一個自定義的通用函數，用來根據需要顯示數組中的內容。

2. C語言中時間的函數

一.概念

在C/C++中，通過學習許多C/C++庫，你可以有很多操作、使用時間的方法。但在這之前你需要了解一些「時間」和「日期」的概念，主要有以下幾個：

1. 協調世界時，又稱為世界標准時間，也就是大家所熟知的格林威治標准時間(Greenwich Mean Time，GMT)。比如，中國內地的時間與UTC的時差為+8，也就是UTC+8。美國是UTC-5。

2. 日歷時間，是用「從一個標准時間點到此時的時間經過的秒數」來表示的時間。這個標准時間點對不同的編譯器來說會有所不同，但對一個編譯系統來說，這個標准時間點是不變的，該編譯系統中的時間對應的日歷時間都通過該標准時間點來衡量，所以可以說日歷時間是「相對時間」，但是無論你在哪一個時區，在同一時刻對同一個標准時間點來說，日歷時間都是一樣的。

3. 時間點。時間點在標准C/C++中是一個整數，它用此時的時間和標准時間點相差的秒數(即日歷時間)來表示。

4. 時鍾計時單元(而不把它叫做時鍾滴答次數)，一個時鍾計時單元的時間長短是由CPU控制的。一個clock tick不是CPU的一個時鍾周期，而是C/C++的一個基本計時單位。

我們可以使用ANSI標准庫中的time.h頭文件。這個頭文件中定義的時間和日期所使用的方法，無論是在結構定義，還是命名，都具有明顯的C語言風格。下面，我將說明在C/C++中怎樣使用日期的時間功能。

二. 介紹

1. 計時

C/C++中的計時函數是clock()，而與其相關的數據類型是clock_t。在MSDN中，查得對clock函數定義如下：

clock_t clock( void );

這個函數返回從「開啟這個程序進程」到「程序中調用clock()函數」時之間的CPU時鍾計時單元(clock tick)數，在MSDN中稱之為掛鍾時間(wal-clock)。其中clock_t是用來保存時間的數據類型，在time.h文件中，我們可以找到對它的定義：

#ifndef _CLOCK_T_DEFINED

typedef long clock_t;

#define _CLOCK_T_DEFINED

#endif

很明顯，clock_t是一個長整形數。在time.h文件中，還定義了一個常量CLOCKS_PER_SEC，它用來表示一秒鍾會有多少個時鍾計時單元，其定義如下：

#define CLOCKS_PER_SEC ((clock_t)1000)

可以看到每過千分之一秒(1毫秒)，調用clock()函數返回的值就加1。下面舉個例子，你可以使用公式clock()/CLOCKS_PER_SEC來計算一個進程自身的運行時間：

void elapsed_time()

{

printf("Elapsed time:%u secs. ",clock()/CLOCKS_PER_SEC);

}

當然，你也可以用clock函數來計算你的機器運行一個循環或者處理其它事件到底花了多少時間：

/* 測量一個事件持續的時間*/

/* Date : 10/24/2007 */

#include "stdio.h"

#include "stdlib.h"

#include "time.h"

int main( void )

{

long i = 10000000L;

clock_t start, finish;

double ration;

/* 測量一個事件持續的時間*/

printf( "Time to do %ld empty loops is ", i );

start = clock();

while( i-- ) ;

finish = clock();

ration = (double)(finish - start) / CLOCKS_PER_SEC;

printf( "%f seconds ", ration );

system("pause");

}

在筆者的機器上，運行結果如下：

Time to do 10000000 empty loops is 0.03000 seconds

上面我們看到時鍾計時單元的長度為1毫秒，那麼計時的精度也為1毫秒，那麼我們可不可以通過改變CLOCKS_PER_SEC的定義，通過把它定義的大一些，從而使計時精度更高呢?通過嘗試，你會發現這樣是不行的。在標准C/C++中，最小的計時單位是一毫秒。

2.與日期和時間相關的數據結構

在標准C/C++中，我們可通過tm結構來獲得日期和時間，tm結構在time.h中的定義如下：

#ifndef _TM_DEFINED

struct tm {

int tm_sec; /* 秒 – 取值區間為[0,59] */

int tm_min; /* 分 - 取值區間為[0,59] */

int tm_hour; /* 時 - 取值區間為[0,23] */

int tm_mday; /* 一個月中的日期 - 取值區間為[1,31] */

int tm_mon; /* 月份(從一月開始，0代表一月) - 取值區間為[0,11] */

int tm_year; /* 年份，其值等於實際年份減去1900 */

int tm_wday; /* 星期 – 取值區間為[0,6]，其中0代表星期天，1代表星期一，以此類推 */

int tm_yday; /* 從每年的1月1日開始的天數 – 取值區間為[0,365]，其中0代表1月1日，1代表1月2日，以此類推 */

int tm_isdst; /* 夏令時標識符，實行夏令時的時候，tm_isdst為正。不實行夏令時的進候，tm_isdst為0;不了解情況時，tm_isdst()為負。*/

};

#define _TM_DEFINED

#endif

ANSI C標准稱使用tm結構的這種時間表示為分解時間(broken-down time)。

而日歷時間(Calendar Time)是通過time_t數據類型來表示的，用time_t表示的時間(日歷時間)是從一個時間點(例如：1970年1月1日0時0分0秒)到此時的秒數。在time.h中，我們也可以看到time_t是一個長整型數：

#ifndef _TIME_T_DEFINED

typedef long time_t; /* 時間值 */

#define _TIME_T_DEFINED /* 避免重復定義 time_t */

#endif

大家可能會產生疑問：既然time_t實際上是長整型，到未來的某一天，從一個時間點(一般是1970年1月1日0時0分0秒)到那時的秒數(即日歷時間)超出了長整形所能表示的數的范圍怎麼辦?對time_t數據類型的值來說，它所表示的時間不能晚於2038年1月18日19時14分07秒。為了能夠表示更久遠的時間，一些編譯器廠商引入了64位甚至更長的整形數來保存日歷時間。比如微軟在Visual C++中採用了__time64_t數據類型來保存日歷時間，並通過_time64()函數來獲得日歷時間(而不是通過使用32位字的time()函數)，這樣就可以通過該數據類型保存3001年1月1日0時0分0秒(不包括該時間點)之前的時間。

在time.h頭文件中，我們還可以看到一些函數，它們都是以time_t為參數類型或返回值類型的函數：

double difftime(time_t time1, time_t time0);

time_t mktime(struct tm * timeptr);

time_t time(time_t * timer);

char * asctime(const struct tm * timeptr);

char * ctime(const time_t *timer);

此外，time.h還提供了兩種不同的函數將日歷時間(一個用time_t表示的整數)轉換為我們平時看到的把年月日時分秒分開顯示的時間格式tm：

struct tm * gmtime(const time_t *timer);

struct tm * localtime(const time_t * timer);

通過查閱MSDN，我們可以知道Microsoft C/C++ 7.0中時間點的值(time_t對象的值)是從1899年12月31日0時0分0秒到該時間點所經過的秒數，而其它各種版本的Microsoft C/C++和所有不同版本的Visual C++都是計算的從1970年1月1日0時0分0秒到該時間點所經過的秒數。

3.與日期和時間相關的函數及應用

在本節，我將向大家展示怎樣利用time.h中聲明的函數對時間進行操作。這些操作包括取當前時間、計算時間間隔、以不同的形式顯示時間等內容。

4. 獲得日歷時間

我們可以通過time()函數來獲得日歷時間(Calendar Time)，其原型為：

time_t time(time_t * timer);

如果你已經聲明了參數timer，你可以從參數timer返回現在的日歷時間，同時也可以通過返回值返回現在的日歷時間，即從一個時間點(例如：1970年1月1日0時0分0秒)到現在此時的秒數。如果參數為空(NUL)，函數將只通過返回值返回現在的日歷時間，比如下面這個例子用來顯示當前的日歷時間：

運行的結果與當時的時間有關，我當時運行的'結果是：

/* Date : 10/24/2007 */

/* Author: Eman Lee */

#include "stdio.h"

#include "stdlib.h"

#include "time.h"

int main(void)

{

time_t lt;

lt =time(NULL);

printf("The Calendar Time now is %d ",lt);

return 0;

}

The Calendar Time now is 1122707619

其中1122707619就是我運行程序時的日歷時間。即從1970-01-01 08:00:00到此時的秒數。

5. 獲得日期和時間

這里說的日期和時間就是我們平時所說的年、月、日、時、分、秒等信息。從第2節我們已經知道這些信息都保存在一個名為tm的結構體中，那麼如何將一個日歷時間保存為一個tm結構的對象呢?

其中可以使用的函數是gmtime()和localtime()，這兩個函數的原型為：

struct tm * gmtime(const time_t *timer);

struct tm * localtime(const time_t * timer);

其中gmtime()函數是將日歷時間轉化為世界標准時間(即格林尼治時間)，並返回一個tm結構體來保存這個時間，而localtime()函數是將日歷時間轉化為本地時間。比如現在用gmtime()函數獲得的世界標准時間是2005年7月30日7點18分20秒，那麼我用localtime()函數在中國地區獲得的本地時間會比世界標准時間晚8個小時，即2005年7月30日15點18分20秒。下面是個例子：

//本地時間,世界標准時間

/* Date : 10/24/2007 */

/* Author: Eman Lee */

#include "stdio.h"

#include "stdlib.h"

#include "time.h"

int main(void)

{

struct tm *local;

time_t t;

t=time(NULL);

local=localtime(&t);

printf("Local hour is: %d:%d:%d ",local->tm_hour,local->tm_min,local->tm_sec);

local=gmtime(&t);

printf("UTC hour is: %d:%d:%d ",local->tm_hour,local->tm_min,local->tm_sec);

return 0;

}

運行結果是：

Local hour is: 23:17:47

UTC hour is: 15:17:47

6. 固定的時間格式

我們可以通過asctime()函數和ctime()函數將時間以固定的格式顯示出來，兩者的返回值都是char*型的字元串。返回的時間格式為：

星期幾 月份 日期 時:分:秒 年

例如：Wed Jan 02 02:03:55 1980

其中 是一個換行符，是一個空字元，表示字元串結束。下面是兩個函數的原型：

char * asctime(const struct tm * timeptr);

char * ctime(const time_t *timer);

其中asctime()函數是通過tm結構來生成具有固定格式的保存時間信息的字元串，而ctime()是通過日歷時間來生成時間字元串。這樣的話，asctime()函數只是把tm結構對象中的各個域填到時間字元串的相應位置就行了，而ctime()函數需要先參照本地的時間設置，把日歷時間轉化為本地時間，然後再生成格式化後的字元串。在下面，如果t是一個非空的time_t變數的話，那麼：

printf(ctime(&t));

等價於：

struct tm *ptr;

ptr=localtime(&t);

printf(asctime(ptr));

那麼，下面這個程序的兩條printf語句輸出的結果就是不同的了(除非你將本地時區設為世界標准時間所在的時區)：

//本地時間,世界標准時間

/* Date : 10/24/2007 */

/* Author: Eman Lee */

#include "stdio.h"

#include "stdlib.h"

#include "time.h"

int main(void)

{

struct tm *ptr;

time_t lt;

lt =time(NULL);

ptr=gmtime(<);

printf(asctime(ptr));

printf(ctime(<));

return 0;

}

運行結果：

Sat Jul 30 08:43:03 2005

Sat Jul 30 16:43:03 2005

7. 自定義時間格式

我們可以使用strftime()函數將時間格式化為我們想要的格式。它的原型如下：

size_t strftime(

char *strDest,

size_t maxsize,

const char *format,

const struct tm *timeptr

);

我們可以根據format指向字元串中格式命令把timeptr中保存的時間信息放在strDest指向的字元串中，最多向strDest中存放maxsize個字元。該函數返迴向strDest指向的字元串中放置的字元數。

函數strftime()的操作有些類似於sprintf()：識別以百分號(%)開始的格式命令集合，格式化輸出結果放在一個字元串中。格式化命令說明串strDest中各種日期和時間信息的確切表示方法。格式串中的其他字元原樣放進串中。格式命令列在下面，它們是區分大小寫的。

%a 星期幾的簡寫

%A 星期幾的全稱

%b 月分的簡寫

%B 月份的全稱

%c 標準的日期的時間串

%C 年份的後兩位數字

%d 十進製表示的每月的第幾天

%D 月/天/年

%e 在兩字元域中，十進製表示的每月的第幾天

%F 年-月-日

%g 年份的後兩位數字，使用基於周的年

%G 年分，使用基於周的年

%h 簡寫的月份名

%H 24小時制的小時

%I 12小時制的小時

%j 十進製表示的每年的第幾天

%m 十進製表示的月份

%M 十時製表示的分鍾數

%n 新行符

%p 本地的AM或PM的等價顯示

%r 12小時的時間

%R 顯示小時和分鍾：hh:mm

%S 十進制的秒數

%t 水平製表符

%T 顯示時分秒：hh:mm:ss

%u 每周的第幾天，星期一為第一天 (值從0到6，星期一為0)

%U 第年的第幾周，把星期日做為第一天(值從0到53)

%V 每年的第幾周，使用基於周的年

%w 十進製表示的星期幾(值從0到6，星期天為0)

%W 每年的第幾周，把星期一做為第一天(值從0到53)

%x 標準的日期串

%X 標準的時間串

%y 不帶世紀的十進制年份(值從0到99)

%Y 帶世紀部分的十進制年份

%z，%Z 時區名稱，如果不能得到時區名稱則返回空字元。

%% 百分號

如果想顯示現在是幾點了，並以12小時制顯示，就象下面這段程序：

//顯示現在是幾點了，並以12小時制顯示

/* Date : 10/24/2007 */

/* Author: Eman Lee */

#include "stdio.h"

#include "stdlib.h"

#include "time.h"

int main(void)

{

struct tm *ptr;

time_t localTime;

char str[80];

localTime=time(NULL);

ptr=localtime(&localTime);

strftime(str,100,"It is now %I %p ",ptr);

printf(str);

return 0;

}

其運行結果為：

It is now 4PM

而下面的程序則顯示當前的完整日期：

//顯示當前的完整日期

/* Date : 10/24/2007 */

/* Author: Eman Lee */

#include "stdio.h"

#include "stdlib.h"

#include "time.h"

void main( void )

{

struct tm *newtime;

char tmpbuf[128];

time_t localTime1;

time( &localTime1 );

newtime=localtime(&localTime1);

strftime( tmpbuf, 128, "Today is %A, day %d of %B in the year %Y. ", newtime);

printf(tmpbuf);

}

運行結果：

Today is Saturday, day 30 of July in the year 2005.

8. 計算持續時間的長度

有時候在實際應用中要計算一個事件持續的時間長度，比如計算打字速度。在第1節計時部分中，我已經用clock函數舉了一個例子。Clock()函數可以精確到毫秒級。同時，我們也可以使用difftime()函數，但它只能精確到秒。該函數的定義如下：

double difftime(time_t time1, time_t time0);

雖然該函數返回的以秒計算的時間間隔是double類型的，但這並不說明該時間具有同double一樣的精確度，這是由它的參數覺得的(time_t是以秒為單位計算的)。比如下面一段程序：

//計算持續時間的長度

/* Date : 10/24/2007 */

/* Author: Eman Lee */

#include "stdio.h"

#include "stdlib.h"

#include "time.h"

int main(void)

{

time_t start,end;

start = time(NULL);

system("pause");

end = time(NULL);

printf("The pause used %f seconds. ",difftime(end,start));//<-

system("pause");

return 0;

}

運行結果為：

請按任意鍵繼續. . .

The pause used 2.000000 seconds.

請按任意鍵繼續. . .

可以想像，暫停的時間並不那麼巧是整整2秒鍾。其實，你將上面程序的帶有「//<-」注釋的一行用下面的一行代碼替換：

printf("The pause used %f seconds. ",end-start);

其運行結果是一樣的。

9. 分解時間轉化為日歷時間

這里說的分解時間就是以年、月、日、時、分、秒等分量保存的時間結構，在C/C++中是tm結構。我們可以使用mktime()函數將用tm結構表示的時間轉化為日歷時間。其函數原型如下：

time_t mktime(struct tm * timeptr);

其返回值就是轉化後的日歷時間。這樣我們就可以先制定一個分解時間，然後對這個時間進行操作了，下面的例子可以計算出1997年7月1日是星期幾：

//計算出1997年7月1日是星期幾

/* Date : 10/24/2007 */

/* Author: Eman Lee */

#include "stdio.h"

#include "stdlib.h"

#include "time.h"

int main(void)

{

struct tm time;

time_t t_of_day;

time.tm_year=1997-1900;

time.tm_mon=6;

time.tm_mday=1;

time.tm_hour=0;

time.tm_min=0;

time.tm_sec=1;

time.tm_isdst=0;

t_of_day=mktime(&time);

printf(ctime(&t_of_day));

return 0;

}

運行結果：

Tue Jul 01 00:00:01 1997

有了mktime()函數，是不是我們可以操作現在之前的任何時間呢?你可以通過這種辦法算出1945年8月15號是星期幾嗎?答案是否定的。因為這個時間在1970年1月1日之前，所以在大多數編譯器中，這樣的程序雖然可以編譯通過，但運行時會異常終止。

註：linux系統時間如果轉換為 time_t 類型，都是從1970-01-01 08:00:00 開始計算

3. c語言中函數怎麼說明

「怎麼說明」?
這是什麼zd意思啊？你想問什麼呢？
*************************************
如果是系統函數，就包含對應的頭文件，例如：
要用內到printf()函數以及scanf()函數，就包含stdio.h頭文件。
如果是自定義函數，可以將函數的定義寫在容主函數前面，也可以將自定義函數的頭部寫在調用之前（一般情況下是寫在主函數前）。

4. 最壞適應演算法 c語言

/**------------------------------------------------------
進入程序後可以根據菜單選項進入不同的模塊
1.使用首次適應演算法分配空間
2.使用最佳適應演算法分配空間
3.釋放一塊空間
4.顯示內存分配情況
5.退出系統
----------------------------------------------------------**/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>

#define MEMSIZE 100 /*定義內存大小為100*/
#define MINSIZE 2 /*如果小於此值 將不再分割內存*/

typedef struct _MemoryInfomation{/* 內存空間分區表 結構*/
int start; /*起始地址*/
int size; /*大小*/
char info; /*狀態 F:空閑(Free) U:佔用(Used) E 結束(end)*/
}MEMINFO;

MEMINFO MemList[MEMSIZE]; //內存空間信息表

void Display();

/*--------------------------------------------------------
函數名:InitALL()
功 能:初始化所有變數
--------------------------------------------------------*/
void InitAll(){
int i;
MEMINFO temp={0,0,'e'};
for(i=0;i<MEMSIZE;i++) //初始化空間信息表
MemList[i]=temp;
MemList[0].start=0; //起始地址為0
MemList[0].size=MEMSIZE;//空間初始為最大的
MemList[0].info='f'; //狀態為空閑
}
/*--------------------------------------------------------
函數名:FirstFit_new()
功 能:首次適應演算法分配內存
--------------------------------------------------------*/
void FirstFit_new(){
int i,j,size;
char temp[10];
printf("FirstFit_new:How many MEMORY requir?");
gets(temp);
size=atoi(temp); //將字元串轉化為整數
for(i=0; i < MEMSIZE-1 && MemList[i].info != 'e';i++) //到了空間尾且沒有空間分配
{
if(MemList[i].size >= size && MemList[i].info=='f') //滿足所需要的大小，且是空閑空間
{
if(MemList[i].size - size <= MINSIZE) //如果小於規定的最小差則將整個空間分配出去
MemList[i].info='u'; //標志為使用
else
{
for(j = MEMSIZE-2; j > i; j--) //將i後的信息表元素後移
{
MemList[j+1]=MemList[j];
}
//將i分成兩部分，使用低地址部分
MemList[i+1].start= MemList[i].start+size;
MemList[i+1].size = MemList[i].size-size;
MemList[i+1].info='f';
MemList[i].size=size;
MemList[i].info='u';
}
break;
}
}
if(i == MEMSIZE-1 || MemList[i].info=='e') //沒有找到符合分配的空間
{
printf("Not Enough Memory!!\n");
getchar();
}
Display();
}

/*--------------------------------------------------------
函數名:BestFit_new()
功 能:最佳適應演算法分配內存
--------------------------------------------------------*/
void BestFit_new()
{
int i,j,k,flag,size;
char temp[10];
printf("BestFit_new How many MEMORY requir?");
gets(temp);
size=atoi(temp); //將字元串轉化為整數
j=0;
flag=0; //標志是否有合適的空間分配，0無，1有
k=MEMSIZE; //用來保存滿足要求的最小空間

for(i=0;i<MEMSIZE-1 && MemList[i].info!='e';i++)
{
if(MemList[i].size >= size && MemList[i].info == 'f') //符合要求
{
flag=1;
if(MemList[i].size < k) //比符合要求的最小空間小，則交換
{
k=MemList[i].size;
j=i;
}
}
}
i=j;
if(flag == 0) //沒找到
{
printf("Not Enough Memory!\n");
getch();
j=i;
}
else if(MemList[i].size - size <= MINSIZE) //小於規定的最小差，將整個空間分配
MemList[i].info='u';
else
{
for(j = MEMSIZE-2; j > i; j--) //後移
MemList[j+1]=MemList[j];
MemList[i+1].start=MemList[i].start+size;
MemList[i+1].size=MemList[i].size-size;
MemList[i+1].info='f';
MemList[i].size=size;
MemList[i].info='u';
}
Display();
}

/*--------------------------------------------------------
最壞適應演算法
*/
void BadFit_new()
{
int i,j,k,flag,size;
char temp[10];
printf("BadFit_new How many MEMORY requir?");
gets(temp);
size=atoi(temp);
j=0;
flag=0;
k=0; //保存滿足要求的最大空間

for(i=0;i<MEMSIZE-1&&MemList[i].info!='e';i++)
{
if(MemList[i].size>=size&&MemList[i].info=='f')
{
flag=1;
if(MemList[i].size>k)
{
k=MemList[i].size;
j=i;
}
}
}
i=j;

if(flag=0)
{
printf("Not Enough Memory!\n");
getch();
j=i;
}
else if(MemList[i].size-size<=MINSIZE)
MemList[i].info='u';
else
{
for(j=MEMSIZE-2;j>i;j--)
MemList[j+1]=MemList[j];
MemList[i+1].start=MemList[i].start+size;
MemList[i+1].size=MemList[i].size-size;
MemList[i+1].info='f';
MemList[i].size=size;
MemList[i].info='u';
}
Display();
}

/*--------------------------------------------------------

函數名:del()
功 能:釋放一塊內存
--------------------------------------------------------*/
void del()
{
int i,number;
char temp[10];
printf("\nplease input the NUMBER you want stop:");
gets(temp);
number=atoi(temp);

if(MemList[number].info == 'u') //輸入的空間是使用的
{
MemList[number].info = 'f'; //標志為空閑
if(MemList[number+1].info == 'f') //右空間為空則合並
{
MemList[number].size+=MemList[number+1].size; //大小合並
for(i=number+1;i < MEMSIZE-1 && MemList[i].info !='e';i++)/* i後的空間信息表元素前移 */
if(i>0)
MemList[i]=MemList[i+1];
}
if(number > 0 && MemList[number-1].info=='f') //左空間空閑則合並
{
MemList[number-1].size+=MemList[number].size;
for(i=number;i<MEMSIZE-1&&MemList[i].info!='e';i++)
MemList[i]=MemList[i+1];
}
}
else
{
printf("Thist Number is Not exist or is Not used!\n ");
getchar();
}
Display();
}

/*--------------------------------------------------------
函數名:Display()
功 能:顯示內存狀態
--------------------------------------------------------*/
void Display(){
int i,
used=0; //記錄可以使用的總空間量

/* clrscr();*/
printf("\n----------------------------------------------\n");
printf("%5s%15s%15s","Number","start","size","Info");
printf("\n----------------------------------------------\n");
for(i=0;i < MEMSIZE && MemList[i].info != 'e';i++)
{
if(MemList[i].info == 'u')
used+=MemList[i].size;
printf("%5d%15d%15d%15s\n",i,MemList[i].start,MemList[i].size,MemList[i].info=='u'?"USED":"FREE");
}
printf("\n----------------------------------------------\n");
printf("Totalsize:%-10d Used:%-10d Free:%-10d\n",MEMSIZE,used,MEMSIZE-used);
printf("\n\n Press Any Key to return...");
getch();
}

/*--------------------------------------------------------
函數名:main()
功 能:主函數
--------------------------------------------------------*/
void main(){
char ch;
InitAll();
while(1){
printf("========================================================\n");
printf(" 1.Get a block use the FISTFIT method\n");
printf(" 2.Get a block use the BESTFIT method\n");
printf(" 3.Get a block use the BadFIT method\n");
printf(" 4.Free a block\n");
printf(" 5.Display Mem info \n");
printf(" 6.Exit \n");
printf("========================================================\n");
ch=getch();
switch(ch){
case '1':FirstFit_new();break; //首次適應演算法
case '2':BestFit_new();break; //最佳適應演算法
case '3':BadFit_new();break; //最壞適應演算法
case '4':del();break; //刪除已經使用完畢的空間
case '5':Display();break; //顯示內存分配情況
case '6':exit(0);
}
}
}

5. c語言的運算符號數組替代

運算符號字元只是一個記號，最後由程序翻譯就好了。我看樓主問題似乎和計算24點的問題有點相似，我正好寫了一個，就是全搜索，計算所有可能的解，式子表現為一顆二叉樹，葉子節點是數，其它節點代表運算符。代碼如下，僅供參考：

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

/*
*gametoget24,given,foursymbols(+-*/)
*willmaxf(n)=3**(n-1)*n!*(n-1)!values
*f(4)=3888f(5)=233280
*f(6)=20995200f(7)=2645395200
*somaybe6or7isthelimited.
*/

#defineLMX_ABS(a)((a)<0?(-(a)):(a))
boolDblEqual_L(doublea,doubleb)
{
returnLMX_ABS(a-b)<0.0000001;
}

#defineMAXN6
#defineMAX_SAVE128

intn=4,aim=24;
intv[MAXN]={5,3,7,8};
charsymbols[8]="+-_*/?";

structNode
{
doubleval;
intsyb;
structNode*l,*r,*p;
};

Nodenode[(MAXN*2-1)*MAX_SAVE],curr[MAXN*2-1];
Node*root[MAX_SAVE];
boolused[MAXN*2-1];

inti_save,i_exist,i_base;

voidDfsCopy_L(Node*q,Node*p)
{
if(p->l!=NULL){
node[i_base].p=q;
node[i_base].val=p->l->val;
node[i_base].syb=p->l->syb;
q->l=&node[i_base];
i_base++;
node[i_base].p=q;
node[i_base].val=p->r->val;
node[i_base].syb=p->r->syb;
q->r=&node[i_base];
i_base++;
DfsCopy_L(q->l,p->l);
DfsCopy_L(q->r,p->r);
}
}
voidSave_L(Node*p)
{
i_base=i_save*(MAXN*2-1);
root[i_save]=&node[i_base];
Node*q=root[i_save];
q->val=p->val;
q->syb=p->syb;
i_base++;
DfsCopy_L(q,p);
i_save++;
}

voidPrint_L(Node*p)
{
if(p->syb<0)printf("%d",(int)(p->val+0.0001));
elseif(p->syb==2||p->syb==5){
printf("(");
Print_L(p->r);
printf("%c",symbols[p->syb-1]);
Print_L(p->l);
printf(")");
}else{
printf("(");
Print_L(p->l);
printf("%c",symbols[p->syb]);
Print_L(p->r);
printf(")");
}
}

doubleCal_L(doublea,doubleb,intk)
{
doubler;
switch(k)
{
case0:r=a+b;break;
case1:r=a-b;break;
case2:r=b-a;break;
case3:r=a*b;break;
case4:r=a/b;break;
case5:r=b/a;break;
default:r=1.0;break;
}
returnr;
}
voidgo(intstep)
{
if(step==2*n-1){
inti=2*n-2;
if(DblEqual_L(curr[i].val,aim)){
i_exist++;
if(i_save<MAX_SAVE){
Save_L(&curr[i]);
}
Print_L(&curr[i]);
printf("
");
}
return;
}
inti,j,k;
for(i=0;i<step-1;i++)
if(used[i])
for(j=i+1;j<step;j++)
if(used[j]){
used[i]=false;
used[j]=false;
used[step]=true;
curr[step].l=&curr[i];
curr[step].r=&curr[j];
curr[i].p=&curr[step];
curr[j].p=&curr[step];
for(k=0;k<6;k++)
{
curr[step].syb=k;
curr[step].val=Cal_L(curr[i].val,curr[j].val,k);
go(step+1);
}
used[i]=true;
used[j]=true;
used[step]=false;
}
}
intmain(intargc,char*argv[])
{
inti;
for(i=0;i<n;i++)
{
curr[i].val=v[i];
curr[i].syb=-1;
used[i]=true;
}
go(n);
return0;
}