可重入函數與不可重入函數
主要用于多任務環境中，一個可重入的函數簡單來說就是可以被中斷的函數，也就是說，可以在這個函數執行的任何時刻中斷它，轉入OS調度下去執行另外一段代碼，而返回控制時不會出現什么錯誤；而不可重入的函數由于使用了一些系統資源，比如全局變量區，中斷向量表等，所以它如果被中斷的話，可能會出現問題，這類函數是不能運行在多任務環境下的。
也可以這樣理解，重入即表示重復進入，首先它意味著這個函數可以被中斷，其次意味著它除了使用自己棧上的變量以外不依賴于任何環境（包括static），這樣的函數就是purecode（純代碼）可重入，可以允許有該函數的多個副本在運行，由于它們使用的是分離的棧，所以不會互相干擾。如果確實需要訪問全局變量（包括static），一定要注意實施互斥手段。可重入函數在并行運行環境中非常重要，但是一般要為訪問全局變量付出一些性能代價。
編寫可重入函數時，若使用全局變量，則應通過關中斷、信號量（即P、V操作）等手段對其加以保護。
說明：若對所使用的全局變量不加以保護，則此函數就不具有可重入性，即當多個進程調用此函數時，很有可能使有關全局變量變為不可知狀態。
示例：假設Exam是int型全局變量，函數Squre_Exam返回Exam平方值。那么如下函數不具有可重入性。
unsigned int example( int para )
{
unsigned int temp;
Exam = para; // （**）
temp = Square_Exam( );
return temp;
}
此函數若被多個進程調用的話，其結果可能是未知的，因為當（**）語句剛執行完后，另外一個使用本函數的進程可能正好被激活，那么當新激活的進程執行到此函數時，將使Exam賦與另一個不同的para值，所以當控制重新回到“temp = Square_Exam( )”后，計算出的temp很可能不是預想中的結果。此函數應如下改進。
unsigned int example( int para ) {
unsigned int temp;
[申請信號量操作] //(1)
Exam = para;
temp = Square_Exam( );
[釋放信號量操作]
return temp;
}
(1)若申請不到“信號量”，說明另外的進程正處于給Exam賦值并計算其平方過程中（即正在使用此信號）,本進程必須等待其釋放信號后，才可繼續執行。若申請到信號，則可繼續執行，但其它進程必須等待本進程釋放信號量后，才能再使用本信號。
保證函數的可重入性的方法：
在寫函數時候盡量使用局部變量（例如寄存器、堆棧中的變量），對于要使用的全局變量要加以保護（如采取關中斷、信號量等方法），這樣構成的函數就一定是一個可重入的函數。
VxWorks中采取的可重入的技術有：
* 動態堆棧變量（各子函數有自己獨立的堆棧空間）
* 受保護的全局變量和靜態變量
* 任務變量
--------------------------------------------------
在實時系統的設計中，經常會出現多個任務調用同一個函數的情況。如果這個函數不幸被設計成為不可重入的函數的話，那么不同任務調用這個函數時可能修改其他任務調用這個函數的數據，從而導致不可預料的后果。那么什么是可重入函數呢？所謂可重入函數是指一個可以被多個任務調用的過程，任務在調用時不必擔心數據是否會出錯。不可重入函數在實時系統設計中被視為不安全函數。滿足下列條件的函數多數是不可重入的：
1) 函數體內使用了靜態的數據結構；
2) 函數體內調用了malloc()或者free()函數；
3) 函數體內調用了標準I/O函數。
下面舉例加以說明。
A. 可重入函數
void strcpy(char *lpszDest, char *lpszSrc)
{
while(*lpszDest++=*lpszSrc++);
*dest=0;
}
B. 不可重入函數1
charcTemp;//全局變量
void SwapChar1(char *lpcX, char *lpcY)
{
cTemp=*lpcX;
*lpcX=*lpcY;
lpcY=cTemp;//訪問了全局變量
}
C. 不可重入函數2
void SwapChar2(char *lpcX,char *lpcY)
{
static char cTemp;//靜態局部變量
cTemp=*lpcX;
*lpcX=*lpcY;
lpcY=cTemp;//使用了靜態局部變量
}
問題1，如何編寫可重入的函數？
答：在函數體內不訪問那些全局變量，不使用靜態局部變量，堅持只使用局部變量，寫出的函數就將是可重入的。如果必須訪問全局變量，記住利用互斥信號量來保護全局變量。
問題2，如何將一個不可重入的函數改寫成可重入的函數？
答：把一個不可重入函數變成可重入的唯一方法是用可重入規則來重寫它。其實很簡單，只要遵守了幾條很容易理解的規則，那么寫出來的函數就是可重入的。
1) 不要使用全局變量。因為別的代碼很可能覆蓋這些變量值。
2) 在和硬件發生交互的時候，切記執行類似disinterrupt()之類的操作，就是關閉硬件中斷。完成交互記得打開中斷，在有些系列上，這叫做“進入/退出核心”。
3) 不能調用其它任何不可重入的函數。
4) 謹慎使用堆棧。最好先在使用前先OS_ENTER_KERNAL。
堆棧操作涉及內存分配，稍不留神就會造成益出導致覆蓋其他任務的數據，所以，請謹慎使用堆棧！最好別用！很多黑客程序就利用了這一點以便系統執行非法代碼從而輕松獲得系統控制權。還有一些規則，總之，時刻記住一句話：保證中斷是安全的！
實例問題：曾經設計過如下一個函數，在代碼檢視的時候被提醒有bug，因為這個函數是不可重入的，為什么？
unsigned int sum_int( unsigned int base )
{
unsigned int index;
static unsigned int sum = 0; // 注意，是static類型
for (index = 1; index <= base; index++)
sum += index;
return sum;
}
分析：所謂的函數是可重入的（也可以說是可預測的），即只要輸入數據相同就應產生相同的輸出。這個函數之所以是不可預測的，就是因為函數中使用了static變量，因為static變量的特征，這樣的函數被稱為：帶“內部存儲器”功能的的函數。因此如果需要一個可重入的函數，一定要避免函數中使用static變量，這種函數中的static變量，使用原則是，能不用盡量不用。
將上面的函數修改為可重入的函數，只要將聲明sum變量中的static關鍵字去掉，變量sum即變為一個auto類型的變量，函數即變為一個可重入的函數。
當然，有些時候，在函數中是必須要使用static變量的，比如當某函數的返回值為指針類型時，則必須是static的局部變量的地址作為返回值，若為auto類型，則返回為錯指針。
posted @
2007-08-03 12:56 frank.sunny 閱讀(5768) |
評論 (3) |
編輯 收藏MSP430的時鐘問題
MSP430的時鐘周期（振蕩周期）、機器周期、指令周期之間的關系
通用知識
時鐘周期也稱為振蕩周期：定義為時鐘脈沖的倒數（時鐘周期就是直接供內部CPU使用的晶振的倒數，例如12M的晶振，它的時鐘周期就是1/12us），是計算機中的最基本的、最小的時間單位。在一個時鐘周期內，CPU僅完成一個最基本的動作。時鐘脈沖是計算機的基本工作脈沖，控制著計算機的工作節奏。時鐘頻率越高，工作速度就越快。
機器周期：在計算機中，常把一條指令的執行過程劃分為若干個階段，每一個階段完成一項工作。每一項工作稱為一個基本操作，完成一個基本操作所需要的時間稱為機器周期。8051系列單片機的一個機器周期由6個S周期（狀態周期）組成。一個S周期=2個時鐘周期，所以8051單片機的一個機器周期=6個狀態周期=12個時鐘周期。
指令周期：執行一條指令所需要的時間，一般由若干個機器周期組成。指令不同，所需的機器周期也不同。
專用知識：
在430中，一個時鐘周期 ＝ MCLK晶振的倒數。如果MCLK是8M，則一個時鐘周期為1/8us；
一個機器周期 ＝ 一個時鐘周期，即430每個動作都能完成一個基本操作；
一個指令周期 ＝ 1～6個機器周期，具體根據具體指令而定。
另：指令長度，只是一個存儲單位與時間沒有必然關系。
MSP430根據型號的不同最多可以選擇使用3個振蕩器。我們可以根據需要選擇合適的振蕩頻率,并可以在不需要時隨時關閉振蕩器,以節省功耗。這3個振蕩器分別為：
（1）DCO 數控RC振蕩器。它在芯片內部,不用時可以關閉。DCO的振蕩頻率會受周圍環境溫度和MSP430工作電壓的影響,且同一型號的芯片所產生的頻率也不相同。但DCO的調節功能可以改善它的性能,他的調節分為以下3步：a：選擇BCSCTL1.RSELx確定時鐘的標稱頻率;b：選擇DCOCTL.DCOx在標稱頻率基礎上分段粗調;c：選擇DCOCTL.MODx的值進行細調。
（2）LFXT1 接低頻振蕩器。典型為接32768HZ的時鐘振蕩器,此時振蕩器不需要接負載電容。也可以接450KHZ~8MHZ的標準晶體振蕩器,此時需要接負載電容。
（3）XT2 接450KHZ~8MHZ的標準晶體振蕩器。此時需要接負載電容,不用時可以關閉。
低頻振蕩器主要用來降低能量消耗,如使用電池供電的系統,高頻振蕩器用來對事件做出快速反應或者供CPU進行大量運算。當然高端430還有鎖頻環(FLL)及FLL+等模塊，但是初步不用考慮那么多。
MSP430的3種時鐘信號：MCLK系統主時鐘;SMCLK系統子時鐘;ACLK輔助時鐘。
（1）MCLK系統主時鐘。除了CPU運算使用此時鐘以外,外圍模塊也可以使用。MCLK可以選擇任何一個振蕩器所產生的時鐘信號并進行1、2、4、8分頻作為其信號源。
（2）SMCLK系統子時鐘。供外圍模塊使用。并在使用前可以通過各模塊的寄存器實現分頻。SMCLK可以選擇任何一個振蕩器所產生的時鐘信號并進行1、2、4、8分頻作為其信號源。
（3）ACLK輔助時鐘。供外圍模塊使用。并在使用前可以通過各模塊的寄存器實現分頻。但ACLK只能由LFXT1進行1、2、4、8分頻作為信號源。
PUC復位后,MCLK和SMCLK的信號源為DCO,DCO的振蕩頻率默認為800KHZ。ACLK的信號源為LFXT1。
MSP430內部含有晶體振蕩器失效監測電路,監測LFXT1（工作在高頻模式）和XT2輸出的時鐘信號。當時鐘信號丟失50us時,監測電路捕捉到振蕩器失效。如果MCLK信號來自LFXT1或者XT2,那么MSP430自動把MCLK的信號切換為DCO,這樣可以保證程序繼續運行。但MSP430不對工作在低頻模式的LFXT1進行監測。
為了實現具體的時鐘可以設置跟時鐘相關的寄存器，在低端430中是DCOCTL、BCSCTL1和BCSCTL2三個寄存器。而對于高端的430，則要考慮SCFI0、SCFQCTL、FLL_CTL0、FLL_CTL1和BTCTL等幾個寄存器。具體設置，參看DataSheet。
上傳上來的時候，發現圖片沒有顯示出來，不好意思
posted @
2007-06-07 22:14 frank.sunny 閱讀(4348) |
評論 (7) |
編輯 收藏
摘要:
關于變量的存儲問題
以前從事上位機程序代碼的編寫，壓根不用很具體的考慮變量的具體存放位置，只知道以下概念就行了：
1. 堆區（ heap ）：由程序員申請分配和釋放，屬動態內存分配方式，變量存放于動態存儲區，若程序員不釋放，程序結束時可能會由 OS 回收。不過這個內存分配很容易引起問題，如果申請的內存不釋放就會造成內存泄漏；如果釋放的不是所要釋放的內存，則輕者引...
閱讀全文
posted @
2007-06-01 15:00 frank.sunny 閱讀(3116) |
評論 (2) |
編輯 收藏
MSP430入門
本人學習和使用msp430一個月，偶在微控論壇看到一筆記，記載的蠻好的，現轉載到自己博客以做備忘。
硬件初步
這只是我在學習TI公司生產的16位超的功耗單片機MSP430的隨筆，希望能對其他朋友有所借鑒，不對之處還請多指教。
下面，開始430之旅。
講解430的書現在也有很多了，不過大多數都是詳細說明底層硬件結構的，看了不免有些空洞和枯燥，我認為了解一個MCU的操作首先要對其基礎特性有所了解，然后再仔細研究各模塊的功能。
1.首先你要知道msp430的存儲器結構。典型微處理器的結構有兩種：馮。諾依曼結構——程序存儲器和數據存儲器統一編碼；哈佛結構——程序存儲器和數據存儲器；msp430系列單片機屬于前者，而常用的mcs51系列屬于后者。
0－0xf特殊功能寄存器；0x10－0x1ff外圍模塊寄存器；0x200－？根據不同型號地址從低向高擴展；0x1000－0x107f seg_b0x1080_0x10ff seg_a 供flash信息存儲剩下的從0xffff開始向下擴展，根據不同容量，例如149為60KB，0xffff－0x1100
2.復位信號是MCU工作的起點，430的復位信號有兩種：上電復位信號POR和上電清除信號PUC。POR信號只在上電和RST/NMI復位管腳被設置為復位功能，且低電平時系統復位。而PUC信號是POR信號產生，以及其他如看門狗定時溢出、安全鍵值出現錯誤是產生。但是，無論那種信號觸發的復位，都會使msp430在地址0xffff處讀取復位中斷向量，然后程序從中斷向量所指的地址開始執行。復位后的狀態不寫了，詳見參考書，嘿嘿。
3.系統時鐘是一個程序運行的指揮官，時序和中斷也是整個程序的核心和中軸線。430最多有三個振蕩器，DCO內部振蕩器；LFXT1外接低頻振蕩器，常見的32768HZ，不用外接負載電容；也可接高頻450KHZ－8M，需接負載電容；XT2接高頻450KHZ－8M，加外接電容。（經驗中發現，接XT2時，需要注意自己開啟XT2，并延時50us等待XT2起振，然后手工清除IFG1中的OFIFG位，其操作順序為：打開XT2->等待XT2穩定->切換系統時鐘為XT2）
430有三種時鐘信號：MCLK系統主時鐘，可分頻1 2 4 8，供cpu使用，其他外圍模塊在有選擇情況下也可使用；SMCLK系統子時鐘，供外圍模塊使用，可選則不同振蕩器產生的時鐘信號；ACLK輔助時鐘，只能由LFXT1產生，供外圍模塊。
4.中斷是430處理器的一大特色，因為幾乎每個外圍模塊都能產生，430可以在沒有任務時進入低功耗狀態，有事件時中斷喚醒cpu，處理完畢再次進入低功耗狀態。
整個中斷的響應過程是這樣的，當有中斷請求時，如果cpu處于活動狀態，先完成當前命令；如果處于低功耗，先退出，將下一條指令的pc值壓入堆棧；如果有多個中斷請求，先響應優先級高的；執行完后，等待中斷請求標志位復位，要注意，單中斷源的中斷請求標志位自動復位，而多中斷的標志位需要軟件復位；然后系統總中斷允許位SR.GIE復位，相應的中斷向量值裝入pc，程序從這個地址繼續執行。
這里要注意，中斷允許位SR.GIE和中斷嵌套問題。如果當你執行中斷程序過程中，希望可以響應更高級別的中斷請求時，必須在進入第一個中斷時把SR.GIE置位。
其實，其他的外圍模塊時鐘沿著時鐘和中斷這個核心來執行的。具體的結構我也不羅索了，可以參考430系列手冊。
C語言編程起步
因為常用的430編程開發是c語言，所以下面講解C語言對430編程的整體結構。基本上屬于框架結構，即整體的模塊化編程，其實這也是硬件編程的基本法則拉（可不是我規定的法則哦）。
首先是程序的頭文件，包括#include <MSP430x14x.h>,這是14系列，因為常用149；其他型號可自己修改。還可以包括#include "data.h" 等數據庫頭文件，或函數變量聲明頭文件，都是你自己定義的哦。
接著就是函數和變量的聲明 void Init_Sys(void)，即系統初始化。系統初始化是個整體的概念，廣義上講包括所有外圍模塊的初始化，你可以把外圍模塊初始化的子函數寫到Init_Sys（）中，也可以分別寫各個模塊的初始化。但結構的簡潔，最好寫完系統的時鐘初始化后，其他所用到的模塊（包括一些中斷初始化）也在這里初始化。
void Init_Sys()
{
unsigned int i;
BCSCTL1&=~XT2OFF; //打開XT2振蕩器
do
{
IFG1 &= ~OFIFG; // 清除振蕩器失效標志
for (i = 0xFF; i > 0; i--); // 延時，等待XT2起振
}
while ((IFG1 & OFIFG) != 0); // 判斷XT2是否起振
BCSCTL2 =SELM_2+SELS; //選擇MCLK、SMCLK為XT2
//以下對各種模塊、中斷、外圍設備等進行初始化
........................................
_EINT(); //打開全局中斷控制
}
這里涉及到時鐘問題，通常我們選擇XT2為8M晶振，也即系統主時鐘MCLK為8M,cpu執行命令以此時鐘為準；但其他外圍模塊可以在相應的控制寄存器中選擇其他的時鐘，ACLK；當你對速度要求很低，定時時間間隔大時，就可以選擇ACLK，例如在定時器Timea初始化中設置。
主程序：
void main( void )
{
WDTCTL = WDTPW + WDTHOLD;//關閉看門狗
InitSys(); //初始化
//自己任務中的其他功能函數
。。。。。。。。。。。。。。。。。。。。。
while(1);
}
主程序之后我要講講中斷函數，中斷是你做單片機任務中不可缺少的部分，也可以說是靈魂了（夸張嗎）。
/***********************************************************************
各中斷函數，可按優先級依次書寫
***********************************************************************/
舉個定時中斷的例子：
//初始化
void Init_Timer_A(void)
{
TACTL = TASSEL0 + TACLR; // ACLK, clear TAR
CCTL0 = CCIE; // CCR0 中斷使能
CCR0=32768; //定時1s
TACTL|=MC0; //增計數模式
}
// 中斷服務
#pragma vector=TIMERA0_VECTOR
__interrupt void TimerA0()
{
// 你自己要求中斷執行的任務
}
當然，還有其他的定時，和多種中斷，各系列芯片的中斷向量個數也不同。
學完并懂得以上知識后，接下去推薦看微控論壇上的msp430常用模塊應用原理。
posted @
2007-04-18 16:04 frank.sunny 閱讀(3185) |
評論 (5) |
編輯 收藏也談關于時間
最近轉去搞低層些的單片機程序編程，在一塊msp430上要增加一個國際標準時間，由于以前在VC中都是拿來用的，沒遇到問題，也就不會去深究。在單片機上想用標準C里面的time（time_t*）函數求得系統時間，最后結果出不來。后來才知道原來以前是取得的是操作系統的時間，汗死，單片機沒系統的啊，希望能夠盡早讓我搞嵌入式啊，呵呵。
后來自己弄明白了，設個時間值，然后用單片機晶振累加計數，還是可以用time.h輕松實現標準時間計時的，而且方便不用考慮自己去寫時間轉換函數，以下是具體的time,h的講解，我就不再展開了。
time.h從頭學
本文從介紹基礎概念入手，探討了在C/C++中對日期和時間操作所用到的數據結構和函數，并對計時、時間的獲取、時間的計算和顯示格式等方面進行了闡述。本文還通過大量的實例向你展示了time.h頭文件中聲明的各種函數和數據結構的詳細使用方法。
關鍵字：UTC（世界標準時間），Calendar Time（日歷時間），epoch（時間點），clock tick（時鐘計時單元）
1． 概念
在C/C++中，對字符串的操作有很多值得注意的問題，同樣，C/C++對時間的操作也有許多值得大家注意的地方。最近，在技術群中有很多網友也多次問到過C++語言中對時間的操作、獲取和顯示等等的問題。下面，在這篇文章中，筆者將主要介紹在C/C++中時間和日期的使用方法.
通過學習許多C/C++庫，你可以有很多操作、使用時間的方法。但在這之前你需要了解一些“時間”和“日期”的概念，主要有以下幾個：
Coordinated Universal Time（UTC）：協調世界時，又稱為世界標準時間，也就是大家所熟知的格林威治標準時間（Greenwich Mean Time，GMT）。比如，中國內地的時間與UTC的時差為+8，也就是UTC+8。美國是UTC-5。
Calendar Time：日歷時間，是用“從一個標準時間點到此時的時間經過的秒數”來表示的時間。這個標準時間點對不同的編譯器來說會有所不同，但對一個編譯系統來說，這個標準時間點是不變的，該編譯系統中的時間對應的日歷時間都通過該標準時間點來衡量，所以可以說日歷時間是“相對時間”，但是無論你在哪一個時區，在同一時刻對同一個標準時間點來說，日歷時間都是一樣的。
epoch：時間點。時間點在標準C/C++中是一個整數，它用此時的時間和標準時間點相差的秒數（即日歷時間）來表示。
clock tick：時鐘計時單元（而不把它叫做時鐘滴答次數），一個時鐘計時單元的時間長短是由CPU控制的。一個clock tick不是CPU的一個時鐘周期，而是C/C++的一個基本計時單位。
我們可以使用ANSI標準庫中的time.h頭文件。這個頭文件中定義的時間和日期所使用的方法，無論是在結構定義，還是命名，都具有明顯的C語言風格。下面，我將說明在C/C++中怎樣使用日期的時間功能。
2． 計時
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.\n",clock()/CLOCKS_PER_SEC);
}
當然，你也可以用clock函數來計算你的機器運行一個循環或者處理其它事件到底花了多少時間：
#include “stdio.h”
#include “stdlib.h”
#include “time.h”
int main( void )
{
long i = 10000000L;
clock_t start, finish;
double duration;
/* 測量一個事件持續的時間*/
printf( "Time to do %ld empty loops is ", i );
start = clock();
while( i-- ) ;
finish = clock();
duration = (double)(finish - start) / CLOCKS_PER_SEC;
printf( "%f seconds\n", duration );
system("pause");
}
在筆者的機器上，運行結果如下：
Time to do 10000000 empty loops is 0.03000 seconds
上面我們看到時鐘計時單元的長度為1毫秒，那么計時的精度也為1毫秒，那么我們可不可以通過改變CLOCKS_PER_SEC的定義，通過把它定義的大一些，從而使計時精度更高呢？通過嘗試，你會發現這樣是不行的。在標準C/C++中，最小的計時單位是一毫秒。
3．與日期和時間相關的數據結構
在標準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秒到該時間點所經過的秒數。
4．與日期和時間相關的函數及應用
在本節，我將向大家展示怎樣利用time.h中聲明的函數對時間進行操作。這些操作包括取當前時間、計算時間間隔、以不同的形式顯示時間等內容。
4.1 獲得日歷時間
我們可以通過time()函數來獲得日歷時間（Calendar Time），其原型為：
time_t time(time_t * timer);
如果你已經聲明了參數timer，你可以從參數timer返回現在的日歷時間，同時也可以通過返回值返回現在的日歷時間，即從一個時間點（例如：1970年1月1日0時0分0秒）到現在此時的秒數。如果參數為空（NUL），函數將只通過返回值返回現在的日歷時間，比如下面這個例子用來顯示當前的日歷時間：
#include "time.h"
#include "stdio.h"
int main(void)
{
struct tm *ptr;
time_t lt;
lt =time(NUL);
printf("The Calendar Time now is %d\n",lt);
return 0;
}
運行的結果與當時的時間有關，我當時運行的結果是：
The Calendar Time now is 1122707619
其中1122707619就是我運行程序時的日歷時間。即從1970年1月1日0時0分0秒到此時的秒數。
4.2 獲得日期和時間
這里說的日期和時間就是我們平時所說的年、月、日、時、分、秒等信息。從第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秒。下面是個例子：
#include "time.h"
#include "stdio.h"
int main(void)
{
struct tm *local;
time_t t;
t=time(NUL);
local=localtime(&t);
printf("Local hour is: %d\n",local->tm_hour);
local=gmtime(&t);
printf("UTC hour is: %d\n",local->tm_hour);
return 0;
}
運行結果是：
Local hour is: 15
UTC hour is: 7
4.3 固定的時間格式
我們可以通過asctime()函數和ctime()函數將時間以固定的格式顯示出來，兩者的返回值都是char*型的字符串。返回的時間格式為：
星期幾 月份日期 時:分:秒 年\n\0
例如：Wed Jan 02 02:03:55 1980\n\0
其中\n是一個換行符，\0是一個空字符，表示字符串結束。下面是兩個函數的原型：
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語句輸出的結果就是不同的了（除非你將本地時區設為世界標準時間所在的時區）：
#include "time.h"
#include "stdio.h"
int main(void)
{
struct tm *ptr;
time_t lt;
lt =time(NUL);
ptr=gmtime(<);
printf(asctime(ptr));
printf(ctime(<));
return 0;
}
運行結果：
Sat Jul 30 08:43:03 2005
Sat Jul 30 16:43:03 2005
4.4 自定義時間格式
我們可以使用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小時制顯示，就象下面這段程序：
#include “time.h”
#include “stdio.h”
int main(void)
{
struct tm *ptr;
time_t lt;
char str[80];
lt=time(NUL);
ptr=localtime(<);
strftime(str,100,"It is now %I %p",ptr);
printf(str);
return 0;
}
其運行結果為：
It is now 4PM
而下面的程序則顯示當前的完整日期：
#include <stdio.h>
#include <time.h>
void main( void )
{
struct tm *newtime;
char tmpbuf[128];
time_t lt1;
time( <1 );
newtime=localtime(<1);
strftime( tmpbuf, 128, "Today is %A, day %d of %B in the year %Y.\n", newtime);
printf(tmpbuf);
}
運行結果：
Today is Saturday, day 30 of July in the year 2005.
4.5 計算持續時間的長度
有時候在實際應用中要計算一個事件持續的時間長度，比如計算打字速度。在第1節計時部分中，我已經用clock函數舉了一個例子。Clock()函數可以精確到毫秒級。同時，我們也可以使用difftime()函數，但它只能精確到秒。該函數的定義如下：
double difftime(time_t time1, time_t time0);
雖然該函數返回的以秒計算的時間間隔是double類型的，但這并不說明該時間具有同double一樣的精確度，這是由它的參數覺得的（time_t是以秒為單位計算的）。比如下面一段程序：
#include "time.h"
#include "stdio.h"
#include "stdlib.h"
int main(void)
{
time_t start,end;
start = time(NUL);
system("pause");
end = time(NUL);
printf("The pause used %f seconds.\n",difftime(end,start));//<-
system("pause");
return 0;
}
運行結果為：
請按任意鍵繼續. . .
The pause used 2.000000 seconds.
請按任意鍵繼續. . .
可以想像，暫停的時間并不那么巧是整整2秒鐘。其實，你將上面程序的帶有“//<-”注釋的一行用下面的一行代碼替換：
printf("The pause used %f seconds.\n",end-start);
其運行結果是一樣的。
4.6 分解時間轉化為日歷時間
這里說的分解時間就是以年、月、日、時、分、秒等分量保存的時間結構，在C/C++中是tm結構。我們可以使用mktime（）函數將用tm結構表示的時間轉化為日歷時間。其函數原型如下：
time_t mktime(struct tm * timeptr);
其返回值就是轉化后的日歷時間。這樣我們就可以先制定一個分解時間，然后對這個時間進行操作了，下面的例子可以計算出1997年7月1日是星期幾：
#include "time.h"
#include "stdio.h"
#include "stdlib.h"
int main(void)
{
struct tm t;
time_t t_of_day;
t.tm_year=1997-1900;
t.tm_mon=6;
t.tm_mday=1;
t.tm_hour=0;
t.tm_min=0;
t.tm_sec=1;
t.tm_isdst=0;
t_of_day=mktime(&t);
printf(ctime(&t_of_day));
return 0;
}
運行結果：
Tue Jul 01 00:00:01 1997
現在注意了，有了mktime()函數，是不是我們可以操作現在之前的任何時間呢？你可以通過這種辦法算出1945年8月15號是星期幾嗎？答案是否定的。因為這個時間在1970年1月1日之前，所以在大多數編譯器中，這樣的程序雖然可以編譯通過，但運行時會異常終止。
posted @
2007-04-05 23:53 frank.sunny 閱讀(990) |
評論 (0) |
編輯 收藏由switch選擇結構理解局部變量
函數體內部自定義變量，稱為局部變量，存儲于棧（stack）中，由編譯器自動分配和釋放，局部變量的生存期（或者說作用域）是當前函數內部，使用時必須初始化，否則其值將不定。以前對局部變量的定義也就是這么多，而且也就那么在用。近期碰到如下一個問題：
void func( void )
{
int x = 2;
switch ( x )
{
int m =0; //initialization skipped by case0,case1,case2,default
case 0 :
int i = 0; //initialization skipped by case1,case2,default
{ int j = 1; } // OK, initialized in enclosing block
break;
case 1 :
break;
case 2:
break;
default:
int k = 1; // OK, initialization not skipped
}
}
遇到這個問題，網上的解答很多，很多人覺得switch內不能定義局部變量，這個明顯是不對的。因為我把代碼改成以下形式后就完全可以用了。
void func( void )
{
int x = 2;
switch ( x )
{
int m;
m = 0; //without execute;
case 0:
int i;
i = 0;
{ int j = 1; } // OK, initialized in enclosing block
printf("%d %d\n", m, i);
break;
case 1:
i = 1;
printf("%d %d\n", m, i);
break;
case 2:
i = 2;
printf("%d %d\n", m, i);
break;
default:
int k = 1; // OK, initialization not skipped
}
}
編譯時有一個warning，即“local variable 'm' used without having been initialized”，執行結果為：-858993460 2
因此switch內不但可以定義變量，而且也不用像很多人所說的在case內遇到要用變量時一定要用{}括起來，不過嚴格的說不用{}擴起來的變量是是屬于整個switch塊結構的，為此編程一定要將新增變量作用域限定在case內就必須要用{}。
通過switch···case結構，對局部變量的聲明、定義以及初始化等概念可以有一個比較清晰的認識。我的理解就是：聲明語句不管是放在哪里，其編譯時都是將其置頂到塊的頭部，如int k雖然在default中，但是這個變量的聲明就在switch的{}內，其生存期與變量m等同，只是由于前面沒有聲明，所以default之前不能用。
posted @
2007-04-05 23:25 frank.sunny 閱讀(1472) |
評論 (0) |
編輯 收藏
?
關于內存映射文件處理
今天看到一篇文章講內存映射文件的處理，雖然自己沒有處理過如此大的文件系統，但是好奇就也看了下，誰知道自己以后會不會用到或考到這方面的知識。所以就給自己
mark
一下，增加點自己的印象。
首先，通過
CreateFile()
函數來創建或打開一個文件內核對象，這個對象標識了磁盤上將要用作內存映射文件的文件。（其實是獲取文件句柄）
其次，通過
CreateFileMapping()
函數來為剛才創建的文件內核對象創建一個文件映射內核對象并告訴系統文件的尺寸以及訪問文件的方式。（獲取文件映射內核對象的句柄）
再次，通過
MapViewOfFile()
函數將文件內核映射對象添加到進程中。（獲取映射內核對象的指針）
接著，程序就可以通過指針進行常規的文件讀取了，這里的操作就和文件操作一樣，不做展開。
用完之后，還得回收，先用
UnmapViewOfFile()
將釋放映射內核對象指針，然后通過
CloseHandle
關閉之前創建的文件映射內核對象句柄和文件內核對象句柄。
?
以下是我找到的文章的出處：
http://newcactus.bokee.com/viewdiary.15316244.html
下面純粹是粘貼別人的作品：
VC++
中使用內存映射文件處理大文件
摘要：
本文給出了一種方便實用的解決大文件的讀取、存儲等處理的方法，并結合相關程序代碼對具體的實現過程進行了介紹。
引言
文件操作是應用程序最為基本的功能之一，Win32 API和MFC均提供有支持文件處理的函數和類，常用的有Win32 API的CreateFile()、WriteFile()、ReadFile()和MFC提供的CFile類等。一般來說，以上這些函數可以滿足大多數場合的要求，但是對于某些特殊應用領域所需要的動輒幾十GB、幾百GB、乃至幾TB的海量存儲，再以通常的文件處理方法進行處理顯然是行不通的。目前，對于上述這種大文件的操作一般是以內存映射文件的方式來加以處理的，本文下面將針對這種Windows核心編程技術展開討論。
內存映射文件
內存映射文件與虛擬內存有些類似，通過內存映射文件可以保留一個地址空間的區域，同時將物理存儲器提交給此區域，只是內存文件映射的物理存儲器來自一個已經存在于磁盤上的文件，而非系統的頁文件，而且在對該文件進行操作之前必須首先對文件進行映射，就如同將整個文件從磁盤加載到內存。由此可以看出，使用內存映射文件處理存儲于磁盤上的文件時，將不必再對文件執行I/O操作，這意味著在對文件進行處理時將不必再為文件申請并分配緩存，所有的文件緩存操作均由系統直接管理，由于取消了將文件數據加載到內存、數據從內存到文件的回寫以及釋放內存塊等步驟，使得內存映射文件在處理大數據量的文件時能起到相當重要的作用。另外，實際工程中的系統往往需要在多個進程之間共享數據，如果數據量小，處理方法是靈活多變的，如果共享數據容量巨大，那么就需要借助于內存映射文件來進行。實際上，內存映射文件正是解決本地多個進程間數據共享的最有效方法。
內存映射文件并不是簡單的文件I/O操作，實際用到了Windows的核心編程技術--內存管理。所以，如果想對內存映射文件有更深刻的認識，必須對Windows操作系統的內存管理機制有清楚的認識，內存管理的相關知識非常復雜，超出了本文的討論范疇，在此就不再贅述，感興趣的讀者可以參閱其他相關書籍。下面給出使用內存映射文件的一般方法：
首先要通過CreateFile()函數來創建或打開一個文件內核對象，這個對象標識了磁盤上將要用作內存映射文件的文件。在用CreateFile()將文件映像在物理存儲器的位置通告給操作系統后，只指定了映像文件的路徑，映像的長度還沒有指定。為了指定文件映射對象需要多大的物理存儲空間還需要通過CreateFileMapping()函數來創建一個文件映射內核對象以告訴系統文件的尺寸以及訪問文件的方式。在創建了文件映射對象后，還必須為文件數據保留一個地址空間區域，并把文件數據作為映射到該區域的物理存儲器進行提交。由MapViewOfFile()函數負責通過系統的管理而將文件映射對象的全部或部分映射到進程地址空間。此時，對內存映射文件的使用和處理同通常加載到內存中的文件數據的處理方式基本一樣，在完成了對內存映射文件的使用時，還要通過一系列的操作完成對其的清除和使用過資源的釋放。這部分相對比較簡單，可以通過UnmapViewOfFile()完成從進程的地址空間撤消文件數據的映像、通過CloseHandle()關閉前面創建的文件映射對象和文件對象。
內存映射文件相關函數
在使用內存映射文件時，所使用的API函數主要就是前面提到過的那幾個函數，下面分別對其進行介紹：
|
HANDLE CreateFile(LPCTSTR lpFileName,
DWORD dwDesiredAccess,
DWORD dwShareMode,
LPSECURITY_ATTRIBUTES lpSecurityAttributes,
DWORD dwCreationDisposition,
DWORD dwFlagsAndAttributes,
HANDLE hTemplateFile);
|
函數CreateFile()即使是在普通的文件操作時也經常用來創建、打開文件，在處理內存映射文件時，該函數來創建/打開一個文件內核對象，并將其句柄返回，在調用該函數時需要根據是否需要數據讀寫和文件的共享方式來設置參數dwDesiredAccess和dwShareMode，錯誤的參數設置將會導致相應操作時的失敗。
|
HANDLE CreateFileMapping(HANDLE hFile,
LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
DWORD flProtect,
DWORD dwMaximumSizeHigh,
DWORD dwMaximumSizeLow,
LPCTSTR lpName);
|
CreateFileMapping()函數創建一個文件映射內核對象，通過參數hFile指定待映射到進程地址空間的文件句柄（該句柄由CreateFile()函數的返回值獲取）。由于內存映射文件的物理存儲器實際是存儲于磁盤上的一個文件，而不是從系統的頁文件中分配的內存，所以系統不會主動為其保留地址空間區域，也不會自動將文件的存儲空間映射到該區域，為了讓系統能夠確定對頁面采取何種保護屬性，需要通過參數flProtect來設定，保護屬性PAGE_READONLY、PAGE_READWRITE和PAGE_WRITECOPY分別表示文件映射對象被映射后，可以讀取、讀寫文件數據。在使用PAGE_READONLY時，必須確保CreateFile()采用的是GENERIC_READ參數；PAGE_READWRITE則要求CreateFile()采用的是GENERIC_READ|GENERIC_WRITE參數；至于屬性PAGE_WRITECOPY則只需要確保CreateFile()采用了GENERIC_READ和GENERIC_WRITE其中之一即可。DWORD型的參數dwMaximumSizeHigh和dwMaximumSizeLow也是相當重要的，指定了文件的最大字節數，由于這兩個參數共64位，因此所支持的最大文件長度為16EB，幾乎可以滿足任何大數據量文件處理場合的要求。
|
LPVOID MapViewOfFile(HANDLE hFileMappingObject,
DWORD dwDesiredAccess,
DWORD dwFileOffsetHigh,
DWORD dwFileOffsetLow,
DWORD dwNumberOfBytesToMap);
|
MapViewOfFile()函數負責把文件數據映射到進程的地址空間，參數hFileMappingObject為CreateFileMapping()返回的文件映像對象句柄。參數dwDesiredAccess則再次指定了對文件數據的訪問方式，而且同樣要與CreateFileMapping()函數所設置的保護屬性相匹配。雖然這里一再對保護屬性進行重復設置看似多余，但卻可以使應用程序能更多的對數據的保護屬性實行有效控制。MapViewOfFile()函數允許全部或部分映射文件，在映射時，需要指定數據文件的偏移地址以及待映射的長度。其中，文件的偏移地址由DWORD型的參數dwFileOffsetHigh和dwFileOffsetLow組成的64位值來指定，而且必須是操作系統的分配粒度的整數倍，對于Windows操作系統，分配粒度固定為64KB。當然，也可以通過如下代碼來動態獲取當前操作系統的分配粒度：
|
SYSTEM_INFO sinf;
GetSystemInfo(&sinf);
DWORD dwAllocationGranularity = sinf.dwAllocationGranularity;
|
參數dwNumberOfBytesToMap指定了數據文件的映射長度，這里需要特別指出的是，對于Windows 9x操作系統，如果MapViewOfFile()無法找到足夠大的區域來存放整個文件映射對象，將返回空值（NULL）；但是在Windows 2000下，MapViewOfFile()只需要為必要的視圖找到足夠大的一個區域即可，而無須考慮整個文件映射對象的大小。
在完成對映射到進程地址空間區域的文件處理后，需要通過函數UnmapViewOfFile()完成對文件數據映像的釋放，該函數原型聲明如下：
|
BOOL UnmapViewOfFile(LPCVOID lpBaseAddress);
|
唯一的參數lpBaseAddress指定了返回區域的基地址，必須將其設定為MapViewOfFile()的返回值。在使用了函數MapViewOfFile()之后，必須要有對應的UnmapViewOfFile()調用，否則在進程終止之前，保留的區域將無法釋放。除此之外，前面還曾由CreateFile()和CreateFileMapping()函數創建過文件內核對象和文件映射內核對象，在進程終止之前有必要通過CloseHandle()將其釋放，否則將會出現資源泄漏的問題。
除了前面這些必須的API函數之外，在使用內存映射文件時還要根據情況來選用其他一些輔助函數。例如，在使用內存映射文件時，為了提高速度，系統將文件的數據頁面進行高速緩存，而且在處理文件映射視圖時不立即更新文件的磁盤映像。為解決這個問題可以考慮使用FlushViewOfFile()函數，該函數強制系統將修改過的數據部分或全部重新寫入磁盤映像，從而可以確保所有的數據更新能及時保存到磁盤。
使用內存映射文件處理大文件應用示例
下面結合一個具體的實例來進一步講述內存映射文件的使用方法。該實例從端口接收數據，并實時將其存放于磁盤，由于數據量大（幾十GB），在此選用內存映射文件進行處理。下面給出的是位于工作線程MainProc中的部分主要代碼，該線程自程序運行時啟動，當端口有數據到達時將會發出事件hEvent[0]，WaitForMultipleObjects()函數等待到該事件發生后將接收到的數據保存到磁盤，如果終止接收將發出事件hEvent[1]，事件處理過程將負責完成資源的釋放和文件的關閉等工作。下面給出此線程處理函數的具體實現過程：
|
……
//
創建文件內核對象，其句柄保存于hFile
HANDLE hFile = CreateFile("Recv1.zip",
GENERIC_WRITE | GENERIC_READ,
FILE_SHARE_READ,
NULL,
CREATE_ALWAYS,
FILE_FLAG_SEQUENTIAL_SCAN,
NULL);
// 創建文件映射內核對象，句柄保存于hFileMapping
HANDLE hFileMapping = CreateFileMapping(hFile,NULL,PAGE_READWRITE,
0, 0x4000000, NULL);
// 釋放文件內核對象
CloseHandle(hFile);
// 設定大小、偏移量等參數
__int64 qwFileSize = 0x4000000;
__int64 qwFileOffset = 0;
__int64 T = 600 * sinf.dwAllocationGranularity;
DWORD dwBytesInBlock = 1000 * sinf.dwAllocationGranularity;
// 將文件數據映射到進程的地址空間
PBYTE pbFile = (PBYTE)MapViewOfFile(hFileMapping,
FILE_MAP_ALL_ACCESS,
(DWORD)(qwFileOffset>>32), (DWORD)(qwFileOffset&0xFFFFFFFF), dwBytesInBlock);
while(bLoop)
{
// 捕獲事件hEvent[0]和事件hEvent[1]
DWORD ret = WaitForMultipleObjects(2, hEvent, FALSE, INFINITE);
ret -= WAIT_OBJECT_0;
switch (ret)
{
// 接收數據事件觸發
case 0:
// 從端口接收數據并保存到內存映射文件
nReadLen=syio_Read(port[1], pbFile + qwFileOffset, QueueLen);
qwFileOffset += nReadLen;
// 當數據寫滿60%時，為防數據溢出，需要在其后開辟一新的映射視圖
if (qwFileOffset > T)
{
T = qwFileOffset + 600 * sinf.dwAllocationGranularity;
UnmapViewOfFile(pbFile);
pbFile = (PBYTE)MapViewOfFile(hFileMapping,
FILE_MAP_ALL_ACCESS,
(DWORD)(qwFileOffset>>32), (DWORD)(qwFileOffset&0xFFFFFFFF), dwBytesInBlock);
}
break;
// 終止事件觸發
case 1:
bLoop = FALSE;
// 從進程的地址空間撤消文件數據映像
UnmapViewOfFile(pbFile);
// 關閉文件映射對象
CloseHandle(hFileMapping);
break;
}
}
…
|
在終止事件觸發處理過程中如果只簡單的執行UnmapViewOfFile()和CloseHandle()函數將無法正確標識文件的實際大小，即如果開辟的內存映射文件為30GB，而接收的數據只有14GB，那么上述程序執行完后，保存的文件長度仍是30GB。也就是說，在處理完成后還要再次通過內存映射文件的形式將文件恢復到實際大小，下面是實現此要求的主要代碼：
|
//
創建另外一個文件內核對象
hFile2 = CreateFile("Recv.zip",
GENERIC_WRITE | GENERIC_READ,
FILE_SHARE_READ,
NULL,
CREATE_ALWAYS,
FILE_FLAG_SEQUENTIAL_SCAN,
NULL);
// 以實際數據長度創建另外一個文件映射內核對象
hFileMapping2 = CreateFileMapping(hFile2,
NULL,
PAGE_READWRITE,
0,
(DWORD)(qwFileOffset&0xFFFFFFFF),
NULL);
// 關閉文件內核對象
CloseHandle(hFile2);
// 將文件數據映射到進程的地址空間
pbFile2 = (PBYTE)MapViewOfFile(hFileMapping2,
FILE_MAP_ALL_ACCESS,
0, 0, qwFileOffset);
// 將數據從原來的內存映射文件復制到此內存映射文件
memcpy(pbFile2, pbFile, qwFileOffset);
file://從進程的地址空間撤消文件數據映像
UnmapViewOfFile(pbFile);
UnmapViewOfFile(pbFile2);
// 關閉文件映射對象
CloseHandle(hFileMapping);
CloseHandle(hFileMapping2);
// 刪除臨時文件
DeleteFile("Recv1.zip");
|
結論
經實際測試，內存映射文件在處理大數據量文件時表現出了良好的性能，比通常使用CFile類和ReadFile()和WriteFile()等函數的文件處理方式具有明顯的優勢。本文所述代碼在Windows 98下由Microsoft Visual C++ 6.0編譯通過。
?
posted @
2007-03-30 21:16 frank.sunny 閱讀(4651) |
評論 (0) |
編輯 收藏
摘要: 聞道有先后，術業有專功
?
對于網絡，我似乎是后知后覺的多些。特別是畢業以后的一年半多的工作生涯中，完全沒有好好的接觸過網絡這個資源。一開題就跑題了，言歸正傳，本科畢業后一段時間才知道有林銳這么一個人，還拜讀了他寫的《大學十年》，當時感想頗多，但是沒有記下來，所以現在想來好像也沒有其它太大的感想，現在記得當時可能想做的...
閱讀全文
posted @
2007-03-30 20:40 frank.sunny 閱讀(2288) |
評論 (4) |
編輯 收藏網訊筆試歸來
昨天去網訊（杭州）筆試了，做了下筆試題，感覺題目都不難，但是自己做的的確不怎么樣，估計是沒機會去了，不過暫時還是先把幾道自己還記得的題目，寫出來，總結下，以做復習。
1、 要求自己實現 String 類，給出了 String 類的以下頭文件類聲明
class String
{
public:
String(const char *m_char = NULL);
String(const String & Str);
String& operator = (const String &Str);
~String();
private:
char * m_Data;
};
關于 String 類的筆試題，以前看林銳的隨筆時聽說他在微軟面試時曾碰到那么一道題目，我自己也沒有真的下筆去做過，平常都是拿來就用的，這次自己碰到，才知道會死得那么慘，反正編得不堪入目（我就不拿出來獻丑了），下面是我回來后，自己重新寫的答案。
String::String(const char* m_char)
{
int m_nLength = strlen(m_char) + 1;
if (m_Data != NULL)
{
delete [] m_Data;
m_Data = NULL;
}// 以上判斷是否必要 ??
m_Data = new char[m_nLength];
memcpy(m_Data, m_char, m_nLength);
}
String::String(const String &Str)
{
int m_nLength = strlen(Str.m_Data) + 1;// 以前真的不知道，原來對象的私有變量
// 在類的實現代碼中也是可以訪問的
if (m_Data != NULL)
{
delete [] m_Data;
m_Data = NULL;
}// 以上判斷是否必要 ??
m_Data = new char[m_nLength];
memcpy(m_Data, Str.m_Data, m_nLength);
}
String& String::operator = (const String& Str)
{
if(this == &Str)
return *this;
int m_nLength = strlen(Str.m_Data) + 1;
if (m_Data != NULL)
{
delete [] m_Data;
m_Data = NULL;
}// 以上判斷是否必要 ??
m_Data = new char[m_nLength];
memcpy(m_Data, Str.m_Data, m_nLength);
return *this;
}
String::~String()
{
if (m_Data != NULL)
{
delete [] m_Data;
m_Data = NULL;
}
}
2、 關于內存分配
這個題目很簡單，就給了一個函數，然后問函數內的局部變量存放在哪里，我也不知道為什么當時會選擇 heap( 堆 ) ，下面再把幾個概念羅列出來：
1. 堆區（ heap ）：由程序員申請分配和釋放，屬動態內存分配方式，若程序員不釋放，程序結束時可能會由 OS 回收。不過這個內存分配很容易引起問題，如果申請的內存不釋放就會造成內存泄漏；如果釋放的不是所要釋放的內存，則輕者引起程序運行結果出錯，重者系統崩潰。
2. 棧區（ stack ）：編譯器自動分配釋放，存放函數的形參值、局部變量的值，也是屬于動態內存分配方式，它由系統分配，所以執行效率也高，不過自由度小，聲明時就得決定其具體大小。
3. 全局區（靜態區）（ static ）：全局變量和靜態變量的存儲是放在一塊的，而且初始化的全局變量和靜態變量在一塊區域，未初始化的全局變量和未初始化的靜態變量在相鄰的另一塊區域。程序結束后由系統釋放，所以也不會造成內存問題。
除了以上的變量外，還有兩類存放位置，文字常量區和程序代碼區，兩者都是由系統分配和釋放，且文字常量區和前面三區合成為程序數據區，與程序代碼區相對應。
3、 關于類繼承的構造和析構函數
class Base
{
public:
Base(){cout<< "Base" <<endl;};
~Base(){cout<<"~Base"<<endl;};
protected:
private:
};
class First:public Base
{
public:
First(){cout << "First" << endl;};
~First(){cout << "~First" <<endl;};
};
int main()
{
Base *a = new First;
delete a;
}
問程序的輸出會是什么？
結果很簡單，也就是 Base
First
~Base
其它還有一個關于 & 的題目，把我搞的云里霧里的，還要再看些東西才知道怎么來解釋。
posted @
2007-03-04 21:53 frank.sunny 閱讀(3384) |
評論 (10) |
編輯 收藏
摘要: 雖然自己用多線程編程用過一陣子，但是未曾仔細了解過概念，用的也是亂亂的，今天看到一篇線程總結的文章，感覺講的很好，Windows下的多線程也就是了解了線程的概念然后加一同步代碼就行了。
Windows平臺下的多線程編程
?
...
閱讀全文
posted @
2007-01-26 22:10 frank.sunny 閱讀(2542) |
評論 (0) |
編輯 收藏