ＶＣ＋＋２００８ｘ６４の最近のブログ記事

６４ビットだろうとアラインメントとパディングの話は変わらない

微禄
(2021年3月28日 15:45) |

６４ビット化擬きの真似事の続きの続きの続きの続きです。

取り敢えず、６４ビットでの構造体のアラインメントなどを確認するだけのサンプルも作ってみました。


＜注意点＞

・メモリ効率を上げてシステムのパフォーマンスを改善しようと「#pragma pack」などを使用すると、アラインメントがズレたメンバにアクセスする際に性能低下 *1 を引き起こしたり、最悪の場合バスエラー *2 が発生する恐れがあります。

・前回の３２ビットとの違いは、ｓｔ１３～ｓｔ１５の配列の要素数のみです。

*1：インテルの場合、ｘ８６系（ｘ６４含む）　*2：インテルの場合、Ｉｔａｎｉｕｍ系


【６４ビット、構造体のアラインメントデータ】

アラインメント機能６４ビット確認
構造体タグｓｉｚｅｏｆａｌｉｇｎｍｅｎｔｐａｄｄｉｎｇ
本来サイズ 出力結果 メンバ最大 構造体サイズ メンバ間 最終メンバの後
ｓｔ０１ ９ １６ ８ １６ ７ ０
ｓｔ０２ １０ １６ ８ １６ ６ ０
ｓｔ０３ １２ １６ ８ １６ ４ ０
ｓｔ０４ １６ １６ ８ １６ ０ ０
ｓｔ０５ １２ １６ ８ １６ ４ ０
ｓｔ０６ １６ １６ ８ １６ ０ ０
ｓｔ０７ ９ １６ ８ １６ ０ ７
ｓｔ０８ １０ １６ ８ １６ ０ ６
ｓｔ０９ １２ １６ ８ １６ ０ ４
ｓｔ１０ １６ １６ ８ １６ ０ ０
ｓｔ１１ １２ １６ ８ １６ ０ ４
ｓｔ１２ １６ １６ ８ １６ ０ ０
ｓｔ１３ １７ ２４ ８ ２４ ７ ０
ｓｔ１４ ２６ ３２ ８ ３２ ６ ０
ｓｔ１５ ４０ ４０ ８ ４０ ０ ０
ｓｔ２１ １０ １６ ８ １６ ６ ０
ｓｔ２２ １２ １６ ８ １６ ４ ０
ｓｔ２３ ８０２ ８０８ ８ ８０８ ６ ０
ｓｔ２４ ８０４ ８０８ ８ ８０８ ４ ０


お試し環境
  WindowsXP 32bit Edition、Windows7 64bit Edition
  Visual C++ 2008 cross x64、native x64


/*---- ６４ビット -------------------　コマンドライン　-----------------------*/

D:\vc2008\x86x64>cl test.c

/*----------------------------------------------------------------------------*/


/*---- ６４ビットデータ --------------------　お試し結果　--------------------*/

D:\vc2008\x86x64>test
sizeof check
diz01 = 16, &diz01 = 000000014000FB80, &diz01.no = 000000014000FB80, diz01.dat = 000000014000FB88
diz02 = 16, &diz02 = 000000014000FFE0, &diz02.no = 000000014000FFE0, diz02.dat = 000000014000FFE8
diz03 = 16, &diz03 = 000000014000F800, &diz03.no = 000000014000F800, diz03.dat = 000000014000F808
diz04 = 16, &diz04 = 000000014000FC00, &diz04.no = 000000014000FC00, diz04.dat = 000000014000FC08
diz05 = 16, &diz05 = 000000014000FB70, &diz05.no = 000000014000FB70, diz05.dat = 000000014000FB78
diz06 = 16, &diz06 = 000000014000FBD0, &diz06.no = 000000014000FBD0, diz06.dat = 000000014000FBD8

padding check
diz07 = 16, &diz07 = 000000014000FBF0, diz07.dat = 000000014000FBF0, &diz07.no = 000000014000FBF8
diz08 = 16, &diz08 = 000000014000F820, diz08.dat = 000000014000F820, &diz08.no = 000000014000F828
diz09 = 16, &diz09 = 000000014000FBE0, diz09.dat = 000000014000FBE0, &diz09.no = 000000014000FBE8
diz10 = 16, &diz10 = 000000014000FC20, diz10.dat = 000000014000FC20, &diz10.no = 000000014000FC28
diz11 = 16, &diz11 = 000000014000FC70, diz11.dat = 000000014000FC70, &diz11.no = 000000014000FC78
diz12 = 16, &diz12 = 000000014000FBC0, diz12.dat = 000000014000FBC0, &diz12.no = 000000014000FBC8

Alignment check
diz13 = 24, &diz13 = 000000014000FFC0, &diz13.no = 000000014000FFC0, diz13.dat = 000000014000FFD0
diz14 = 32, &diz14 = 000000014000FBA0, &diz14.no = 000000014000FBA0, diz14.dat = 000000014000FBB8
diz15 = 40, &diz15 = 000000014000FC40, &diz15.no = 000000014000FC40, diz15.dat = 000000014000FC60

Arithmetic check
diz21 = 16, &diz21 = 000000014000F810, &diz21.no = 000000014000F810, diz21.ptr = 000000014000F818
diz22 = 16, &diz22 = 000000014000FC10, &diz22.no = 000000014000FC10, diz22.ptr = 000000014000FC18
diz23 = 808, &diz23 = 000000014000F840, &diz23.no = 000000014000F840, diz23.ptr = 000000014000F848
diz24 = 808, &diz24 = 000000014000FC80, &diz24.no = 000000014000FC80, diz24.ptr = 000000014000FC88

sizeof(WORD) + 100 * sizeof(PVOID) = 802
sizeof(DWORD) + 100 * sizeof(PVOID) = 804
FIELD_OFFSET(struct st21, ptr) + 100 * sizeof(PVOID) = 808
FIELD_OFFSET(struct st22, ptr) + 100 * sizeof(PVOID) = 808

/*----------------------------------------------------------------------------*/


/*---- test.c -------------------　６４ビット お試しソース　------------------*/

#include <stdio.h>
#include <windows.h>

// sizeof check
struct st01 {
    char no;
    void *dat[1];
} diz01;

struct st02 {
    short no;
    void *dat[1];
} diz02;

struct st03 {
    int no;
    void *dat[1];
} diz03;

struct st04 {
    long long no;
    void *dat[1];
} diz04;

struct st05 {
    float no;
    void *dat[1];
} diz05;

struct st06 {
    double no;
    void *dat[1];
} diz06;

// padding check
struct st07 {
    void *dat[1];
    char no;
} diz07;

struct st08 {
    void *dat[1];
    short no;
} diz08;

struct st09 {
    void *dat[1];
    int no;
} diz09;

struct st10 {
    void *dat[1];
    long long no;
} diz10;

struct st11 {
    void *dat[1];
    float no;
} diz11;

struct st12 {
    void *dat[1];
    double no;
} diz12;

// Alignment check
struct st13 {
    char no[9];
    void *dat[1];
} diz13;

struct st14 {
    short no[9];
    void *dat[1];
} diz14;

struct st15 {
    long long no[4];
    void *dat[1];
} diz15;

// Arithmetic check
struct st21 {
    WORD no;
    PVOID ptr[1];
} diz21;

struct st22 {
    DWORD no;
    PVOID ptr[1];
} diz22;

struct st23 {
    WORD no;
    PVOID ptr[100];
} diz23;

struct st24 {
    DWORD no;
    PVOID ptr[100];
} diz24;

