指针类型转换

当我们初始化一个指针或给一个指针赋值时，赋值号的左边是一个指针，赋
值号的右边是一个指针表达式。在我们前面所举的例子中，绝大多数情况下，指
针的类型和指针表达式的类型是一样的，指针所指向的类型和指针表达式所指向
的类型是一样的。
例十四：
1。 float f=12.3;
2。 float *fptr=&f;
3。 int *p;
在上面的例子中，假如我们想让指针p指向实数f，应该怎么搞？是用下面的
语句吗？
p=&f;
不对。因为指针p的类型是int*，它指向的类型是int。表达式&f的结果是一
个指针，指针的类型是float*,它指向的类型是float。两者不一致，直接赋值的
方法是不行的。至少在我的MSVC++6.0上，对指针的赋值语句要求赋值号两边的类
型一致，所指向的类型也一致，其它的编译器上我没试过，大家可以试试。为了
实现我们的目的，需要进行“强制类型转换”：
p=(int*)&f;
如果有一个指针p，我们需要把它的类型和所指向的类型改为TYEP*和TYPE，
那么语法格式是：
(TYPE*)p；
这样强制类型转换的结果是一个新指针，该新指针的类型是TYPE*，它指向的
类型是TYPE，它指向的地址就是原指针指向的地址。而原来的指针p的一切属性都
没有被修改。

一个函数如果使用了指针作为形参，那么在函数调用语句的实参和形参的结
合过程中，也会发生指针类型的转换。
例十五：
void fun(char*);
int a=125,b;
fun((char*)&a);
...
...
void fun(char*s)
{
char c;
c=*(s+3);*(s+3)=*(s+0);*(s+0)=c;
c=*(s+2);*(s+2)=*(s+1);*(s+1)=c;
}
}
注意这是一个32位程序，故int类型占了四个字节，char类型占一个字节。函
数fun的作用是把一个整数的四个字节的顺序来个颠倒。注意到了吗？在函数调用
语句中，实参&a的结果是一个指针，它的类型是int *，它指向的类型是int。形
参这个指针的类型是char*，它指向的类型是char。这样，在实参和形参的结合过
程中，我们必须进行一次从int*类型到char*类型的转换。结合这个例子，我们可
以这样来想象编译器进行转换的过程：编译器先构造一个临时指针 char*temp，
然后执行temp=(char*)&a，最后再把temp的值传递给s。所以最后的结果是：s的
类型是char*,它指向的类型是char，它指向的地址就是a的首地址。

我们已经知道，指针的值就是指针指向的地址，在32位程序中，指针的值其
实是一个32位整数。那可不可以把一个整数当作指针的值直接赋给指针呢？就象
下面的语句：
unsigned int a;
TYPE *ptr;//TYPE是int，char或结构类型等等类型。
...
...
a=20345686;
ptr=20345686;//我们的目的是要使指针ptr指向地址20345686（十进制
）
ptr=a;//我们的目的是要使指针ptr指向地址20345686（十进制）
编译一下吧。结果发现后面两条语句全是错的。那么我们的目的就不能达到
了吗？不，还有办法：
unsigned int a;
TYPE *ptr;//TYPE是int，char或结构类型等等类型。
...
...
a=某个数，这个数必须代表一个合法的地址；
ptr=(TYPE*)a；//呵呵，这就可以了。
严格说来这里的(TYPE*)和指针类型转换中的(TYPE*)还不一样。这里的(TYP
E*)的意思是把无符号整数a的值当作一个地址来看待。
上面强调了a的值必须代表一个合法的地址，否则的话，在你使用ptr的时候
，就会出现非法操作错误。

想想能不能反过来，把指针指向的地址即指针的值当作一个整数取出来。完
全可以。下面的例子演示了把一个指针的值当作一个整数取出来，然后再把这个
整数当作一个地址赋给一个指针：
例十六：
int a=123,b;
int *ptr=&a;
char *str;
b=(int)ptr;//把指针ptr的值当作一个整数取出来。
str=(char*)b;//把这个整数的值当作一个地址赋给指针str。

