我也是一个c语言初学者，抽业余时间学习C语言；有兴趣的同学可以来交流一下，互相学习，相互促进。
首先来看window窗口的绘制属性的设置。

const int WINDOW_STYLES = WS_OVERLAPPED | WS_SYSMENU | WS_CAPTION | WS_MINIMIZEBOX;

以上句子设置了一个常数WINDOW_STYLES；
这个常数通过------或运算，计算后，就被初始化了。
以下是后面这些常量的含义。
WS_OVERLAPPED   产生一个层叠的窗口；一个层叠的窗口有一个标题条和一个边框。
WS_SYSMENU 创建一个在标题条上带有窗口菜单的窗口，必须同时设定WS_CAPTION风格。
WS_CAPTION 创建一个有标题框的窗口（包括WS_BORDER风格）。
WS_MINIMIZEBOX 创建一个具有最大化按钮的窗口；该风格不能与WS_EX_CONTEXTHELP风格同时出现，同时必须指定WS_SYSMENU风格。

对于一个初学者，也没有必要看长篇大论，基于自己的水平，做细节上的消化；
象棋小巫师第一阶段cpp源码，在3楼；所有源码在8楼下载；
第一阶段代码的分析，共14小节；
我打算分析完所有，大家共同来探索人工智能的奥秘吧！

[此贴子已经被作者于2016-3-27 12:11编辑过]

C语言从零起步分析《象眼》象棋引擎的源码(2)
窗口的创建过程：
1注册窗口类
2构建窗口
3显示窗口

注册窗口类：
RegisterClassEx  为(随后在调用Createwindow函数中使用的)窗口---注册一个窗口类；
ATOM RegisterClassEx（CONST WNDCLASSEX *Ipwcx）；
ATOM RegisterClassEx（指向窗口类的指针）；

窗口的创建：CreateWindow

jubing = CreateWindow("XQWLIGHT", "象棋小巫师", WINDOW_STYLES,
      CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
      CW_USEDEFAULT, NULL, NULL, hInstance, NULL);

绿色的WINDOW_STYLES上一节的常量
  CW_USEDEFAULT是指窗口的大小位置等位默认值；

jubing = CreateWindow(窗口类名称,窗口标题, 窗口格式风格,
      初始 x 坐标, 初始 y 坐标, 宽,
      高, 父窗口句柄, 窗口菜单句柄, 程序实例句柄, 创建参数);

显示窗口：
ShowWindow(jubing, nCmdShow)
ShowWindow(窗口句柄,指定窗口如何显示);
参数nCmdShow----第一次调用ShowWindow函数时，该值应为在函数WinMain中nCmdShow参数;

本节分析了基本的创建窗口的粗略过程；

/**

 * XiangQi Wizard Light - A Very Simple Chinese Chess Program

 * Designed by Morning Yellow, Version: 0.1, Last Modified: Mar. 2008

 * Copyright (C) 2004-2008 www.*

 * 象棋小巫师 0.1 的目标：

 * 一、制作一个可操作的图形界面。

 */

#include <windows.h>
#include "resource.h"

// 版本号
const LPCSTR cszAbout = "象棋小巫师 0.1\n象棋百科全书 荣誉出品\n\n"
    "欢迎登录 www.\n免费下载PC版 象棋巫师";

// 窗口和绘图属性
const int WINDOW_STYLES = WS_OVERLAPPED | WS_SYSMENU | WS_CAPTION | WS_MINIMIZEBOX;
const int MASK_COLOR = RGB(0, 255, 0);
const int SQUARE_SIZE = 56;
const int BOARD_EDGE = 8;
const int BOARD_WIDTH = BOARD_EDGE + SQUARE_SIZE * 9 + BOARD_EDGE;
const int BOARD_HEIGHT = BOARD_EDGE + SQUARE_SIZE * 10 + BOARD_EDGE;

// 棋盘范围
const int RANK_TOP = 3;
const int RANK_BOTTOM = 12;
const int FILE_LEFT = 3;
const int FILE_RIGHT = 11;

// 棋子编号
const int PIECE_KING = 0;
const int PIECE_ADVISOR = 1;
const int PIECE_BISHOP = 2;
const int PIECE_KNIGHT = 3;
const int PIECE_ROOK = 4;
const int PIECE_CANNON = 5;
const int PIECE_PAWN = 6;