int main(int argc, char *argv[])
{
    printf("sizeof check\n");
    printf("diz01 = %d, &diz01 = %p, &diz01.no = %p, diz01.dat = %p\n", sizeof(diz01), &diz01, &diz01.no, diz01.dat);
    printf("diz02 = %d, &diz02 = %p, &diz02.no = %p, diz02.dat = %p\n", sizeof(diz02), &diz02, &diz02.no, diz02.dat);
    printf("diz03 = %d, &diz03 = %p, &diz03.no = %p, diz03.dat = %p\n", sizeof(diz03), &diz03, &diz03.no, diz03.dat);
    printf("diz04 = %d, &diz04 = %p, &diz04.no = %p, diz04.dat = %p\n", sizeof(diz04), &diz04, &diz04.no, diz04.dat);
    printf("diz05 = %d, &diz05 = %p, &diz05.no = %p, diz05.dat = %p\n", sizeof(diz05), &diz05, &diz05.no, diz05.dat);
    printf("diz06 = %d, &diz06 = %p, &diz06.no = %p, diz06.dat = %p\n", sizeof(diz06), &diz06, &diz06.no, diz06.dat);

    printf("\npadding check\n");
    printf("diz07 = %d, &diz07 = %p, diz07.dat = %p, &diz07.no = %p\n", sizeof(diz07), &diz07, diz07.dat, &diz07.no);
    printf("diz08 = %d, &diz08 = %p, diz08.dat = %p, &diz08.no = %p\n", sizeof(diz08), &diz08, diz08.dat, &diz08.no);
    printf("diz09 = %d, &diz09 = %p, diz09.dat = %p, &diz09.no = %p\n", sizeof(diz09), &diz09, diz09.dat, &diz09.no);
    printf("diz10 = %d, &diz10 = %p, diz10.dat = %p, &diz10.no = %p\n", sizeof(diz10), &diz10, diz10.dat, &diz10.no);
    printf("diz11 = %d, &diz11 = %p, diz11.dat = %p, &diz11.no = %p\n", sizeof(diz11), &diz11, diz11.dat, &diz11.no);
    printf("diz12 = %d, &diz12 = %p, diz12.dat = %p, &diz12.no = %p\n", sizeof(diz12), &diz12, diz12.dat, &diz12.no);

    printf("\nAlignment check\n");
    printf("diz13 = %d, &diz13 = %p, &diz13.no = %p, diz13.dat = %p\n", sizeof(diz13), &diz13, &diz13.no, diz13.dat);
    printf("diz14 = %d, &diz14 = %p, &diz14.no = %p, diz14.dat = %p\n", sizeof(diz14), &diz14, &diz14.no, diz14.dat);
    printf("diz15 = %d, &diz15 = %p, &diz15.no = %p, diz15.dat = %p\n", sizeof(diz15), &diz15, &diz15.no, diz15.dat);

    printf("\nArithmetic check\n");
    printf("diz21 = %d, &diz21 = %p, &diz21.no = %p, diz21.ptr = %p\n", sizeof(diz21), &diz21, &diz21.no, diz21.ptr);
    printf("diz22 = %d, &diz22 = %p, &diz22.no = %p, diz22.ptr = %p\n", sizeof(diz22), &diz22, &diz22.no, diz22.ptr);
    printf("diz23 = %d, &diz23 = %p, &diz23.no = %p, diz23.ptr = %p\n", sizeof(diz23), &diz23, &diz23.no, diz23.ptr);
    printf("diz24 = %d, &diz24 = %p, &diz24.no = %p, diz24.ptr = %p\n", sizeof(diz24), &diz24, &diz24.no, diz24.ptr);

    printf("\n");
    printf("sizeof(WORD) + 100 * sizeof(PVOID) = %d\n", sizeof(WORD) + 100 * sizeof(PVOID));
    printf("sizeof(DWORD) + 100 * sizeof(PVOID) = %d\n", sizeof(DWORD) + 100 * sizeof(PVOID));

    printf("FIELD_OFFSET(struct st21, ptr) + 100 * sizeof(PVOID) = %d\n", FIELD_OFFSET(struct st21, ptr) + 100 * sizeof(PVOID));
    printf("FIELD_OFFSET(struct st22, ptr) + 100 * sizeof(PVOID) = %d\n", FIELD_OFFSET(struct st22, ptr) + 100 * sizeof(PVOID));
}

/*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*/
/*============================================================================*/

３２ビット⇒６４ビット化の問題では無く、アラインメントの話だと思うけど

微禄
(2021年3月22日 15:06) |

６４ビット化擬きの真似事の続きの続きの続きです。

ＭＳドキュメントの「移植に関する問題のチェックリスト」に書かれている以下の問題点は、本当に６４ビット化に関する問題なのか？ と首を傾げたくなります。（それとも、隠れている意図を見つけられないだけ？）

単に「アラインメント」と「パディング」の説明書き、だと思うのですが・・・。

struct xx {
   DWORD NumberOfPointers;
   PVOID Pointers[1];
};

ＮＧ：malloc(sizeof(DWORD)+100*sizeof(PVOID));
ＯＫ：malloc(FIELD_OFFSET(struct xx, Pointers) +100*sizeof(PVOID));

これって、単なる偶然（チョンボ？）の一致ですよね。だって、３２ビットの「ＷＯＲＤ」でも同じ問題が発生しますから。

そこで、３２ビットでの構造体のアラインメントなどを確認するだけのサンプルを作ってみました。

尚、構造体のメンバを「あなた」が適切な順序で並べる事が出来れば、パディングを限り無く０に近付ける事が可能らしいです。


＜注意点＞

・構造体のサイズには、本来のサイズとアラインメント調整されたサイズとが有ります。

・構造体のアラインメントは、メンバのアラインメント最大値と同じ。

・Ｃコンパイラの構造体サイズは、メンバの中で最大サイズのアラインメントを整数倍した値と同じ。

・sizeof 演算子の戻り値は、構造体メンバのアラインメント最大値を整数倍に切り上げた値で、本来のサイズではありません。

・つまり、構造体の本来のサイズは電卓を叩けば分かります。アラインメント調整されたサイズは sizeof() を使えば直ぐ分かります。


【３２ビット、構造体のアラインメントデータ】

アラインメント機能３２ビット確認
構造体タグｓｉｚｅｏｆａｌｉｇｎｍｅｎｔｐａｄｄｉｎｇ
本来サイズ 出力結果 メンバ最大 構造体サイズ メンバ間 最終メンバの後
ｓｔ０１ ５ ８ ４ ８ ３ ０
ｓｔ０２ ６ ８ ４ ８ ２ ０
ｓｔ０３ ８ ８ ４ ８ ０ ０
ｓｔ０４ １２ １６ ８ １６ ０ ４
ｓｔ０５ ８ ８ ４ ８ ０ ０
ｓｔ０６ １２ １６ ８ １６ ０ ４
ｓｔ０７ ５ ８ ４ ８ ０ ３
ｓｔ０８ ６ ８ ４ ８ ０ ２
ｓｔ０９ ８ ８ ４ ８ ０ ０
ｓｔ１０ １２ １６ ８ １６ ４ ０
ｓｔ１１ ８ ８ ４ ８ ０ ０
ｓｔ１２ １２ １６ ８ １６ ４ ０
ｓｔ１３ ９ １２ ４ １２ ３ ０
ｓｔ１４ １４ １６ ４ １６ ２ ０
ｓｔ１５ ２０ ２４ ８ ２４ ０ ４
ｓｔ２１ ６ ８ ４ ８ ２ ０
ｓｔ２２ ８ ８ ４ ８ ０ ０
ｓｔ２３ ４０２ ４０４ ４ ４０４ ２ ０
ｓｔ２４ ４０４ ４０４ ４ ４０４ ０ ０


お試し環境
  WindowsXP 32bit Edition、Windows7 64bit Edition
  Visual C++ 2008 cross x64、native x64


/*---- ３２ビット -------------------　コマンドライン　-----------------------*/

D:\vc2008\x86x64>cl test.c

/*----------------------------------------------------------------------------*/


/*---- ３２ビットデータ --------------------　お試し結果　--------------------*/

D:\vc2008\x86x64>test
sizeof check
diz01 = 8, &diz01 = 0040E0A0, &diz01.no = 0040E0A0, diz01.dat = 0040E0A4
diz02 = 8, &diz02 = 0040E2F0, &diz02.no = 0040E2F0, diz02.dat = 0040E2F4
diz03 = 8, &diz03 = 0040DEE0, &diz03.no = 0040DEE0, diz03.dat = 0040DEE4
diz04 = 16, &diz04 = 0040E0F0, &diz04.no = 0040E0F0, diz04.dat = 0040E0F8
diz05 = 8, &diz05 = 0040E098, &diz05.no = 0040E098, diz05.dat = 0040E09C
diz06 = 16, &diz06 = 0040E0D0, &diz06.no = 0040E0D0, diz06.dat = 0040E0D8