好了，现在我们已经知道了，可以把指针的值当作一个整数取出来，也可以
把一个整数值当作地址赋给一个指针。

其他相关资料：

#pragma src

＃i nclude <reg51.H>

f(){}
f1(){}
f2(){}

main()
{
    {
        int x;
        int *px;

        //下面这些表示虽然很烦，但是生成的代码却及其简洁：

        //将 xdata 型指针 0x4000 赋给 px
        px=(int xdata *)0x4000;

        //表示从 xdata 0x4000处取一个 char 给x
        x=*((char xdata *)0x4000);

        // 表示从 code 0x4000处取一个 word 作为 xdata 型的指针 给
px
        px=*((int xdata * xdata *)0x4000);

        //表示从 code 0x4000处取一个 word 作为 xdata 型的指针,
        //再把这个指针指向的char数据赋给x
        x=**((char xdata * code *)0x4000);

        //表示把函数f()入口地址当作xdata型指针，再把指向的xdata
        //中的int型数据作为code型指针，把指向的code字节
        //赋给x（晕,这样有意义吗？）
        x=**(int code * xdata *)f;

        //把f()入口地址处的ROM中两个code型字节,
        //赋给堆栈指针SP指向的字节(想干什么?编操作系统?)
        *(unsigned int idata *)SP=*(unsigned int code *)&f;

        //表示把f()入口地址处的ROM中两个code型字节，
        //作为一个xdata指针寻址，
        //把指向的数据作为pdata指针寻址，
        //再把把指向的数据作为idata指针寻址，
        //把该地址处的一个字节赋给x (我靠，累死了)
        x= ****(unsigned int data * idata * pdata * xdata * code
*)&f;
       
        //总之，一个括号里面外面的"*"一样多就表示指向的是数据。
    }

    {
        //数组函数
        code void (*ArrFn[])(void) =
        {    &f1,
            &f2,
        };
        //可以像引用数组一样调用函数啦：
        (*ArrFn[0])();
        (*ArrFn[1])();
    }

    {
        //这样将使函数调用0000H处：
        void (*reset) (void);
        reset=0x0;
        (*reset)();
        reset();

        //或者直接这样，仅仅生成一条指令LCALL 1234H
        ((void (code *)(void))0x1234)();
    }

    {
        //这样可以调用RETI指令：
        #define  INT_NUM  30    //空闲中断号
        ((void (code *)(void))(INT_NUM*8+3))();
        //当然需要在外面声明   int_rpt()interrupt INT_NUM {}
    }
    {
        //这样调用RETI指令太变态：
        code unsigned char ret_i=0x32;
        ((void (code *)(void))(&ret_i))();
    }
}int_rpt()interrupt INT_NUM {}

 

 

＃i nclude "stdafx.h"


int main(int argc, char* argv[])
{
int i=6465;
long j;
/* 初始化指针方法: */
/* 指针 = 指针表达式 */
int *pi;
char *pp;
pi=&i; // &i是指针表达式，实际上&i性质上已经指针,
// 可以理解为把一个指针赋予给另一个指针
pp=(char *)pi;// 把pi指针转换为char 指针 */
printf ("%c/n",*pp);
pp=*(char **)π// pi是指针,其值为i地址；&pi是指向指针的指针，其值为pi地址，属于二级指针
// int型二级指针转换为二级char **指针
// *解为:指针&pi的值是的指针pi的地址，*(&pi)即取变量&pi的值，也就是pi地址
printf ("%c/n",*pp);//由于pp的值为pi地址，所以*pp等于*pi
printf ("%c/n",*(char*)pi);
j=*(char *)π
printf ("%l/n",j);

printf ("%c/n",(char *)&j);


}