// 棋盘初始设置
static const BYTE cucpcStartup[256] = {
  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  0,  0,  0, 20, 19, 18, 17, 16, 17, 18, 19, 20,  0,  0,  0,  0,
  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  0,  0,  0,  0, 21,  0,  0,  0,  0,  0, 21,  0,  0,  0,  0,  0,
  0,  0,  0, 22,  0, 22,  0, 22,  0, 22,  0, 22,  0,  0,  0,  0,
  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  0,  0,  0, 14,  0, 14,  0, 14,  0, 14,  0, 14,  0,  0,  0,  0,
  0,  0,  0,  0, 13,  0,  0,  0,  0,  0, 13,  0,  0,  0,  0,  0,
  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  0,  0,  0, 12, 11, 10,  9,  8,  9, 10, 11, 12,  0,  0,  0,  0,
  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0
};

// 获得格子的横坐标
inline int RANK_Y(int sq) {
  return sq >> 4;
}

// 获得格子的纵坐标
inline int FILE_X(int sq) {
  return sq & 15;
}

// 根据纵坐标和横坐标获得格子
inline int COORD_XY(int x, int y) {
  return x + (y << 4);
}

// 翻转格子
inline int SQUARE_FLIP(int sq) {
  return 254 - sq;
}

// 纵坐标水平镜像
inline int FILE_FLIP(int x) {
  return 14 - x;
}

// 横坐标垂直镜像
inline int RANK_FLIP(int y) {
  return 15 - y;
}

// 获得红黑标记(红子是8，黑子是16)
inline int SIDE_TAG(int sd) {
  return 8 + (sd << 3);
}

// 获得对方红黑标记
inline int OPP_SIDE_TAG(int sd) {
  return 16 - (sd << 3);
}

// 获得走法的起点
inline int SRC(int mv) {
  return mv & 255;
}

// 获得走法的终点
inline int DST(int mv) {
  return mv >> 8;
}

// 根据起点和终点获得走法
inline int MOVE(int sqSrc, int sqDst) {
  return sqSrc + sqDst * 256;
}

// 局面结构
struct PositionStruct {
  int sdPlayer;                   // 轮到谁走，0=红方，1=黑方
  BYTE ucpcSquares[256];          // 棋盘上的棋子

  void Startup(void) {            // 初始化棋盘
    sdPlayer = 0;
    memcpy(ucpcSquares, cucpcStartup, 256);
  }
  void ChangeSide(void) {         // 交换走子方
    sdPlayer = 1 - sdPlayer;
  }
  void AddPiece(int sq, int pc) { // 在棋盘上放一枚棋子
    ucpcSquares[sq] = pc;
  }
  void DelPiece(int sq) {         // 从棋盘上拿走一枚棋子
    ucpcSquares[sq] = 0;
  }
  void MovePiece(int mv);         // 搬一步棋的棋子
  void MakeMove(int mv) {         // 走一步棋
    MovePiece(mv);
    ChangeSide();
  }
};

// 搬一步棋的棋子
void PositionStruct::MovePiece(int mv) {
  int sqSrc, sqDst, pc;
  sqSrc = SRC(mv);
  sqDst = DST(mv);
  DelPiece(sqDst);
  pc = ucpcSquares[sqSrc];
  DelPiece(sqSrc);
  AddPiece(sqDst, pc);
}

static PositionStruct pos; // 局面实例

// 与图形界面有关的全局变量
static struct {
  HINSTANCE hInst;                              // 应用程序句柄实例
  HWND hWnd;                                    // 主窗口句柄
  HDC hdc, hdcTmp;                              // 设备句柄，只在"ClickSquare"过程中有效
  HBITMAP bmpBoard, bmpSelected, bmpPieces[24]; // 资源图片句柄
  int sqSelected, mvLast;                       // 选中的格子，上一步棋
  BOOL bFlipped;                                // 是否翻转棋盘
} Xqwl;