padding check
diz07 = 8, &diz07 = 0040E0E8, diz07.dat = 0040E0E8, &diz07.no = 0040E0EC
diz08 = 8, &diz08 = 0040DEF0, diz08.dat = 0040DEF0, &diz08.no = 0040DEF4
diz09 = 8, &diz09 = 0040E0E0, diz09.dat = 0040E0E0, &diz09.no = 0040E0E4
diz10 = 16, &diz10 = 0040E110, diz10.dat = 0040E110, &diz10.no = 0040E118
diz11 = 8, &diz11 = 0040E138, diz11.dat = 0040E138, &diz11.no = 0040E13C
diz12 = 16, &diz12 = 0040E0C0, diz12.dat = 0040E0C0, &diz12.no = 0040E0C8

Alignment check
diz13 = 12, &diz13 = 0040E2E0, &diz13.no = 0040E2E0, diz13.dat = 0040E2E8
diz14 = 16, &diz14 = 0040E0B0, &diz14.no = 0040E0B0, diz14.dat = 0040E0BC
diz15 = 24, &diz15 = 0040E120, &diz15.no = 0040E120, diz15.dat = 0040E130

Arithmetic check
diz21 = 8, &diz21 = 0040DEE8, &diz21.no = 0040DEE8, diz21.ptr = 0040DEEC
diz22 = 8, &diz22 = 0040E100, &diz22.no = 0040E100, diz22.ptr = 0040E104
diz23 = 404, &diz23 = 0040DF00, &diz23.no = 0040DF00, diz23.ptr = 0040DF04
diz24 = 404, &diz24 = 0040E140, &diz24.no = 0040E140, diz24.ptr = 0040E144

sizeof(WORD) + 100 * sizeof(PVOID) = 402
sizeof(DWORD) + 100 * sizeof(PVOID) = 404
FIELD_OFFSET(struct st21, ptr) + 100 * sizeof(PVOID) = 404
FIELD_OFFSET(struct st22, ptr) + 100 * sizeof(PVOID) = 404

/*----------------------------------------------------------------------------*/


/*---- test.c -----------------------　お試しソース　-------------------------*/

#include <stdio.h>
#include <windows.h>

// sizeof check
struct st01 {
    char no;
    void *dat[1];
} diz01;

struct st02 {
    short no;
    void *dat[1];
} diz02;

struct st03 {
    int no;
    void *dat[1];
} diz03;

struct st04 {
    long long no;
    void *dat[1];
} diz04;

struct st05 {
    float no;
    void *dat[1];
} diz05;

struct st06 {
    double no;
    void *dat[1];
} diz06;

// padding check
struct st07 {
    void *dat[1];
    char no;
} diz07;

struct st08 {
    void *dat[1];
    short no;
} diz08;

struct st09 {
    void *dat[1];
    int no;
} diz09;

struct st10 {
    void *dat[1];
    long long no;
} diz10;

struct st11 {
    void *dat[1];
    float no;
} diz11;

struct st12 {
    void *dat[1];
    double no;
} diz12;

// Alignment check
struct st13 {
    char no[5];
    void *dat[1];
} diz13;

struct st14 {
    short no[5];
    void *dat[1];
} diz14;

struct st15 {
    long long no[2];
    void *dat[1];
} diz15;

// Arithmetic check
struct st21 {
    WORD no;
    PVOID ptr[1];
} diz21;

struct st22 {
    DWORD no;
    PVOID ptr[1];
} diz22;

struct st23 {
    WORD no;
    PVOID ptr[100];
} diz23;

struct st24 {
    DWORD no;
    PVOID ptr[100];
} diz24;

int main(int argc, char *argv[])
{
    printf("sizeof check\n");
    printf("diz01 = %d, &diz01 = %p, &diz01.no = %p, diz01.dat = %p\n", sizeof(diz01), &diz01, &diz01.no, diz01.dat);
    printf("diz02 = %d, &diz02 = %p, &diz02.no = %p, diz02.dat = %p\n", sizeof(diz02), &diz02, &diz02.no, diz02.dat);
    printf("diz03 = %d, &diz03 = %p, &diz03.no = %p, diz03.dat = %p\n", sizeof(diz03), &diz03, &diz03.no, diz03.dat);
    printf("diz04 = %d, &diz04 = %p, &diz04.no = %p, diz04.dat = %p\n", sizeof(diz04), &diz04, &diz04.no, diz04.dat);
    printf("diz05 = %d, &diz05 = %p, &diz05.no = %p, diz05.dat = %p\n", sizeof(diz05), &diz05, &diz05.no, diz05.dat);
    printf("diz06 = %d, &diz06 = %p, &diz06.no = %p, diz06.dat = %p\n", sizeof(diz06), &diz06, &diz06.no, diz06.dat);

    printf("\npadding check\n");
    printf("diz07 = %d, &diz07 = %p, diz07.dat = %p, &diz07.no = %p\n", sizeof(diz07), &diz07, diz07.dat, &diz07.no);
    printf("diz08 = %d, &diz08 = %p, diz08.dat = %p, &diz08.no = %p\n", sizeof(diz08), &diz08, diz08.dat, &diz08.no);
    printf("diz09 = %d, &diz09 = %p, diz09.dat = %p, &diz09.no = %p\n", sizeof(diz09), &diz09, diz09.dat, &diz09.no);
    printf("diz10 = %d, &diz10 = %p, diz10.dat = %p, &diz10.no = %p\n", sizeof(diz10), &diz10, diz10.dat, &diz10.no);
    printf("diz11 = %d, &diz11 = %p, diz11.dat = %p, &diz11.no = %p\n", sizeof(diz11), &diz11, diz11.dat, &diz11.no);
    printf("diz12 = %d, &diz12 = %p, diz12.dat = %p, &diz12.no = %p\n", sizeof(diz12), &diz12, diz12.dat, &diz12.no);

    printf("\nAlignment check\n");
    printf("diz13 = %d, &diz13 = %p, &diz13.no = %p, diz13.dat = %p\n", sizeof(diz13), &diz13, &diz13.no, diz13.dat);
    printf("diz14 = %d, &diz14 = %p, &diz14.no = %p, diz14.dat = %p\n", sizeof(diz14), &diz14, &diz14.no, diz14.dat);
    printf("diz15 = %d, &diz15 = %p, &diz15.no = %p, diz15.dat = %p\n", sizeof(diz15), &diz15, &diz15.no, diz15.dat);

    printf("\nArithmetic check\n");
    printf("diz21 = %d, &diz21 = %p, &diz21.no = %p, diz21.ptr = %p\n", sizeof(diz21), &diz21, &diz21.no, diz21.ptr);
    printf("diz22 = %d, &diz22 = %p, &diz22.no = %p, diz22.ptr = %p\n", sizeof(diz22), &diz22, &diz22.no, diz22.ptr);
    printf("diz23 = %d, &diz23 = %p, &diz23.no = %p, diz23.ptr = %p\n", sizeof(diz23), &diz23, &diz23.no, diz23.ptr);
    printf("diz24 = %d, &diz24 = %p, &diz24.no = %p, diz24.ptr = %p\n", sizeof(diz24), &diz24, &diz24.no, diz24.ptr);

    printf("\n");
    printf("sizeof(WORD) + 100 * sizeof(PVOID) = %d\n", sizeof(WORD) + 100 * sizeof(PVOID));
    printf("sizeof(DWORD) + 100 * sizeof(PVOID) = %d\n", sizeof(DWORD) + 100 * sizeof(PVOID));

    printf("FIELD_OFFSET(struct st21, ptr) + 100 * sizeof(PVOID) = %d\n", FIELD_OFFSET(struct st21, ptr) + 100 * sizeof(PVOID));
    printf("FIELD_OFFSET(struct st22, ptr) + 100 * sizeof(PVOID) = %d\n", FIELD_OFFSET(struct st22, ptr) + 100 * sizeof(PVOID));
}

/*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*/
/*============================================================================*/

３２ビットプログラムの６４ビット化に関する問題点を拾ってみる

微禄
(2021年3月14日 12:37) |

６４ビット化擬きの真似事の続きの続きです。

