关于指针变量定义问题

quder

论坛内的大佬们，我又有一个问题了

我定义了一个变量

1. unsigned char *Pixle

复制代码

那么这个unsigned char是指Pixle=0xA5,是指这个地址的大小是unsigned char型的，还是这个地址所对应的变量是unsigned char 型的

这个和

1. uinsigned char AA[10]

复制代码

类比的话，AA内变量是unsigned char型的 但是 单独AA是个地址 我引用AA的话可不可以放到函数

1. void TFTSPI_BinRoad(unsigned char high_start, unsigned char wide_start, unsigned char high, unsigned char wide, unsigned char *Pixle)
   
2. {
   
3.         unsigned long i;
   
4.     /* 设置显示范围 */
   
5.     TFTSPI_Set_Pos(wide_start, high_start, wide_start - 1 + wide, high_start - 1 + high);
   
6. 
   
7.     unsigned long temp = high * wide;
   
8.     /* 显示图像 */
   
9.     for(i = 0; i < temp; i++)
   
10.     {
    
11.         if(Pixle[i])
    
12.         {
    
13.             /* 显示 */
    
14.             TFTSPI_Write_Word (0xffff);
    
15.         }
    
16.         else
    
17.         {
    
18.             /* 显示 */
    
19.             TFTSPI_Write_Word (0);
    
20.         }
    
21. 
    
22.     }
    
23. 
    
24. }

复制代码

最后一个变量位，还是需要(unsigned char *)强制转换一下？

如果是需要强制转换 那(unsigned char *) 这个unsigned char是指地址是这种类型的 还是指地址所对应的变量是这种类型的？

如果指的是地址，那么引用后的 Pixle[6] 是会默认为unsigned char 变量吗？

写的有点乱，刚入门没多久，在百度CSDN上也搜不到这类问题

鲜衣怒马

第一个问题，答案是后者，即指针的类型是指它所指向的对象的类型
第二个问题，可以把数组名作为参数传递给函数，实际也是这么用的

鲜衣怒马

估计大佬们看到这个问题太简单都不想回复.那我再班门弄斧一次，说的不对的地方轻喷：

所有的指针，数组名，函数名本质都是一个地址，这个地址的长度由使用的器件和编译器决定，例如51内核的一般是2字节， Cortex-M 内核是4字节
他们之间可以互换，比如：
    可以把一段程序放在数组中，将数组名赋值给一个函数指针，通过函数指针运行数组内的代码
    可以把一个变量强制转换为函数指针，通过调用函数指针跳转到到某个地址
    可以把多个变量放在数组中，将数组名赋值给一个字符指针，通过字符指针读写数组（你的这个例子）
    可以把函数名赋值给字符指针，通过字符操作打印出函数所在的具体地址
    可以把浮点类型变量的地址强制转换为字符指针，将浮点数按字节打印或存储
等等……

指针是C语言的精髓，同时也如同在刀刃上跳芭蕾一样优雅而危险！

dog

没看懂：
不管什么指针，在32位系统，它都是32位的。
指针的类型（字节宽度）由你定。

unifax001

1. int main(void)
   