// TransparentBlt 的替代函数，用来修正原函数在 Windows 98 下资源泄漏的问题
static void TransparentBlt2(HDC hdcDest, int nXOriginDest, int nYOriginDest, int nWidthDest, int nHeightDest,
    HDC hdcSrc, int nXOriginSrc, int nYOriginSrc, int nWidthSrc, int nHeightSrc, UINT crTransparent) {
  HDC hImageDC, hMaskDC;
  HBITMAP hOldImageBMP, hImageBMP, hOldMaskBMP, hMaskBMP;

  hImageBMP = CreateCompatibleBitmap(hdcDest, nWidthDest, nHeightDest);
  hMaskBMP = CreateBitmap(nWidthDest, nHeightDest, 1, 1, NULL);
  hImageDC = CreateCompatibleDC(hdcDest);
  hMaskDC = CreateCompatibleDC(hdcDest);
  hOldImageBMP = (HBITMAP) SelectObject(hImageDC, hImageBMP);
  hOldMaskBMP = (HBITMAP) SelectObject(hMaskDC, hMaskBMP);

  if (nWidthDest == nWidthSrc && nHeightDest == nHeightSrc) {
    BitBlt(hImageDC, 0, 0, nWidthDest, nHeightDest,
        hdcSrc, nXOriginSrc, nYOriginSrc, SRCCOPY);
  } else {
    StretchBlt(hImageDC, 0, 0, nWidthDest, nHeightDest,
        hdcSrc, nXOriginSrc, nYOriginSrc, nWidthSrc, nHeightSrc, SRCCOPY);
  }
  SetBkColor(hImageDC, crTransparent);
  BitBlt(hMaskDC, 0, 0, nWidthDest, nHeightDest, hImageDC, 0, 0, SRCCOPY);
  SetBkColor(hImageDC, RGB(0,0,0));
  SetTextColor(hImageDC, RGB(255,255,255));
  BitBlt(hImageDC, 0, 0, nWidthDest, nHeightDest, hMaskDC, 0, 0, SRCAND);
  SetBkColor(hdcDest, RGB(255,255,255));
  SetTextColor(hdcDest, RGB(0,0,0));
  BitBlt(hdcDest, nXOriginDest, nYOriginDest, nWidthDest, nHeightDest,
      hMaskDC, 0, 0, SRCAND);
  BitBlt(hdcDest, nXOriginDest, nYOriginDest, nWidthDest, nHeightDest,
      hImageDC, 0, 0, SRCPAINT);

  SelectObject(hImageDC, hOldImageBMP);
  DeleteDC(hImageDC);
  SelectObject(hMaskDC, hOldMaskBMP);
  DeleteDC(hMaskDC);
  DeleteObject(hImageBMP);
  DeleteObject(hMaskBMP);
}

// 绘制透明图片
inline void DrawTransBmp(HDC hdc, HDC hdcTmp, int xx, int yy, HBITMAP bmp) {
  SelectObject(hdcTmp, bmp);
  TransparentBlt2(hdc, xx, yy, SQUARE_SIZE, SQUARE_SIZE, hdcTmp, 0, 0, SQUARE_SIZE, SQUARE_SIZE, MASK_COLOR);
}

// 绘制棋盘
static void DrawBoard(HDC hdc) {
  int x, y, xx, yy, sq, pc;
  HDC hdcTmp;

  // 画棋盘
  hdcTmp = CreateCompatibleDC(hdc);
  SelectObject(hdcTmp, Xqwl.bmpBoard);
  BitBlt(hdc, 0, 0, BOARD_WIDTH, BOARD_HEIGHT, hdcTmp, 0, 0, SRCCOPY);
  // 画棋子
  for (x = FILE_LEFT; x <= FILE_RIGHT; x ++) {
    for (y = RANK_TOP; y <= RANK_BOTTOM; y ++) {
      if (Xqwl.bFlipped) {
        xx = BOARD_EDGE + (FILE_FLIP(x) - FILE_LEFT) * SQUARE_SIZE;
        yy = BOARD_EDGE + (RANK_FLIP(y) - RANK_TOP) * SQUARE_SIZE;
      } else {
        xx = BOARD_EDGE + (x - FILE_LEFT) * SQUARE_SIZE;
        yy = BOARD_EDGE + (y - RANK_TOP) * SQUARE_SIZE;
      }
      sq = COORD_XY(x, y);
      pc = pos.ucpcSquares[sq];
      if (pc != 0) {
        DrawTransBmp(hdc, hdcTmp, xx, yy, Xqwl.bmpPieces[pc]);
      }
      if (sq == Xqwl.sqSelected || sq == SRC(Xqwl.mvLast) || sq == DST(Xqwl.mvLast)) {
        DrawTransBmp(hdc, hdcTmp, xx, yy, Xqwl.bmpSelected);
      }
    }
  }
  DeleteDC(hdcTmp);
}

// 播放资源声音
inline void PlayResWav(int nResId) {
  PlaySound(MAKEINTRESOURCE(nResId), Xqwl.hInst, SND_ASYNC | SND_NOWAIT | SND_RESOURCE);
}