６４ビット化に関して色々と検索していると、「移植に関する問題のチェックリスト」なるマイクロソフトドキュメントを見つけ、簡単そうな問題点を拾ってコンパイルするだけのサンプルを作ってみました。

ただ最近までは、配列の添え字の確からしさを含め処理する事が、プログラマの努めだった筈なのに？ 添え字の"－１"って、普通のソフトウエアでは有り得ない？


＜ポインタ算術演算の注意点＞

①符号無しと符号付きの演算には注意

　この問題は x が符号無しのために発生します（式全体が符号無しになる）が、y が負の値でない限り成功します。
　64ビットの Windows では、この32ビットの符号無し負の値は、大きな64ビットの正の数値になり、間違った結果が得られます。
　（この問題を解決するには、x を符号付きの値として宣言するか、式を明示的に LONG 型にキャストします。と在りますが・・・）

②１６進定数と符号無しの値を使用する場合には注意

　６４ビットシステムでは、条件式は真に成りません。
　(UINT64)(TEST_SIZE - 1) = 0x0000000000000fff ⇒ ~((UINT_PTR)(TEST_SIZE - 1)) = 0xfffffffffffff000
　~(TEST_SIZE - 1) = 0xfffff000　　　　　　　　⇒ (UINT_PTR)(~(TEST_SIZE - 1)) = 0x00000000fffff000

③ＮＯＴ演算には注意

　この問題は、~(b - 1) が 0x0000 0000 xxxx xxxx を生成し、0xFFFF FFFF xxxx xxxx とは成らないことです。
　コンパイラはこれを検出しません。

④バッファサイズを計算する場合には注意

　ポインタの演算ではポインタをＰＣＨＡＲにキャストする。とありますが、

　何故これが移植に関する問題点に挙がっているのか、良く分かりません。８バイトどうしの減算結果が４バイトに収まる保証は無い、のは確かです。

　だとしても、３２ビットでも当該事項が指摘されていないのが不可解です。バッファサイズと言うなら、"１"ではなく"４"ですよね？
　これも、プログラマとして想定内だと思うのですが・・・。

⑤６４ビットの Windows では、0xFFFFFFFF は -1 と同じでは無いことに注意

　３２ビット機の場合：p[index - 1] == p[0xffffffff] == p[-1]
　６４ビット機の場合：p[index - 1] == p[0x00000000ffffffff] != p[-1]、（index が４バイトの時）

以上の様な説明書きが、ドキュメントに在りました。


お試し環境
  WindowsXP 32bit Edition、Windows7 64bit Edition
  Visual C++ 2008 cross x64、native x64


/*---- ３２ビット -------------------　コマンドライン　-----------------------*/

D:\vc2008\x86x64>cl test32.c

/*----------------------------------------------------------------------------*/

/*---- ６４ビット -------------------　コマンドライン　-----------------------*/

D:\vc2008\x86x64>cl test64.c

/*----------------------------------------------------------------------------*/


/*---- ３２ビットデータ --------------------　お試し結果　--------------------*/

D:\vc2008\x86x64>test32
①-1：pVar2 = 0012FF7C, pVar1 = 0012FF6C, y = 2, x = 3
①-2：pVar2 = 0012FF5C, pVar1 = 0012FF6C, y = -2, x = 3
②：Equal, ~((UINT_PTR)(TEST_SIZE - 1)) = 0xfffff000, (UINT_PTR)(~(TEST_SIZE - 1)) = 0xfffff000
③：a = 0x12141210
④：len = 0x1
⑤：Equal, p[index - 1] = 0, p[-1] = 0

/*----------------------------------------------------------------------------*/

/*---- そのまま６４ビット化 ---------------　お試し結果　---------------------*/

D:\vc2008\x86x64>test64
①-1：pVar2 = 000000000012FEE0, pVar1 = 000000000012FED0, y = 2, x = 3
①-2：pVar2 = 000000040012FEC0, pVar1 = 000000000012FED0, y = -2, x = 3
②：NOT equal, ~((UINT_PTR)(TEST_SIZE - 1)) = 0xfffffffffffff000, (UINT_PTR)(~(TEST_SIZE - 1)) = 0xfffff000
③：a = 0x12141210
④：len = 0xffffffff
⑤：例外発生 ← コメント化
⑥：index - 1 = 0xffffffff, -1 = 0xffffffff

/*----------------------------------------------------------------------------*/

/*---- 手直し６４ビット化 -----------------　お試し結果　---------------------*/

D:\vc2008\x86x64>test64
①-1：pVar2 = 000000000012FED0, pVar1 = 000000000012FEC0, y = 2, x = 3
①-2：pVar2 = 000000040012FEB0, pVar1 = 000000000012FEC0, y = -2, x = 3
①-3：pVar2 = 000000000012FEB0, pVar1 = 000000000012FEC0, y = -2, x = 3
②：NOT equal, ~((UINT_PTR)(TEST_SIZE - 1)) = 0xfffffffffffff000, (UINT_PTR)(~(TEST_SIZE - 1)) = 0xfffff000
③：a = 0x9012141210
④：len = 0xfffffffc
⑤：Equal, p[index - 1] = 0, p[-1] = 0
⑥：index - 1 = 0xffffffffffffffff, -1 = 0xffffffff
⑦：ptr2 = 000000000012FEF8, ptr1 = 000000000012FEFC, ptr2 - ptr1 = FFFFFFFFFFFFFFFF

/*----------------------------------------------------------------------------*/


/*---- test32.c -----------------------　お試しソース　-----------------------*/

#include <stdio.h>
#include <windows.h>

#define TEST_SIZE 0x1000UL

int main(char argc, char *argv[])
{
    ULONG x = 3;
    LONG y = 2;
    LONG z;
    LONG *pVar1 = &y;
    LONG *pVar2 = &z;

    UINT_PTR a = 0x12345678;
    ULONG b = 0xabcdef;

    LONG c;
    LONG d;
    ULONG len;
    LONG *ptr1 = &c;
    LONG *ptr2 = &d;

    DWORD index = 0;
    CHAR *p = "ABC";

    pVar2 = pVar1 + y * (x - 1);
    printf("\n①-1：pVar2 = %p, pVar1 = %p, y = %d, x = %d\n", pVar2, pVar1, y, x);
    y = -2;
    pVar2 = pVar1 + y * (x - 1);
    printf("①-2：pVar2 = %p, pVar1 = %p, y = %d, x = %d\n", pVar2, pVar1, y, x);

    if(~((UINT_PTR)(TEST_SIZE - 1)) == (UINT_PTR)(~(TEST_SIZE - 1))) { // warning C4127: 条件式が定数です。
        printf("②：Equal, ~((UINT_PTR)(TEST_SIZE - 1)) = %#x, (UINT_PTR)(~(TEST_SIZE - 1)) = %#x\n", ~((UINT_PTR)(TEST_SIZE - 1)), (UINT_PTR)(~(TEST_SIZE - 1)));
    } else {
        printf("②：NOT equal, ~((UINT_PTR)(TEST_SIZE - 1)) = %#llx, (UINT_PTR)(~(TEST_SIZE - 1)) = %#llx\n", ~((UINT_PTR)(TEST_SIZE - 1)), (UINT_PTR)(~(TEST_SIZE - 1)));
    }

    a = a & ~(b - 1);
    printf("③：a = %#x\n", a);

    len = ptr2 - ptr1;
    printf("④：len = %#x\n", len);

    if(p[index - 1] == p[-1]) {
        printf("⑤：Equal, p[index - 1] = %#x, p[-1] = %#x\n", p[index - 1], p[-1]); // On 32-bit machines : p[index-1] == p[0xffffffff] == p[-1]
    } else {
        printf("⑤：NOT equal, p[index - 1] = %#llx, p[-1] = %#llx\n", p[index - 1], p[-1]);
    }
}

/*----------------------------------------------------------------------------*/

/*---- test64.c ---------------　そのまま６４ビット化ソース　-----------------*/

#include <stdio.h>
#include <windows.h>

#define TEST_SIZE 0x1000UL

