问个问题，顺便散散分。。

[pw_Start]

今天看到一个帖子
http://topic.csdn.net/u/20100114/11/48264168-cd89-4562-b6d0-f9faa3ecf07e.html
楼主已结贴，但我又发现另外一个问题，在这儿重新问一下，顺便散散分
我写了输出double类型变量c的二进制位的程序，如下

#include "stdafx.h"
#include <iostream>

using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
    
    double c = 3.5;
    int d[2];

    memcpy( d, &c, 64 );

    for( int i = 1; i >= 0; i-- )
    {
        for( int j = 31; j >= 0; j-- )
        {
            if( d[i]>>j & 0x01 )
                cout<<"1";
            else
                cout<<"0";
            if( j % 8 == 0 )
                cout<<"  ";
        }
        cout<<endl;
    }

    return 0;
}

我的疑问是：
执行memcpy( d, &c, 64 );之后，应该是d[0]中存放的c的低32位，d[1]中存的高32位，
但实事上怎么正好和我的理解相反，是d[1]中存放的c的低32位，d[0]中存的高32位
请高手解释一下
想多给点儿分，但我只能发最多100的贴了，还望大家见谅

[traceless]

    double c = 3.5;
    unsigned int d[2];   //改成这个无符号的比较好

    memcpy( d, &c, 8);
   
    printf("d[0]:%#x d[1]:%#x\n", d[0], d[1]);//你加这个打印出来

我倒~~~ 运行了没有 ==！！

[pw_Start]

你没理解我的问题
你这样打印来，二进制不也是
d[0]中是00000000 00000000 00000000 00000000
d[1]中是01000000 00001100 00000000 00000000
我理解应该是
d[0]中是01000000 00001100 00000000 00000000
d[1]中是00000000 00000000 00000000 00000000
就是d[0]和d[1]交换一下才对，问为什么？

[Quote=引用 22 楼 traceless 的回复:]
C/C++ codedouble c=3.5;
unsignedint d[2];//改成这个无符号的比较好
memcpy( d,&c,8);

printf("d[0]:%#x d[1]:%#x\n", d[0], d[1]);//你加这个打印出来

我倒~~~  运行了没有  ==！！
[/Quote]

[traceless]

我知道了你的疑问了，你等等

解惑马上来。。。正在写

我就不信，一个概念搞这么复杂。。。。

[aaaa3105563]

up

[traceless]

printf("%p:%#x\n",&c, *(unsigned short*)&c);
	printf("%p:%#x\n",(unsigned short*)&c+1, *((unsigned short*)&c+1));
    printf("%p:%#x\n",(unsigned short*)&c+2, *((unsigned short*)&c+2));
	printf("%p:%#x\n",(unsigned short*)&c+3, *((unsigned short*)&c+3));

运行结果如下：

0012FF5C:0
0012FF5E:0
0012FF60:0
0012FF62:0x400c
也就是说低地址：d[0]中是00000000 00000000 00000000 00000000 ：这个是数据高位部分
d[1]中是01000000 00001100 00000000 00000000：高地址存的是数据的低位部分

而你的理解是认为d[0]是01000000 00001100 00000000 00000000应该在低位，
那是你认为栈的生长方向是从低位到高位。（这里不得不涉及到栈的生长方向了）
实际上我们正在讨论的环境是栈是从高地址到低地址的，这是突破你的疑问关键所在。
从上面的输出结果来看，还是没有打破你原来正确的认知，小端还是低地址存的是数据的高位部分。

不知道这个回答可以帮你解惑了吗

[haifan191]

jf

[ropert911]

我是来接分的。谢谢，我要10分。

[Delta]

来看看，学习一下

[wangchentangjuan]

jf

[hacker1125]

jf而来。。。

[lmafwo]

看看

[zy7318750]

UP

[lidowx]

接分

[chenmengdx]

JF

[simes34]

jf~~~

[sj13426074890]

jf

[tan870426]

学习

[psc88]

jf

[jdjking]

[Quote=引用 26 楼 traceless 的回复:]
C/C++ codeprintf("%p:%#x\n",&c,*(unsignedshort*)&c);
printf("%p:%#x\n",(unsignedshort*)&c+1,*((unsignedshort*)&c+1));
printf("%p:%#x\n",(unsignedshort*)&c+2,*((unsignedshort*)&c+2));
printf("%p:%#x\n",(unsignedshort*)&c+3,*((unsignedshort*)&c+3));

运行结果如下：
Assembly code0012FF5C:0
0012FF5E:0
0012FF60:0
0012FF62:0x400c
也就是说低地址：d[0]中是00000000000000000000000000000000 ：这个是数据高位部分
d[1]中是01000000000011000000000000000000：高地址存的是数据的低位部分

而你的理解是认为d[0]是01000000 00001100 00000000 00000000应该在低位，
那是你认为栈的生长方向是从低位到高位。（这里不得不涉及到栈的生长方向了）
实际上我们正在讨论的环境是栈是从高地址到低地址的，这是突破你的疑问关键所在。
从上面的输出结果来看，还是没有打破你原来正确的认知，小端还是低地址存的是数据的高位部分。

不知道这个回答可以帮你解惑了吗
[/Quote]
这块知道但不熟，补课了，呵呵

[NIKE霸天虎]

环境是栈是从高地址到低地址的