本帖最后由 chengzepeng 于 2012-9-24 00:33 编辑

51的C语言指针分两大类：

1，通用指针，不管你用来访问程序数据区域还是内存都可以，缺点是占用3个字节，访问时间也超长。

2，特定指针，就是指定区域的指针，缺点是不可以访问该区域外的数据，好处就是访问时间短。

AT89C52的实测读取时间：内部RAM指针的读取需要5指令时间，指针读取代码需要9个指令时间，用通用指针读内部RAM要17个指令时间（可见效率低下）。

用法： 先确定你的指针用在那个区域，然后在一个变量前面加个*号，去取某个变量的地址就是在变量前加个&，数组的话可以直接用数组名。

如：

1. 
   
2. uint8_t idata *RP1；   // 指针在指定在内部RAM，data加不加i都一样，因为内部RAM是0-255，所以这个只要一个字节
   
3. uint8_t pdata *RP2；  // 指针在指定在外部RAM，这个是外部RAM的分页访问，也是用一个字节，速度和内部的差不多
   
4. uint16_t xdata *RP3；// 指针在指定在外部RAM，这个是外部整个区域的访问，占用2个字节
   
5. uint16_t code *RP4； // 指针在指定在代码区，这个是代码区的访问，只能读
   
6. uint8_t *RP5；          // 通用指针，这个是未指定区域访问，因为占用3个字节，所以访问速度超慢，不推荐使用[code]
   
7. 
   
8. 测试例子:
   
9. 
   
10. [code]#include<reg52.h>
    
11. #include <stdint.h>
    
12. #include <absacc.h>
    
13. 
    
14. sbit K0 = P1^0;
    
15. sbit K1 = P1^1;
    
16. sbit CS = P2^0;
    
17. 
    
18. uint8_t idata IRAM_BUF[128];
    
19. uint8_t idata *pdr;                                   // 指针区域定在内部RAM
    
20. uint16_t code *por;                                   // 指针区域定在代码
    
21. 
    
22. void delay_ms(uint8_t xms)
    
23. {
    
24.         uint16_t xus;
    
25.         for(;xms;--xms)
    
26.         {       
    
27.                 for(xus=124;xus;--xus);
    
28.         }
    
29. }
    
30. 
    
31. void uart_init()
    
32. {
    
33.         // SMOD = 1,波特率加倍
    
34.     PCON |= 0x80;                                        
    
35.         // SM0=0;SM1=1;SM2=0;REN0=0;TB8=0;RB8=0;TI0=0;RI0=0;
    
36.         // 串口模式1，8bit可变波特率，关闭接收  
    
37.         SCON = 0x40;
    
38.         TMOD = 0x20;
    
39.         TH1  = 0xFF;        // 11.0592M时57600
    
40.         TR1  = 1;
    
41.         TI   = 1;                                                                       
    
42. }
    
43. 
    
44. void UART(uint8_t TD)                                   // 串口发送函数
    
45. {
    
46.         while(!TI);
    
47.         TI = 0;       
    
48.         SBUF = TD;
    
49. }
    
50. 
    
51. void main()
    
52. {
    
53.         uint8_t mi,mj;
    
54.         P3 = 0xFF;
    
55.         uart_init();
    
56.         for(mi=0;mi<128;mi++)
    
57.         {
    
58.                 IRAM_BUF[mi]=mi;
    
59.         }       
    
60.         while(1)
    
61.         {
    
62.                 if((!K0)||(!K1))
    
63.                 {
    
64.                         delay_ms(100);
    
65.                         if(!K0)
    
66.                         {                                 
    
67.                                 pdr=IRAM_BUF;                        // 将数组的起始地址取出来
    
68.                                 for(mi=128;mi!=0;mi--)
    
69.                                 {
    
70.                                         CS = 0;                         // 测试IO
    
71.                                         mj = *pdr;                 // 读出数据   
    
72.                                         CS = 1;
    
73.                                         ++pdr;                        // 指针自加1       
    
74.                                         UART(mj);
    
75.                                 }
    
76.                         }
    
77.                         else if(!K1)
    
78.                         {
    
79. // 听说直接对指针赋值不合法,不过实际测试可以用也没有警告
    
80.                                 por=0;
    
81.                                 for(mi=0;mi<128;mi++)        // 从代码区读出128字节
    
82.                                 {
    
83.                                         CS = 0;
    
84.                                         mj = *por;
    
85.                                         CS = 1;
    
86.                                         ++por;
    
87.                                         UART(mj);
    
88.                                 }
    
89.                         }
    
90.                          while((!K0)||(!K1));
    
91.                 }
    
92.         }
    
93. }
    

复制代码