int main(char argc, char *argv[])
{
    ULONG x = 3;
    LONG y = 2;
    LONG z;
    LONG *pVar1 = &y;
    LONG *pVar2 = &z;

    UINT_PTR a = 0x9012345678;
    ULONG b = 0xabcdef;

    LONG c;
    LONG d;
    ULONG len;
    LONG *ptr1 = &c;
    LONG *ptr2 = &d;

    DWORD index = 0;
    CHAR *p = "ABC";

    pVar2 = pVar1 + y * (x - 1);
    printf("\n①-1：pVar2 = %p, pVar1 = %p, y = %d, x = %d\n", pVar2, pVar1, y, x);
    y = -2;
    pVar2 = pVar1 + y * (x - 1);
    printf("①-2：pVar2 = %p, pVar1 = %p, y = %d, x = %d\n", pVar2, pVar1, y, x);

    if(~((UINT_PTR)(TEST_SIZE - 1)) == (UINT_PTR)(~(TEST_SIZE - 1))) { // warning C4127: 条件式が定数です。
        printf("②：Equal, ~((UINT_PTR)(TEST_SIZE - 1)) = %#x, (UINT_PTR)(~(TEST_SIZE - 1)) = %#x\n", ~((UINT_PTR)(TEST_SIZE - 1)), (UINT_PTR)(~(TEST_SIZE - 1)));
    } else {
        printf("②：NOT equal, ~((UINT_PTR)(TEST_SIZE - 1)) = %#llx, (UINT_PTR)(~(TEST_SIZE - 1)) = %#llx\n", ~((UINT_PTR)(TEST_SIZE - 1)), (UINT_PTR)(~(TEST_SIZE - 1)));
    }

    a = a & ~(b - 1);
    printf("③：a = %#llx\n", a);

    len = ptr2 - ptr1; // warning C4242: '=' : '__int64' から 'ULONG' への変換です。データが失われる可能性があります。
    printf("④：len = %#x\n", len);
/*
    if(p[index - 1] == p[-1]) { // // causes access violation on 64-bit Windows!
        printf("⑤：Equal, p[index - 1] = %#x, p[-1] = %#x\n", p[index - 1], p[-1]);
    } else {
        printf("⑤：NOT equal, p[index - 1] = %#llx, p[-1] = %#llx\n", p[index - 1], p[-1]); // // On 64-bit machines : p[index-1] == p[0x00000000ffffffff] != p[-1]
    }
*/
    printf("⑥：index - 1 = %#llx, -1 = %#llx\n", index - 1, -1);
}

/*----------------------------------------------------------------------------*/

/*---- test64.c ----------------　手直し６４ビット化ソース　------------------*/

#include <stdio.h>
#include <windows.h>

#define TEST_SIZE 0x1000UL

int main(char argc, char *argv[])
{
    ULONG x = 3;
    LONG y = 2;
    LONG z;
    LONG *pVar1 = &y;
    LONG *pVar2 = &z;

    UINT_PTR a = 0x9012345678;
    ULONG b = 0xabcdef;

    LONG c;
    LONG d;
    ULONG len;
    LONG *ptr1 = &c;
    LONG *ptr2 = &d;

    DWORD_PTR index = 0;
    CHAR *p = "ABC";

    pVar2 = pVar1 + y * (x - 1);
    printf("\n①-1：pVar2 = %p, pVar1 = %p, y = %d, x = %d\n", pVar2, pVar1, y, x);
    y = -2;
    pVar2 = pVar1 + y * (x - 1);
    printf("①-2：pVar2 = %p, pVar1 = %p, y = %d, x = %d\n", pVar2, pVar1, y, x);
    pVar2 = (LONG)(pVar1 + y * (x - 1)); // warning C4305: '型キャスト' : 'LONG *' から 'LONG' へ切り詰めます。warning C4047: '=' : 間接参照のレベルが 'LONG *' と 'LONG' で異なっています。
    printf("①-3：pVar2 = %p, pVar1 = %p, y = %d, x = %d\n", pVar2, pVar1, y, x);

    if(~((UINT_PTR)(TEST_SIZE - 1)) == (UINT_PTR)(~(TEST_SIZE - 1))) { // warning C4127: 条件式が定数です。
        printf("②：Equal, ~((UINT_PTR)(TEST_SIZE - 1)) = %#x, (UINT_PTR)(~(TEST_SIZE - 1)) = %#x\n", ~((UINT_PTR)(TEST_SIZE - 1)), (UINT_PTR)(~(TEST_SIZE - 1)));
    } else {
        printf("②：NOT equal, ~((UINT_PTR)(TEST_SIZE - 1)) = %#llx, (UINT_PTR)(~(TEST_SIZE - 1)) = %#llx\n", ~((UINT_PTR)(TEST_SIZE - 1)), (UINT_PTR)(~(TEST_SIZE - 1)));
    }

    a = a & ~((UINT_PTR)b - 1);
    printf("③：a = %#llx\n", a);

    len = (PCHAR)ptr2 - (PCHAR)ptr1; // warning C4242: '=' : '__int64' から 'ULONG' への変換です。データが失われる可能性があります。
    printf("④：len = %#x\n", len);

    if(p[index - 1] == p[-1]) {
        printf("⑤：Equal, p[index - 1] = %#x, p[-1] = %#x\n", p[index - 1], p[-1]);
    } else {
        printf("⑤：NOT equal, p[index - 1] = %#llx, p[-1] = %#llx\n", p[index - 1], p[-1]);
    }
    printf("⑥：index - 1 = %#llx, -1 = %#llx\n", index - 1, -1);

    printf("⑦：ptr2 = %p, ptr1 = %p, ptr2 - ptr1 = %p\n", ptr2, ptr1, ptr2 - ptr1);
}

/*----------------------------------------------------------------------------*/
/*============================================================================*/

６４ビットＷｉｎｄｏｗｓ環境で、新しいデータ型の使用は恩恵をもたらすのか（誰に）？

微禄
(2021年3月 7日 11:10) |

６４ビット化擬きの真似事の続きです。６４ビットＷｉｎｄｏｗｓ環境で、「固定精度整数型」「ポインター精度整数型」「固定精度ポインター型」を含めたデータサイズをチェックするだけのサンプルを作ってみました。

★POINTER_32、POINTER_64 型は、有効に活用できる場面があるのか思い当たりませんが・・・。


＜注意点＞

・［再出］ボイド型ポインタ（void *、別名汎用ポインタ）の参照先変数への読み書きは出来ません。⇒「error C2100: 間接指定演算子 (*) の使い方が正しくありません。」

・［再出］マイクロソフトのドキュメントでは、HWND、HINSTANCE、HDC の３つともボイド型ポインタだろうと思うのですが、コンパイルエラーはそうではないと言っているようです（永遠にお手上げ？）。


【データモデルについて】

short や int やlong のデータサイズ、そしてポインタのサイズなどを、コンパイラ（やＯＳ）の抽象化データモデルと呼ぶそうです。データモデルが変わるとデータサイズも必然的に変わってきます。

３２ビットシステムでは一般的に、int, long, pointer のサイズが４バイトである事を示すＩＬＰ３２を採用しています。６４ビットシステムではデータモデルが同一では無く、Ｗｉｎｄｏｗｓの場合はＩＬ３２Ｐ６４（単にＰ６４とも）と表現されるモデルを採用しています。

個人的には、Ｕｎｉｘ系のＬＰ６４モデルを好ましく思いますが、一部にはＩＬＰ６４モデルも存在します。int と long の２つ、無駄な感じがします。

Ｃコンパイラのデータモデル（ビット数）
データモデルcharshortintlonglong longpointer
Ｃ＋＋標準 　－　 １６以上 １６以上 ３２以上 ６４以上 　－　
ＩＬＰ３２（Ｗｉｎ３２） *1 ８ １６ ３２ ３２ ６４ ３２
Ｐ６４（Ｗｉｎ６４） *2 ８ １６ ３２ ３２ ６４ ６４
ＬＰ６４（ｍａｃＯＳ） *3 ８ １６ ３２ ６４ ６４ ６４

　*1：一般的な３２ビット環境　*2：Ｗｉｎｄｏｗｓ６４ビット環境でＬＬＰ６４とも
　*3：Ｕｎｉｘ系全般


【６４ビットＷｉｎｄｏｗｓ環境のデータ型一覧】

