K.xml

函数名: kbhit 

功  能: 检查当前按下的键 

用  法: int kbhit(void); 

程序例: 

 
   
  
    #include <conio.h> 

  
    int 
  
    main
  
    (
  
    void
  
    ) 

  
    { 
   cprintf
  
    ("Press any 
  
    key 
  
    to 
  
    continue:"); 
   
  
    while 
  
    (!kbhit
  
    (
  
    )
  
    ) /* 
  
    do 
  
    nothing */ ; 
   cprintf
  
    ("\r\nA 
  
    key was 
  
    pressed...\r\n"); 
   
  
    return 
  
    0; 

  
    } 
  
  
  

  
    
 
   

函数名: keep 

功  能: 退出并继续驻留 

用  法: void keep(int status, int size); 

程序例: 

 
   
    
  /***NOTE: 
   
  
    This 
  
    is 
  
    an 
  
    interrupt 
  
    service routine.  You 
   
  
    can 
  
    NOT 
  
    compile 
  
    this 
  
    program 
  
    with Test 
   
  
    Stack Overflow 
  
    turned 
  
    on 
  
    and 
  
    get 
  
    an 
   
  
    executable 
  
    file 
  
    which 
  
    will 
  
    operate 
   correctly.  Due 
  
    to 
  
    the 
  
    nature 
  
    of 
  
    this 
   
  
    function 
  
    the 
  
    formula 
  
    used 
  
    to 
  
    compute 
   
  
    the 
  
    number 
  
    of 
  
    paragraphs 
  
    may 
  
    not 
   
  
    necessarily 
  
    work 
  
    in 
  
    all cases.  
  
    Use 
  
    with 
   care!  
  
    Terminate Stay Resident 
  
    (TSR
  
    ) 
   
  
    programs 
  
    are 
  
    complex 
  
    and 
  
    no 
  
    other 
  
    support 
   
  
    for 
  
    them 
  
    is provided.  Refer 
  
    to 
  
    the 
   MS-DOS 
  
    technical 
  
    documentation 
   
  
    for 
  
    more information.  */ 
   
    
     
      

  
    #include <dos.h> 
/* 
  
    The 
  
    clock 
  
    tick 
  
    interrupt */ 

  
    #define INTR 0x1C 
/* 
  
    Screen 
  
    attribute 
  
    (blue 
  
    on 
  
    grey
  
    ) */ 

  
    #define ATTR 0x7900 
/* 
  
    reduce 
  
    heaplength 
  
    and 
  
    stacklength 

  
    to 
  
    make 
  
    a 
  
    smaller 
  
    program 
  
    in 
  
    memory */ 

 
  
   

  
    extern 
  
    unsigned 
  
    _heaplen 
  
    = 
  
    1024; 

  
    extern 
  
    unsigned 
  
    _stklen  
  
    = 
  
    512; 

  
    void 
  
    interrupt 
  
    ( *
  
    oldhandler
  
    )
  
    (
  
    void
  
    ); 

  
    void 
  
    interrupt 
  
    handler
  
    (
  
    void
  
    ) 

  
    { 
   
  
    unsigned 
  
    int 
  
    (
  
    far *
  
    screen
  
    )[
  
    80]; 
   
  
    static 
  
    int 
  
    count; 
/* 
  
    For 
  
    a 
  
    color 
  
    screen 
  
    the 
  
    video 
  
    memory 
   
  
    is 
  
    at B800:
  
    0000.  
  
    For 
  
    a 
  
    monochrome 
   
  
    system 
  
    use B000:
  
    000 */ 
   
  
    screen 
  
    = MK_FP
  
    (0xB800,
  
    0
  
    ); 
/* 
  
    increase 
  
    the 
  
    counter 
  
    and 
  
    keep 
  
    it 
   
  
    within 
  
    0 
  
    to 
  
    9 */ 
   
  
    count++; 
   
  
    count %= 
  
    10; 
/* 
  
    put 
  
    the 
  
    number 
  
    on 
  
    the 
  
    screen */ 
   
  
    screen[
  
    0][
  
    79] = 
  
    count + '
  
    0' + ATTR; 
/* 
  
    call 
  
    the 
  
    old 
  
    interrupt 
  
    handler */ 
   
  
    oldhandler
  
    (
  
    ); 

  
    } 

 

  
    int 
  
    main
  
    (
  
    void
  
    ) 

  
    { 
/* 
  
    get 
  
    the 
  
    address 
  
    of 
  
    the 
  
    current 
  
    clock 
   
  
    tick 
  
    interrupt */ 

  
    oldhandler 
  
    = getvect
  
    (INTR
  
    ); 
/* 
  
    install 
  
    the 
  
    new 
  
    interrupt 
  
    handler */ 
setvect
  
    (INTR, 
  
    handler
  
    ); 
/* 
  
    _psp 
  
    is 
  
    the 
  
    starting 
  
    address 
  
    of 
  
    the 
   
  
    program 
  
    in 
  
    memory.  
  
    The 
  
    top 
  
    of 
  
    the 
  
    stack 
   
  
    is 
  
    the 
  
    end 
  
    of 
  
    the 
  
    program.  Using _SS 
  
    and 
   _SP 
  
    together 
  
    we 
  
    can 
  
    get 
  
    the 
  
    end 
  
    of 
  
    the 
   
  
    stack.  You 
  
    may 
  
    want 
  
    to 
  
    allow 
  
    a 
  
    bit 
  
    of 
   
  
    saftey 
  
    space 
  
    to 
  
    insure 
  
    that 
  
    enough 
  
    room 
   
  
    is 
  
    being 
  
    allocated ie: 
   
  
    (_SS + ((_SP + 
  
    safety 
  
    space
  
    )/
  
    16
  
    ) - 
  
    _psp
  
    ) 
*/ 

  
    keep
  
    (
  
    0, (_SS + (_SP/
  
    16
  
    ) - 
  
    _psp
  
    )
  
    ); 

  
    return 
  
    0; 

  
    } 
  

  
    
 
   

本文使用 书画小说软件 发布，内容与软件无关，书画小说软件 更惬意的读、更舒心的写、更轻松的发布。