// "DrawSquare"参数
const BOOL DRAW_SELECTED = TRUE;

// 绘制格子
static void DrawSquare(int sq, BOOL bSelected = FALSE) {
  int sqFlipped, xx, yy, pc;

  sqFlipped = Xqwl.bFlipped ? SQUARE_FLIP(sq) : sq;
  xx = BOARD_EDGE + (FILE_X(sqFlipped) - FILE_LEFT) * SQUARE_SIZE;
  yy = BOARD_EDGE + (RANK_Y(sqFlipped) - RANK_TOP) * SQUARE_SIZE;
  SelectObject(Xqwl.hdcTmp, Xqwl.bmpBoard);
  BitBlt(Xqwl.hdc, xx, yy, SQUARE_SIZE, SQUARE_SIZE, Xqwl.hdcTmp, xx, yy, SRCCOPY);
  pc = pos.ucpcSquares[sq];
  if (pc != 0) {
    DrawTransBmp(Xqwl.hdc, Xqwl.hdcTmp, xx, yy, Xqwl.bmpPieces[pc]);
  }
  if (bSelected) {
    DrawTransBmp(Xqwl.hdc, Xqwl.hdcTmp, xx, yy, Xqwl.bmpSelected);
  }
}

// 点击格子事件处理
static void ClickSquare(int sq) {
  int pc;
  Xqwl.hdc = GetDC(Xqwl.hWnd);
  Xqwl.hdcTmp = CreateCompatibleDC(Xqwl.hdc);
  sq = Xqwl.bFlipped ? SQUARE_FLIP(sq) : sq;
  pc = pos.ucpcSquares[sq];

  if ((pc & SIDE_TAG(pos.sdPlayer)) != 0) {
    // 如果点击自己的子，那么直接选中该子
    if (Xqwl.sqSelected != 0) {
      DrawSquare(Xqwl.sqSelected);
    }
    Xqwl.sqSelected = sq;
    DrawSquare(sq, DRAW_SELECTED);
    if (Xqwl.mvLast != 0) {
      DrawSquare(SRC(Xqwl.mvLast));
      DrawSquare(DST(Xqwl.mvLast));
    }
    PlayResWav(IDR_CLICK); // 播放点击的声音

  } else if (Xqwl.sqSelected != 0) {
    // 如果点击的不是自己的子，但有子选中了(一定是自己的子)，那么走这个子
    Xqwl.mvLast = MOVE(Xqwl.sqSelected, sq);
    pos.MakeMove(Xqwl.mvLast);
    DrawSquare(Xqwl.sqSelected, DRAW_SELECTED);
    DrawSquare(sq, DRAW_SELECTED);
    Xqwl.sqSelected = 0;
    PlayResWav(pc == 0 ? IDR_MOVE : IDR_CAPTURE); // 播放走子或吃子的声音
  }
  DeleteDC(Xqwl.hdcTmp);
  ReleaseDC(Xqwl.hWnd, Xqwl.hdc);
}

// 初始化棋局
static void Startup(void) {
  pos.Startup();
  Xqwl.sqSelected = Xqwl.mvLast = 0;
}