基本型
タイプ定義データ幅ポインタ幅
char ‐ １バイト ８バイト
short ‐ ２バイト ８バイト
int ‐ ４バイト ８バイト
long ‐ ４バイト ８バイト

　「long long」型は不使用が良いかと

固定精度整数型
タイプ定義データ幅ポインタ幅
DWORD32 ３２ビット符号無し整数 ４バイト ８バイト
DWORD64 ６４ビット符号無し整数 ８バイト ８バイト
INT32 ３２ビット符号付き整数 ４バイト ８バイト
UINT32 ３２ビット符号無し整数 ４バイト ８バイト
INT64 ６４ビット符号付き整数 ８バイト ８バイト
UINT64 ６４ビット符号無し整数 ８バイト ８バイト
LONG32 ３２ビット符号付き整数 ４バイト ８バイト
ULONG32 ３２ビット符号無し整数 ４バイト ８バイト
LONG64 ６４ビット符号付き整数 ８バイト ８バイト
ULONG64 ６４ビット符号無し整数 ８バイト ８バイト

　

ポインタ精度整数型
タイプ定義データ幅ポインタ幅
DWORD_PTR ポインタ有効ビット数の符号無し整数 ８バイト ８バイト
INT_PTR ポインタ有効ビット数の符号付き整数 ８バイト ８バイト
UINT_PTR ポインタ有効ビット数の符号無し整数 ８バイト ８バイト
LONG_PTR ポインタ有効ビット数の符号付き整数 ８バイト ８バイト
ULONG_PTR ポインタ有効ビット数の符号無し整数 ８バイト ８バイト
SIZE_T ポインタが参照できる符号無し最大バイト数 *1 ８バイト ８バイト
SSIZE_T ポインタが参照できる符号付き最大バイト数 *1 ８バイト ８バイト
HALF_PTR ポインタ有効ビット数半分の符号付き整数 *2 ４バイト ８バイト
UHALF_PTR ポインタ有効ビット数半分の符号無し整数 *2 ４バイト ８バイト

　*1：ポインタの範囲全体にまたがる必要があるカウントに使用。
　*2：３２ビットシステムでは１６ビット、６４ビットシステムでは３２ビット。

文字列型
タイプ定義データ幅ポインタ幅
PSTR １バイト文字列のポインタ １バイト ８バイト
LPSTR １バイト文字列のポインタ １バイト ８バイト
PCSTR １バイト文字列のポインタ １バイト ８バイト
LPCSTR １バイト文字列のポインタ １バイト ８バイト
PWSTR ２バイト文字列のポインタ *1 ２バイト ８バイト
LPWSTR ２バイト文字列のポインタ *1 ２バイト ８バイト
PCWSTR ２バイト文字列のポインタ *1 ２バイト ８バイト
LPCWSTR ２バイト文字列のポインタ *1 ２バイト ８バイト
PTSTR １バイト文字列のポインタ １バイト ８バイト
LPTSTR １バイト文字列のポインタ １バイト ８バイト
PCTSTR １バイト文字列のポインタ １バイト ８バイト
LPCTSTR １バイト文字列のポインタ １バイト ８バイト

　*1：ＵＮＩＣＯＤＥ文字列に対応。

ウインドウ型
タイプ定義データ幅ポインタ幅
LPARAM ポインタ有効ビット数の符号付き整数 ８バイト ８バイト
WPARAM ポインタ有効ビット数の符号付き整数 ８バイト ８バイト
LRESULT ポインタ有効ビット数の符号付き整数 ８バイト ８バイト
LPVOID ボイドのポインタ 無効 *1 ８バイト
HANDLE ボイドのポインタ 無効 *1 ８バイト
HWND ‐？‐ *2 無効？ ８バイト
HINSTANCE ‐？‐ *2 無効？ ８バイト
HDC ‐？‐ *2 無効？ ８バイト

　*1：アクセス不可を示す。
　*2：'HWND__' 'HINSTANCE__' 'HDC__' は、今のところ（永久に？）不明、アクセス不可？

固定精度ポインタ型
タイプ定義データ幅ポインタ幅
POINTER_32 ３２ビットポインタ *1 指定サイズ依存 ４バイト
POINTER_64 ６４ビットポインタ *2 指定サイズ依存 ８バイト

　*1：３２ビットシステムではネイティブポインタ、６４ビットシステムでは切り捨てられた６４ビットポインタ。
　*2：６４ビットシステムではネイティブポインタ、３２ビットシステムでは符号拡張３２ビットポインタ。


お試し環境
  WindowsXP 32bit Edition、Windows7 64bit Edition
  Visual C++ 2008 cross x64、native x64


/*---- ６４ビットデータ型確認 ----------------　コマンドライン　--------------*/

D:\vc2008\x86x64>cl test.c

/*----------------------------------------------------------------------------*/


/*--------------------------------　お試し結果　------------------------------*/

D:\vc2008\x86x64>test
基本型
sizeof(a) = 1, sizeof(char *) = 8, a = 0x12
sizeof(b) = 2, sizeof(short *) = 8, b = 0x1234
sizeof(c) = 4, sizeof(int *) = 8, c = 0x12345678
sizeof(d) = 4, sizeof(long *) = 8, d = 0x12345678

固定精度整数型
sizeof(f) = 4, sizeof(DWORD32 *) = 8, f = 0x12345678
sizeof(g) = 8, sizeof(DWORD64 *) = 8, g = 0x1234567890abcdef
sizeof(h) = 4, sizeof(INT32 *) = 8, h = 0x12345678
sizeof(i) = 4, sizeof(UINT32 *) = 8, i = 0x12345678
sizeof(j) = 8, sizeof(INT64 *) = 8, j = 0x1234567890abcd12
sizeof(k) = 8, sizeof(UINT64 *) = 8, k = 0x1234567812345678
sizeof(l) = 4, sizeof(LONG32 *) = 8, l = 0x12345678
sizeof(m) = 4, sizeof(ULONG32 *) = 8, m = 0x12345678
sizeof(n) = 8, sizeof(LONG64 *) = 8, n = 0x1234567890ab1234
sizeof(o) = 8, sizeof(ULONG64 *) = 8, o = 0x1234567812345678

ポインタ精度整数型
sizeof(p) = 8, sizeof(DWORD_PTR *) = 8, p = 0x1234567890abcdef
sizeof(q) = 8, sizeof(INT_PTR *) = 8, q = 0x1234567890abcdef
sizeof(r) = 8, sizeof(UINT_PTR *) = 8, r = 0x1234567890abcdef
sizeof(s) = 8, sizeof(LONG_PTR *) = 8, s = 0x1234567890abcdef
sizeof(t) = 8, sizeof(ULONG_PTR *) = 8, t = 0x1234567890abcdef
sizeof(u) = 8, sizeof(SIZE_T *) = 8, u = 0x1234567890abcdef
sizeof(v) = 8, sizeof(SSIZE_T *) = 8, v = 0x1234567890abcdef
sizeof(w) = 4, sizeof(HALF_PTR *) = 8, w = 0x12345678
sizeof(x) = 4, sizeof(UHALF_PTR *) = 8, x = 0x12345678

文字列型
sizeof(*sa) = 1, sizeof(PSTR) = 8, *sa = 1
sizeof(*sb) = 1, sizeof(LPSTR) = 8, *sb = 2
sizeof(*sc) = 1, sizeof(PCSTR) = 8, *sc = A
sizeof(*sd) = 1, sizeof(LPCSTR) = 8, *sd = A
sizeof(*se) = 2, sizeof(PWSTR) = 8, *se = 3
sizeof(*sf) = 2, sizeof(LPWSTR) = 8, *sf = 4
sizeof(*sg) = 2, sizeof(PCWSTR) = 8, *sg = A
sizeof(*sh) = 2, sizeof(LPCWSTR) = 8, *sh = A
sizeof(*si) = 1, sizeof(PTSTR) = 8, *si = 5
sizeof(*sj) = 1, sizeof(LPTSTR) = 8, *sj = 6
sizeof(*sk) = 1, sizeof(PCTSTR) = 8, *sk = A
sizeof(*sl) = 1, sizeof(LPCTSTR) = 8, *sl = A