2. {
   
3.     char *p1;
   
4.     short *p2;
   
5.     int *p3;
   
6.     long *p4;
   
7.     float *p5;
   
8.    
   
9.     char a[10];
   
10.     short b[10];
    
11.     int c[10];
    
12.     long d[10];
    
13.     float e[10];
    
14.    
    
15.   
    
16.     //第一步 看看类型在你机器上多大
    
17.     printf("type char lenth is %d\n\r",sizeof(char));
    
18.     printf("type short lenth is %d\n\r",sizeof(short));
    
19.     printf("type int lenth is %d\n\r",sizeof(int));
    
20.     printf("type long lenth is %d\n\r",sizeof(long));
    
21.     printf("type float lenth is %d\n\r",sizeof(float));
    
22.    
    
23.    //第二步 看看不同类型的指针大小是多少
    
24. 
    
25.     p1=&a[0];//p1=a;效果等价，但意义不同
    
26.     p2=&b[0];
    
27.     p3=&c[0];
    
28.     p4=&d[0];
    
29.     p5=&e[0];   
    
30. 
    
31.     printf("type char* lenth is %d\n\r",sizeof(p1));
    
32.     printf("type short* lenth is %d\n\r",sizeof(p2));
    
33.     printf("type int* lenth is %d\n\r",sizeof(p3));
    
34.     printf("type long* lenth is %d\n\r",sizeof(p4));
    
35.     printf("type float* lenth is %d\n\r",sizeof(p5));
    
36. 
    
37.    //第三步 看看不同类型的指针内是什么
    
38.    
    
39. 
    
40.     printf("p1 vlue is %04x\t &a[0] address is %04x\n\r",(int)p1,(int)(&a[0]));
    
41.     printf("p2 vlue is %04x\t &b[0] address is %04x\n\r",(int)p1,(int)(&b[0]));
    
42.     printf("p3 vlue is %04x\t &c[0] address is %04x\n\r",(int)p1,(int)(&c[0]));
    
43.     printf("p4 vlue is %04x\t &d[0] address is %04x\n\r",(int)p1,(int)(&d[0]));
    
44.     printf("p5 vlue is %04x\t &e[0] address is %04x\n\r",(int)p1,(int)(&e[0]));
    
45.    
    
46.    //第四步 看看不同类型的指针++后有什么变化
    
47.   
    
48.     printf("p1 vlue is %04x\t",(int)p1);
    
49.     p1++;
    
50.     printf("p1 vlue is %04x\n\r",(int)p1);
    
51.    
    
52.     printf("p2 vlue is %04x\t",(int)p2);
    
53.     p1++;
    
54.     printf("p2 vlue is %04x\n\r",(int)p2);
    
55. 
    
56.     printf("p3 vlue is %04x\t",(int)p3);
    
57.     p1++;
    
58.     printf("p3 vlue is %04x\n\r",(int)p3);
    
59.    
    
60.     printf("p4 vlue is %04x\t",(int)p4);
    
61.     p1++;
    
62.     printf("p4 vlue is %04x\n\r",(int)p4);
    
63.    
    
64.     printf("p5 vlue is %04x\t",(int)p5);
    
65.     p1++;
    
66.     printf("p5 vlue is %04x\n\r",(int)p5);
    
67.    
    
68.     //第五步 灵活混搭一下看看
    
69.    
    
70.     a[0]=10;
    
71.     a[1]=11;
    
72.     a[2]=12;
    
73.     a[3]=13;
    
74.    
    
75.     b[0]=100;
    
76.     b[1]=110;
    
77.     b[2]=120;
    
78.     b[3]=130;  
    
79. 
    
80.     p1=&a[0]; //p1 是char*类型的
    
81.    
    
82.     printf("*p1=%d\t",*p1);
    
83.     p1++;
    
84.     printf("*p1=%d\n\r",*p1);  
    
85. 
    
86.     p1=(char*)&b[0];// 理解这步和一下的结果是本程序的核心
    
87.    
    
88.     printf("*p1=%x\t",*p1);//看看打印了些什么东西  100 = 0x0064
    
89.     p1++;
    
90.     printf("*p1=%x\n\r",*p1); //看看打印了些什么东西  100 = 0x0064
    
91.    
    
92.     p2=(short*)&a[0];
    
93.    
    
94.     printf("*p2=%x\t",*p1);//看看打印了些什么东西
    
95.     p1++;
    
96.     printf("*p2=%x\n\r",*p1); //看看打印了些什么东西   
    
97.    
    
98.    
    
99. }

复制代码

上面的程序看看 然后运行运行 然后就都明白了。

quder

鲜衣怒马 发表于 2021-5-17 14:39
估计大佬们看到这个问题太简单都不想回复.那我再班门弄斧一次，说的不对的地方轻喷：

所有的指针，数组名 ...

懂了，谢谢大佬

quder

unifax001 发表于 2021-5-17 15:42
上面的程序看看 然后运行运行 然后就都明白了。

谢谢大佬，确实要自己实操一下