// 窗体事件捕捉过程
static LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
  int x, y;
  HDC hdc;
  RECT rect;
  PAINTSTRUCT ps;
  MSGBOXPARAMS mbp;

  switch (uMsg) {
  // 新建窗口
  case WM_CREATE:
    // 调整窗口位置和尺寸
    GetWindowRect(hWnd, &rect);
    x = rect.left;
    y = rect.top;
    rect.right = rect.left + BOARD_WIDTH;
    rect.bottom = rect.top + BOARD_HEIGHT;
    AdjustWindowRect(&rect, WINDOW_STYLES, TRUE);
    MoveWindow(hWnd, x, y, rect.right - rect.left, rect.bottom - rect.top, TRUE);
    break;
  // 退出
  case WM_DESTROY:
    PostQuitMessage(0);
    break;
  // 菜单命令
  case WM_COMMAND:
    switch (LOWORD(wParam)) {
    case IDM_FILE_RED:
    case IDM_FILE_BLACK:
      Xqwl.bFlipped = (LOWORD(wParam) == IDM_FILE_BLACK);
      Startup();
      hdc = GetDC(Xqwl.hWnd);
      DrawBoard(hdc);
      ReleaseDC(Xqwl.hWnd, hdc);
      break;
    case IDM_FILE_EXIT:
      DestroyWindow(Xqwl.hWnd);
      break;
    case IDM_HELP_HOME:
      ShellExecute(NULL, NULL, "http://www.", NULL, NULL, SW_SHOWNORMAL);
      break;
    case IDM_HELP_ABOUT:
      // 弹出带象棋小巫师图标的对话框
      MessageBeep(MB_ICONINFORMATION);
      mbp.cbSize = sizeof(MSGBOXPARAMS);
      mbp.hwndOwner = hWnd;
      mbp.hInstance = Xqwl.hInst;
      mbp.lpszText = cszAbout;
      mbp.lpszCaption = "关于象棋小巫师";
      mbp.dwStyle = MB_USERICON;
      mbp.lpszIcon = MAKEINTRESOURCE(IDI_APPICON);
      mbp.dwContextHelpId = 0;
      mbp.lpfnMsgBoxCallback = NULL;
      mbp.dwLanguageId = 0;
      MessageBoxIndirect(&mbp);
      break;
    }
    break;
  // 绘图
  case WM_PAINT:
    hdc = BeginPaint(Xqwl.hWnd, &ps);
    DrawBoard(hdc);
    EndPaint(Xqwl.hWnd, &ps);
    break;
  // 鼠标点击
  case WM_LBUTTONDOWN:
    x = FILE_LEFT + (LOWORD(lParam) - BOARD_EDGE) / SQUARE_SIZE;
    y = RANK_TOP + (HIWORD(lParam) - BOARD_EDGE) / SQUARE_SIZE;
    if (x >= FILE_LEFT && x <= FILE_RIGHT && y >= RANK_TOP && y <= RANK_BOTTOM) {
      ClickSquare(COORD_XY(x, y));
    }
    break;
  // 其他事件
  default:
    return DefWindowProc(hWnd, uMsg, wParam, lParam);
  }
  return FALSE;
}

// 装入资源图片
inline HBITMAP LoadResBmp(int nResId) {
  return (HBITMAP) LoadImage(Xqwl.hInst, MAKEINTRESOURCE(nResId), IMAGE_BITMAP, 0, 0, LR_DEFAULTSIZE | LR_SHARED);
}

// 入口过程
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
  int i;
  MSG msg;
  WNDCLASSEX wce;

  // 初始化全局变量
  Xqwl.hInst = hInstance;
  Xqwl.bFlipped = FALSE;
  Startup();

  // 装入图片
  Xqwl.bmpBoard = LoadResBmp(IDB_BOARD);
  Xqwl.bmpSelected = LoadResBmp(IDB_SELECTED);
  for (i = PIECE_KING; i <= PIECE_PAWN; i ++) {
    Xqwl.bmpPieces[SIDE_TAG(0) + i] = LoadResBmp(IDB_RK + i);
    Xqwl.bmpPieces[SIDE_TAG(1) + i] = LoadResBmp(IDB_BK + i);
  }

  // 设置窗口
  wce.cbSize = sizeof(WNDCLASSEX);
  wce.style = 0;
  wce.lpfnWndProc = (WNDPROC) WndProc;
  wce.cbClsExtra = wce.cbWndExtra = 0;
  wce.hInstance = hInstance;
  wce.hIcon = (HICON) LoadImage(hInstance, MAKEINTRESOURCE(IDI_APPICON), IMAGE_ICON, 32, 32, LR_SHARED);
  wce.hCursor = (HCURSOR) LoadImage(NULL, IDC_ARROW, IMAGE_CURSOR, 0, 0, LR_DEFAULTSIZE | LR_SHARED);
  wce.hbrBackground = (HBRUSH) (COLOR_BTNFACE + 1);
  wce.lpszMenuName = MAKEINTRESOURCE(IDM_MAINMENU);
  wce.lpszClassName = "XQWLIGHT";
  wce.hIconSm = (HICON) LoadImage(hInstance, MAKEINTRESOURCE(IDI_APPICON), IMAGE_ICON, 16, 16, LR_SHARED);
  RegisterClassEx(&wce);

  // 打开窗口
  Xqwl.hWnd = CreateWindow("XQWLIGHT", "象棋小巫师", WINDOW_STYLES,
      CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, hInstance, NULL);
  if (Xqwl.hWnd == NULL) {
    return 0;
  }
  ShowWindow(Xqwl.hWnd, nCmdShow);
  UpdateWindow(Xqwl.hWnd);

  // 接收消息
  while (GetMessage(&msg, NULL, 0, 0)) {
    TranslateMessage(&msg);
    DispatchMessage(&msg);
  }
  return msg.wParam;
}