ウインドウ型
sizeof(wa) = 8, sizeof(LPARAM *) = 8, wa = 0x1234567890abcdef
sizeof(wb) = 8, sizeof(WPARAM *) = 8, wb = 0x1234567890abcdef
sizeof(wc) = 8, sizeof(LRESULT *) = 8, wc = 0x1234567890abcdef
sizeof(wd) = 8, sizeof(LPVOID *) = 8
sizeof(we) = 8, sizeof(HANDLE *) = 8
sizeof(wf) = 8, sizeof(HWND *) = 8
sizeof(wg) = 8, sizeof(HINSTANCE *) = 8
sizeof(wh) = 8, sizeof(HDC *) = 8

固定精度ポインタ型
sizeof(ya) = 4, sizeof(char *) = 8, *ya = 0x12
sizeof(yb) = 4, sizeof(int *) = 8, *yb = 0x12345678
sizeof(yc) = 4, sizeof(void *) = 8
sizeof(za) = 8, sizeof(short *) = 8, *za = 0x1234
sizeof(zb) = 8, sizeof(long *) = 8, *zb = 0x12345678
sizeof(zc) = 8, sizeof(void *) = 8

/*----------------------------------------------------------------------------*/


/*---- test.c ------------------------　お試しソース　------------------------*/

#include <stdio.h>
#include <windows.h>

