可重入函数与不可重入函数

 

主要用于多任务环境中，一个可重入的函数简单来说就是可以被中断的函数，也就是说，可以在这个函数执行的任何时刻中断它，转入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类型，则返回为错指针。

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。

 

 

 

上传上来的时候，发现图片没有显示出来，不好意思      摘要:   关于变量的存储问题   以前从事上位机程序代码的编写，压根不用很具体的考虑变量的具体存放位置，只知道以下概念就行了： 1. 堆区（ heap ）：由程序员申请分配和释放，属动态内存分配方式，变量存放于动态存储区，若程序员不释放，程序结束时可能会由 OS 回收。不过这个内存分配很容易引起问题，如果申请的内存不释放就会造成内存泄漏；如果释放的不是所要释放的内存，则轻者引...  阅读全文

 

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常用模块应用原理。

也谈关于时间

最近转去搞低层些的单片机程序编程，在一块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日之前，所以在大多数编译器中，这样的程序虽然可以编译通过，但运行时会异常终止。

 

由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 阅读(1441) | 评论 (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 阅读(4601) | 评论 (0) | 编辑 收藏

闻道有先后，术业有专功

     摘要: 闻道有先后，术业有专功   对于网络，我似乎是后知后觉的多些。特别是毕业以后的一年半多的工作生涯中，完全没有好好的接触过网络这个资源。一开题就跑题了，言归正传，本科毕业后一段时间才知道有林锐这么一个人，还拜读了他写的《大学十年》，当时感想颇多，但是没有记下来，所以现在想来好像也没有其它太大的感想，现在记得当时可能想做的...  阅读全文

posted @ 2007-03-30 20:40 frank.sunny 阅读(2241) | 评论 (4) | 编辑 收藏

自己实现String类（网讯笔试归来）

网讯笔试归来

昨天去网讯（杭州）笔试了，做了下笔试题，感觉题目都不难，但是自己做的的确不怎么样，估计是没机会去了，不过暂时还是先把几道自己还记得的题目，写出来，总结下，以做复习。

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 阅读(3356) | 评论 (10) | 编辑 收藏

[转载]Windows平台下的多线程编程

     摘要: 虽然自己用多线程编程用过一阵子，但是未曾仔细了解过概念，用的也是乱乱的，今天看到一篇线程总结的文章，感觉讲的很好，Windows下的多线程也就是了解了线程的概念然后加一同步代码就行了。 Windows平台下的多线程编程   ...  阅读全文

posted @ 2007-01-26 22:10 frank.sunny 阅读(2513) | 评论 (0) | 编辑 收藏

仅列出标题

共7页: 1 2 3 4 5 6 7