[此贴子已经被作者于2016-3-27 10:03编辑过]

窗口类结构体WNDCLASSEX：

结构体参数：
1--cbSize：   WNDCLASSEX 的大小,即结构体本身的大小；
2--style：从这个窗口类派生的窗口具有的风格；
3--lpfnWndProc：窗口处理函数的指针；
4--cbClsExtra：指定紧跟在窗口类结构后的附加字节数；
5--cbWndExtra：指定紧跟在窗口实例的附加字节数；
6--hInstance：模块的实例句柄；
7--hIcon：图标的句柄；
8--hCursor：光标的句柄；
9--hbrBackground：背景画刷的句柄；
10--lpszMenuName：指向菜单的指针；
11--lpszClassName：指向类名称的指针；
12--hIconSm：和窗口类关联的小图标；如果该值为NULL则把hIcon中的图标转换成大小合适的小图标；

这是象棋窗口类的设置代码：

  WNDCLASSEX wce;
// 设置窗口类
  wce.cbSize = sizeof(WNDCLASSEX);
  wce.style = 0;
  wce.lpfnWndProc = (WNDPROC) WndProc;// 窗体事件捕捉(窗口事件将触发这个函数)
  wce.cbClsExtra = wce.cbWndExtra = 0;
  wce.hInstance = hInstance;
  wce.hIcon = (HICON) LoadImage(hInstance, MAKEINTRESOURCE(IDI_APPICON), IMAGE_ICON, 32, 32, LR_SHARED);
  wce.hCursor = (HCURSOR) LoadImage(NULL, IDC_ARROW, IMAGE_CURSOR, 0, 0, LR_DEFAULTSIZE | LR_SHARED);
  wce.hbrBackground = (HBRUSH) (COLOR_BTNFACE + 1);
  wce.lpszMenuName = MAKEINTRESOURCE(IDM_MAINMENU);
  wce.lpszClassName = "XQWLIGHT";
  wce.hIconSm = (HICON) LoadImage(hInstance, MAKEINTRESOURCE(IDI_APPICON), IMAGE_ICON, 16, 16, LR_SHARED);
  RegisterClassEx(&wce);

当移动鼠标，按下鼠标，释放鼠标，按下键盘，释放键盘，等事件发生时；
操作系统将调用本程序中的回调函数-------lpfnWndProc：窗口处理函数的指针；
这个函数即wce.lpfnWndProc = (WNDPROC) WndProc;// 窗体事件捕捉(窗口事件将触发这个函数)；

这一节，分析了窗口类的设置

[此贴子已经被作者于2016-3-27 11:06编辑过]

因为，源码很长，所以，采用分块的方法，来消化；
把注册窗口类，这个过程，剪切掉，放入一个头文件中；
然后，仅使用一条语句，就可以调用它，加强了可读性，便于我们理解；
注册窗口类中的这个变量WNDCLASSEX wce，
是个传递参数的变量，仅仅使用1次，因此完全可以把它放入函数内部；

剪切并稍微修改后的代码是这个样子的：

//ATOM MyRegisterClass(HINSTANCE hInstance);
ATOM MyRegisterClass(HINSTANCE hInstance)
{
  WNDCLASSEX wce;
  wce.cbSize = sizeof(WNDCLASSEX);
  wce.style = 0;
  wce.lpfnWndProc = (WNDPROC) WndProc;
  wce.cbClsExtra = wce.cbWndExtra = 0;
  wce.hInstance = hInstance;
  wce.hIcon = (HICON) LoadImage(hInstance, MAKEINTRESOURCE(IDI_APPICON), IMAGE_ICON, 32, 32, LR_SHARED);
  wce.hCursor = (HCURSOR) LoadImage(NULL, IDC_ARROW, IMAGE_CURSOR, 0, 0, LR_DEFAULTSIZE | LR_SHARED);
  wce.hbrBackground = (HBRUSH) (COLOR_BTNFACE + 1);
  wce.lpszMenuName = MAKEINTRESOURCE(IDM_MAINMENU);
  wce.lpszClassName = "XQWLIGHT";
  wce.hIconSm = (HICON) LoadImage(hInstance, MAKEINTRESOURCE(IDI_APPICON), IMAGE_ICON, 16, 16, LR_SHARED);
  return RegisterClassEx(&wce);
}