int main(int argc, char *argv[])
{
// 基本型
    char a = 0x12;
    short b = 0x1234;
    int c = 0x12345678;
    long d = 0x12345678;

// 固定精度整数型
    DWORD32 f = 0x12345678;
    DWORD64 g = 0x1234567890abcdef;
    INT32 h = 0x12345678;
    UINT32 i = 0x12345678;
    INT64 j = 0x1234567890abcdef;
    UINT64 k = 0x1234567890abcdef;
    LONG32 l = 0x12345678;
    ULONG32 m = 0x12345678;
    LONG64 n = 0x1234567890abcdef;
    ULONG64 o = 0x1234567890abcdef;

// ポインタ精度整数型
    DWORD_PTR p = 0x1234567890abcdef;
    INT_PTR q = 0x1234567890abcdef;
    UINT_PTR r = 0x1234567890abcdef;
    LONG_PTR s = 0x1234567890abcdef;
    ULONG_PTR t = 0x1234567890abcdef;
    SIZE_T u = 0x1234567890abcdef;
    SSIZE_T v = 0x1234567890abcdef;
    HALF_PTR w = 0x12345678;
    UHALF_PTR x = 0x12345678;

// 文字列型
    PSTR sa = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    LPSTR sb = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    PCSTR sc = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    LPCSTR sd = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    PWSTR se = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    LPWSTR sf = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    PCWSTR sg = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    LPCWSTR sh = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    PTSTR si = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    LPTSTR sj = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    PCTSTR sk = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    LPCTSTR sl = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

// ウインドウ型
    LPARAM wa = 0x1234567890abcdef;
    WPARAM wb = 0x1234567890abcdef;
    LRESULT wc = 0x1234567890abcdef;
    LPVOID wd = (LPVOID)0x1234567890abcdef;
    HANDLE we = (HANDLE)0x1234567890abcdef;
    HWND wf = (HWND)0x1234567890abcdef;
    HINSTANCE wg = (HINSTANCE)0x1234567890abcdef;
    HDC wh = (HDC)0x1234567890abcdef;

// 固定精度ポインタ型
    char *POINTER_32 ya = (char *)0x1234567890abcdef; // warning C4244: '初期化中' : 'char *' から 'char *' への変換です。データが失われる可能性があります。
    int *POINTER_32 yb = (int *)0x1234567890abcdef;  // warning C4244: '初期化中' : 'int *' から 'int *' への変換です。データが失われる可能性があります。
    void *POINTER_32 yc = (void *)0x1234567890abcdef; // warning C4244: '初期化中' : 'void *' から 'void *' への変換です。データが失われる可能性があります。
    short *POINTER_64 za = (short *)0x1234567890abcdef;
    long *POINTER_64 zb = (long *)0x1234567890abcdef;
    void *POINTER_64 zc = (void *)0x1234567890abcdef;


// ウインドウ型チェック
    wd = &p;
    we = &q;
    wf = (HWND)&r;
    wg = (HINSTANCE)&s;
    wh = (HDC)&t;

//  *wd = 0x11; error C2100: 間接指定演算子 (*) の使い方が正しくありません。warning C4047: '=' : 間接参照のレベルが 'LPVOID' と 'int' で異なっています。
//  *we = 0x22; error C2100: 間接指定演算子 (*) の使い方が正しくありません。warning C4047: '=' : 間接参照のレベルが 'HANDLE' と 'int' で異なっています。
//  *wf = 0x33; error C2440: '=' : 'int' から 'HWND__' に変換できません。
//  *wg = 0x44; error C2440: '=' : 'int' から 'HINSTANCE__' に変換できません。
//  *wh = 0x55; error C2440: '=' : 'int' から 'HDC__' に変換できません。

// 固定精度ポインタ型チェック
    ya = (char *)&j; // warning C4244: '=' : 'char *' から 'char *' への変換です。データが失われる可能性があります。
    yb = (int *)&k; // warning C4244: '=' : 'int *' から 'int *' への変換です。データが失われる可能性があります。
    yc = &g;  // warning C4244: '=' : 'DWORD64 *' から 'void *' への変換です。データが失われる可能性があります。
    za = (short *)&n;
    zb = (long *)&o;
    zc = &g;

    *ya = 0x12;  // warning C4826: 'char *' から 'char *' への変換は符号拡張されています。これは、予期しない実行時の動作を発生させる可能性があります。
    *yb = 0x12345678; // warning C4826: 'int *' から 'int *' への変換は符号拡張されています。これは、予期しない実行時の動作を発生させる可能性があります。
//  *yc = 0x1234567890abcdef; error C2100: 間接指定演算子 (*) の使い方が正しくありません。warning C4047: '=' : 間接参照のレベルが 'void *' と '__int64' で異なっています。
    *za = 0x1234;
    *zb = 0x12345678;
//  *zc = 0x1234567890abcdef; error C2100: 間接指定演算子 (*) の使い方が正しくありません。warning C4047: '=' : 間接参照のレベルが 'void *' と '__int64' で異なっています。

// 文字列型チェック
    *sa = '1';
    *sb = '2';
//  *sc = '3'; error C2166: 左辺値は const オブジェクトに指定されています。
//  *sd = '4'; error C2166: 左辺値は const オブジェクトに指定されています。
    *se = '3';
    *sf = '4';
//  *sg = '7'; error C2166: 左辺値は const オブジェクトに指定されています。
//  *sh = '8'; error C2166: 左辺値は const オブジェクトに指定されています。
    *si = '5';
    *sj = '6';
//  *sk = '1'; error C2166: 左辺値は const オブジェクトに指定されています。
//  *sl = '2'; error C2166: 左辺値は const オブジェクトに指定されています。


// 基本型データ出力
    printf("基本型\n");
    printf("sizeof(a) = %d, sizeof(char *) = %d, a = %#x\n", sizeof(a), sizeof(char *), a);
    printf("sizeof(b) = %d, sizeof(short *) = %d, b = %#x\n", sizeof(b), sizeof(short *), b);
    printf("sizeof(c) = %d, sizeof(int *) = %d, c = %#x\n", sizeof(c), sizeof(int *), c);
    printf("sizeof(d) = %d, sizeof(long *) = %d, d = %#x\n", sizeof(d), sizeof(long *), d);

// 固定精度整数型データ出力
    printf("\n固定精度整数型\n");
    printf("sizeof(f) = %d, sizeof(DWORD32 *) = %d, f = %#x\n", sizeof(f), sizeof(DWORD32 *), f);
    printf("sizeof(g) = %d, sizeof(DWORD64 *) = %d, g = %#llx\n", sizeof(g), sizeof(DWORD64 *), g);
    printf("sizeof(h) = %d, sizeof(INT32 *) = %d, h = %#x\n", sizeof(h), sizeof(INT32 *), h);
    printf("sizeof(i) = %d, sizeof(UINT32 *) = %d, i = %#x\n", sizeof(i), sizeof(UINT32 *), i);
    printf("sizeof(j) = %d, sizeof(INT64 *) = %d, j = %#llx\n", sizeof(j), sizeof(INT64 *), j);
    printf("sizeof(k) = %d, sizeof(UINT64 *) = %d, k = %#llx\n", sizeof(k), sizeof(UINT64 *), k);
    printf("sizeof(l) = %d, sizeof(LONG32 *) = %d, l = %#x\n", sizeof(l), sizeof(LONG32 *), l);
    printf("sizeof(m) = %d, sizeof(ULONG32 *) = %d, m = %#x\n", sizeof(m), sizeof(ULONG32 *), m);
    printf("sizeof(n) = %d, sizeof(LONG64 *) = %d, n = %#llx\n", sizeof(n), sizeof(LONG64 *), n);
    printf("sizeof(o) = %d, sizeof(ULONG64 *) = %d, o = %#llx\n", sizeof(o), sizeof(ULONG64 *), o);

// ポインタ精度整数型データ出力
    printf("\nポインタ精度整数型\n");
    printf("sizeof(p) = %d, sizeof(DWORD_PTR *) = %d, p = %#llx\n", sizeof(p), sizeof(DWORD_PTR *), p);
    printf("sizeof(q) = %d, sizeof(INT_PTR *) = %d, q = %#llx\n", sizeof(q), sizeof(INT_PTR *), q);
    printf("sizeof(r) = %d, sizeof(UINT_PTR *) = %d, r = %#llx\n", sizeof(r), sizeof(UINT_PTR *), r);
    printf("sizeof(s) = %d, sizeof(LONG_PTR *) = %d, s = %#llx\n", sizeof(s), sizeof(LONG_PTR *), s);
    printf("sizeof(t) = %d, sizeof(ULONG_PTR *) = %d, t = %#llx\n", sizeof(t), sizeof(ULONG_PTR *), t);
    printf("sizeof(u) = %d, sizeof(SIZE_T *) = %d, u = %#llx\n", sizeof(u), sizeof(SIZE_T *), u);
    printf("sizeof(v) = %d, sizeof(SSIZE_T *) = %d, v = %#llx\n", sizeof(v), sizeof(SSIZE_T *), v);
    printf("sizeof(w) = %d, sizeof(HALF_PTR *) = %d, w = %#x\n", sizeof(w), sizeof(HALF_PTR *), w);
    printf("sizeof(x) = %d, sizeof(UHALF_PTR *) = %d, x = %#x\n", sizeof(x), sizeof(UHALF_PTR *), x);

// 文字列型データ出力
    printf("\n文字列型\n");
    printf("sizeof(*sa) = %d, sizeof(PSTR) = %d, *sa = %c\n", sizeof(*sa), sizeof(PSTR), *sa);
    printf("sizeof(*sb) = %d, sizeof(LPSTR) = %d, *sb = %c\n", sizeof(*sb), sizeof(LPSTR), *sb);
    printf("sizeof(*sc) = %d, sizeof(PCSTR) = %d, *sc = %c\n", sizeof(*sc), sizeof(PCSTR), *sc);
    printf("sizeof(*sd) = %d, sizeof(LPCSTR) = %d, *sd = %c\n", sizeof(*sd), sizeof(LPCSTR), *sd);
    printf("sizeof(*se) = %d, sizeof(PWSTR) = %d, *se = %c\n", sizeof(*se), sizeof(PWSTR), *se);
    printf("sizeof(*sf) = %d, sizeof(LPWSTR) = %d, *sf = %c\n", sizeof(*sf), sizeof(LPWSTR), *sf);
    printf("sizeof(*sg) = %d, sizeof(PCWSTR) = %d, *sg = %c\n", sizeof(*sg), sizeof(PCWSTR), *sg);
    printf("sizeof(*sh) = %d, sizeof(LPCWSTR) = %d, *sh = %c\n", sizeof(*sh), sizeof(LPCWSTR), *sh);
    printf("sizeof(*si) = %d, sizeof(PTSTR) = %d, *si = %c\n", sizeof(*si), sizeof(PTSTR), *si);
    printf("sizeof(*sj) = %d, sizeof(LPTSTR) = %d, *sj = %c\n", sizeof(*sj), sizeof(LPTSTR), *sj);
    printf("sizeof(*sk) = %d, sizeof(PCTSTR) = %d, *sk = %c\n", sizeof(*sk), sizeof(PCTSTR), *sk);
    printf("sizeof(*sl) = %d, sizeof(LPCTSTR) = %d, *sl = %c\n", sizeof(*sl), sizeof(LPCTSTR), *sl);

// ウインドウ型データ出力
    printf("\nウインドウ型\n");
    printf("sizeof(wa) = %d, sizeof(LPARAM *) = %d, wa = %#llx\n", sizeof(wa), sizeof(LPARAM *), wa);
    printf("sizeof(wb) = %d, sizeof(WPARAM *) = %d, wb = %#llx\n", sizeof(wb), sizeof(WPARAM *), wb);
    printf("sizeof(wc) = %d, sizeof(LRESULT *) = %d, wc = %#llx\n", sizeof(wc), sizeof(LRESULT *), wc);
    printf("sizeof(wd) = %d, sizeof(LPVOID *) = %d\n", sizeof(wd), sizeof(LPVOID *));
    printf("sizeof(we) = %d, sizeof(HANDLE *) = %d\n", sizeof(we), sizeof(HANDLE *));
    printf("sizeof(wf) = %d, sizeof(HWND *) = %d\n", sizeof(wf), sizeof(HWND *));
    printf("sizeof(wg) = %d, sizeof(HINSTANCE *) = %d\n", sizeof(wg), sizeof(HINSTANCE *));
    printf("sizeof(wh) = %d, sizeof(HDC *) = %d\n", sizeof(wh), sizeof(HDC *));

// 固定精度ポインタ型データ出力
    printf("\n固定精度ポインタ型\n");
    printf("sizeof(ya) = %d, sizeof(char *) = %d, *ya = %#x\n", sizeof(ya), sizeof(char *), *ya); // warning C4826: 'char *' から 'char *' への変換は符号拡張されています。これは、予期しない実行時の動作を発生させる可能性があります。
    printf("sizeof(yb) = %d, sizeof(int *) = %d, *yb = %#x\n", sizeof(yb), sizeof(int *), *yb);  // warning C4826: 'int *' から 'int *' への変換は符号拡張されています。これは、予期しない実行時の動作を発生させる可能性があります。
//  printf("sizeof(yc) = %d, sizeof(void *) = %d, *yc = %d\n", sizeof(yc), sizeof(void *), *yc); error C2100: 間接指定演算子 (*) の使い方が正しくありません。
    printf("sizeof(yc) = %d, sizeof(void *) = %d\n", sizeof(yc), sizeof(void *));
    printf("sizeof(za) = %d, sizeof(short *) = %d, *za = %#x\n", sizeof(za), sizeof(short *), *za);
    printf("sizeof(zb) = %d, sizeof(long *) = %d, *zb = %#x\n", sizeof(zb), sizeof(long *), *zb);
//  printf("sizeof(zc) = %d, sizeof(void *) = %d, *zc = %d\n", sizeof(zc), sizeof(void *), *zc); error C2100: 間接指定演算子 (*) の使い方が正しくありません。
    printf("sizeof(zc) = %d, sizeof(void *) = %d\n", sizeof(zc), sizeof(void *));

    return(0);
}

/*----------------------------------------------------------------------------*/
/*============================================================================*/

« ＶＢ２００８ | メインページ | アーカイブ | Ｗｉｎｄｏｗｓ »

検索

このアーカイブについて

このページには、過去に書かれたブログ記事のうちＶＣ＋＋２００８ｘ６４カテゴリに属しているものが含まれています。

前のカテゴリはＶＢ２００８です。

次のカテゴリはＷｉｎｄｏｗｓです。

最近のコンテンツはインデックスページで見られます。過去に書かれたものはアーカイブのページで見られます。

ＶＣ＋＋２００８ｘ６４: 2021年3月: 月別アーカイブ

カテゴリ

月別 アーカイブ

ウェブページ

お気に入りリンク

ＮＯＰ法人 アジアチャイルドサポート 最も大切なボランティアは、自分自身が一生懸命に生きること