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

微禄
(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月 7日 11:10に書いたブログ記事です。

ひとつ前のブログ記事は「３２ビットＷｉｎｄｏｗｓ環境で、新しいデータ型の使用はプログラムの安全性（堅牢性）を図れるのか？」です。

次のブログ記事は「３２ビットプログラムの６４ビット化に関する問題点を拾ってみる」です。

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

カテゴリ

月別 アーカイブ

ウェブページ

お気に入りリンク

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