然后在使用时，就MyRegisterClass(hInstance);就可以了；

这一节，使用剪切法，来提高代码的可读性；

[此贴子已经被作者于2016-3-27 11:07编辑过]

大神，你不用1234了，直接上全部代码，告诉编译环境。

// 接收消息
  while (GetMessage(&msg, NULL, 0, 0)) {
    TranslateMessage(&msg);
    DispatchMessage(&msg);
  }

总之，这是一个消息循环；
GetMessage----接受消息
只接受自己的消息；而不接受其他线程或应用程序的消息；
从消息队列里取得一个消息并将其放于指定的结构(msg中)；
如果取得WM_QUIT之外的其他消息，返回非零值；
如果取得WM_QUIT消息，返回零；(即退出这个循环；)

TranslateMessage
将虚拟键消息转换为字符消息；
DispatchMessage
调度一个消息给窗体；
窗体将会调用----回调函数(WndProc)；

现在把主函数整理一下：
使用原有的句柄变量-------Xqwl.hWnd；
全局变量定义：

// 与图形界面有关的全局变量
static struct {
  HINSTANCE hInst;                              // 应用程序句柄实例
  HWND hWnd;                                    // 主窗口句柄
  HDC hdc, hdcTmp;                              // 设备句柄，只在"ClickSquare"过程中有效
  HBITMAP bmpBoard, bmpSelected, bmpPieces[24]; // 资源图片句柄
  int sqSelected, mvLast;                       // 选中的格子，上一步棋
  BOOL bFlipped;                                // 是否翻转棋盘
} Xqwl;

主函数：

int WINAPI WinMain(
                   HINSTANCE hInstance, 
                   HINSTANCE hPrevInstance, 
                   LPSTR lpCmdLine, 
                   int nCmdShow) 
{
  MSG msg;
  // 设置窗口,注册窗口类
  MyRegisterClass(hInstance);
  // 打开窗口
  Xqwl.hWnd = CreateWindow("XQWLIGHT", "象棋小巫师", WINDOW_STYLES,
      CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
      NULL, NULL, hInstance, NULL);
  if (Xqwl.hWnd == NULL) {return 0;}//如果建窗口失败就退出
  ShowWindow(Xqwl.hWnd, nCmdShow);//显示
  UpdateWindow(Xqwl.hWnd);//刷新
  // 接收消息-----主循环
  while (GetMessage(&msg, NULL, 0, 0)) {//取消息
    TranslateMessage(&msg);//转换为字符消息
    DispatchMessage(&msg);//把消息给窗体
  }
  return msg.wParam;
}

这一节，整理了主函数中的窗口构建，与消息循环；
主函数中，也只需要有这些内容；
关于画图和事件相应，都在回调函数(WndProc)中实现；

[此贴子已经被作者于2016-3-27 11:10编辑过]

这个源码共有6个开发阶段；
我使用的是VC6.0；当然其他的也行，如VS等；
在这个附件里下载吧

[此贴子已经被作者于2016-3-27 10:10编辑过]

回调函数(WndProc)
函数参数：
HWND hWnd, ---窗口的句柄
UINT uMsg, -----消息
WPARAM wParam, ---附加消息
LPARAM lParam  ---附加消息

参数UINT uMsg消息分类:

WM_CREATE: 创建窗口时发生;产生时间是窗口创建之后显示之前;
WM_PAINT:当需要绘制一部分应用窗口的时候，这个消息被Windows发出;
WM_DESTROY:窗口销毁后(调用DestroyWindow()后)的消息;
WM_COMMAND:这个消息是由窗口控件产生；
--------此时，参数WPARAM wParam:直接对应控件号；

WM_LBUTTONDOWN:鼠标点击；当用户在window客户区域点击鼠标左键的时候发送；
   wParam表示按键状态;以用它判断CTRL或者ATL或者SHIFT之类的按键有没有按下;
   lParam表示鼠标坐标（lParam是4字节整数，高2字节表示Y坐标，低2字节表示X坐标
   X坐标xPos = LOWORD(lParam);
   Y坐标yPos = HIWORD(lParam);

为了简洁，和可读性，外加可试验性；
把回调函数（WndProc）独立到一个H头文件之中；

static LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, 
                                WPARAM wParam, LPARAM lParam) 
{
  int x, y;
  HDC hdc;
  RECT rect;
  PAINTSTRUCT ps;//绘图信息结构
  MSGBOXPARAMS mbp;
switch(uMsg){
    case WM_PAINT:  // 绘图
        hdc = BeginPaint(Xqwl.hWnd, &ps);//绘画
        EndPaint(Xqwl.hWnd, &ps);
        break;
    case WM_COMMAND: // 菜单命令
        switch (LOWORD(wParam)) {
              case IDM_FILE_EXIT://菜单退出
                  DestroyWindow(Xqwl.hWnd);
                  break;
        }
    case WM_DESTROY:    // 退出
        PostQuitMessage(0);//发送一个退出信号，使主循环退出
        break;
    default://其他事件
        //默认的窗口处理函数，我们可以把不关心的消息都丢给它来处理
        return DefWindowProc(hWnd, uMsg, wParam, lParam);
    }
    return FALSE;
}

这样，就可以试运行了；

 
 这一节，稍微熟悉了回调函数的使用，并且试运行了一个最简单的窗口程序。

[此贴子已经被作者于2016-3-27 11:04编辑过]

在回调函数（WndProc）的消息选项中，
添加调整窗口尺寸的函数；

//static LRESULT CALLBACK WndProc(...){
//switch(uMsg){
    case WM_CREATE://创建窗口时发生;产生时间是窗口创建之后显示之前;
        tiaozhengchuangkou(hWnd); // 调整窗口位置和尺寸
//    case WM_PAINT:  // 绘图

函数独立出来放入头文件之中；

// 调整窗口位置和尺寸
void tiaozhengchuangkou(HWND hWnd)
{
    int x, y;
    RECT rect;
    GetWindowRect(hWnd, &rect);
    x = rect.left;
    y = rect.top;
    //右=左+棋盘宽度
    rect.right = rect.left + BOARD_WIDTH;
    //底=上+棋盘高度
    rect.bottom = rect.top + BOARD_HEIGHT;
    //计算矩形的大小--微调是为了适应风格(自适应)
    AdjustWindowRect(&rect, WINDOW_STYLES, TRUE);
    //改变窗口的位置和大小
    MoveWindow(hWnd, x, y, rect.right - rect.left, rect.bottom - rect.top, TRUE);
}

关于棋盘的常量设置，也粘贴出来：

// 版本号
const LPCSTR cszAbout = "象棋小巫师 0.1\n象棋百科全书 荣誉出品\n\n"
    "欢迎登录 www.\n免费下载PC版 象棋巫师";

// 窗口和绘图属性

//WS_OVERLAPPED产生一个层叠的窗口。一个层叠的窗口有一个标题条和一个边框。
//WS_SYSMENU创建一个在标题条上带有窗口菜单的窗口，必须同时设定WS_CAPTION风格。
//WS_CAPTION创建一个有标题框的窗口（包括WS_BORDER风格）。
//WS_MINIMIZEBOX创建一个具有最大化按钮的窗口。
//该风格不能与WS_EX_CONTEXTHELP风格同时出现，同时必须指定WS_SYSMENU风格。
const int WINDOW_STYLES = WS_OVERLAPPED | WS_SYSMENU | WS_CAPTION | WS_MINIMIZEBOX;

//
const int MASK_COLOR = RGB(0, 255, 0);//掩码颜色(绿色)
const int SQUARE_SIZE = 56;//单元的大小(正方形格子的边长)
const int BOARD_EDGE = 8;//棋盘边缘
const int BOARD_WIDTH = BOARD_EDGE + SQUARE_SIZE * 9 + BOARD_EDGE;//棋盘宽度
const int BOARD_HEIGHT = BOARD_EDGE + SQUARE_SIZE * 10 + BOARD_EDGE;//棋盘高度

// 棋盘范围
const int RANK_TOP = 3;//最顶行
const int RANK_BOTTOM = 12;//最底行
const int FILE_LEFT = 3;//最左列
const int FILE_RIGHT = 11;//最右列

// 棋子编号
const int PIECE_KING = 0;//将帅
const int PIECE_ADVISOR = 1;//士
const int PIECE_BISHOP = 2;//象
const int PIECE_KNIGHT = 3;//马
const int PIECE_ROOK = 4;//车
const int PIECE_CANNON = 5;//炮
const int PIECE_PAWN = 6;//卒或兵

 
这一节，分析了窗口的调整部分。
 

[此贴子已经被作者于2016-3-27 11:12编辑过]