C++博客-Sunshine Alike-随笔分类-WinAPI应用程序

MultiThread

Sunshine Alike — Mon, 11 May 2009 03:19:00 GMT

WindowsAPI里的多线程简单例子，先记下来，以后再学学

#include <windows.h>
#include <iostream>

using namespace std;

//线程处理函数
DWORD WINAPI Fun1(LPVOID lpParam);
DWORD WINAPI Fun2(LPVOID lpParam);

int tickets = 20;

void main()
{
    HANDLE hThread1, hThread2;
    hThread1 = CreateThread(NULL, 0, Fun1, NULL, 0, NULL);
    hThread2 = CreateThread(NULL, 0, Fun2, NULL, 0, NULL);
    CloseHandle(hThread1);
    CloseHandle(hThread2);

    cin.get();
}

DWORD WINAPI Fun1(LPVOID lpParam)
{
    while(true)
    {
        if(tickets > 0)
            cout<<"Thread1 sell ticket : "<<tickets--<<endl;
        else break;
    }
    return 0;
}

DWORD WINAPI Fun2(LPVOID lpParam)
{
    while(true)
    {
        if(tickets > 0)
            cout<<"Thread2 sell ticket : "<<tickets--<<endl;
        else break;
    }
    return 0;
}

这里在main里用两个函数Fun1和Fun2建了两个线程，有一个全局变量ticket＝20表示20张票，分由两个线程进行出售。
但是这个程序运行起来结果会出现混乱和不确定：

原因很简单，在操作系统里都学过关于同步的问题，这里的两个线程之间就没有对临界资源ticket进行同步。类似于操作系统里的PV操作，可以将程序改为：

#include <windows.h>
#include <iostream>

using namespace std;

//线程处理函数
DWORD WINAPI Fun1(LPVOID lpParam);
DWORD WINAPI Fun2(LPVOID lpParam);

int tickets = 20;
HANDLE hMutex;

void main()
{
    hMutex = CreateMutex(NULL, false, NULL);

    HANDLE hThread1, hThread2;
    hThread1 = CreateThread(NULL, 0, Fun1, NULL, 0, NULL);
    hThread2 = CreateThread(NULL, 0, Fun2, NULL, 0, NULL);
    CloseHandle(hThread1);
    CloseHandle(hThread2);

    cin.get();
}

DWORD WINAPI Fun1(LPVOID lpParam)
{
    while(true)
    {
        WaitForSingleObject(hMutex, INFINITE);
        if(tickets > 0)
            cout<<"Thread1 sell ticket : "<<tickets--<<endl;
        else break;
        ReleaseMutex(hMutex);
    }
    return 0;
}

DWORD WINAPI Fun2(LPVOID lpParam)
{
    while(true)
    {
        WaitForSingleObject(hMutex, INFINITE);
        if(tickets > 0)
            cout<<"Thread2 sell ticket : "<<tickets--<<endl;
        else break;
        ReleaseMutex(hMutex);
    }
    return 0;
}

这里用了一个信息量Mutex来对ticket进行同步操作，进程要操作ticket之前必须先获得信号量，使用完之后释放以使整个过程能继续下去。
最后得到正常的结果为：

Sunshine Alike 2009-05-11 11:19 发表评论

WinSocketTest 2.0

Sunshine Alike — Wed, 06 May 2009 09:08:00 GMT

在VS下建一个对话框的MFC程序UDPChat，去掉所有带的控件。加入以下控件：
按钮一个 IDC_BTN_SEND
编程框三个 IDC_EDIT_PORT(端口号)，IDC_EDIT_REC(显示接收到的消息)，IDC_EDIT_SEND(输入发送内容)
IP控件一个 IDC_IPADDRESS1

UDPChatDlg.h中加入
#define WM_RECDATA WM_USER+1
来定义一个消息号，用来处理接收到消息的事件

然后是以下方法声明：

private:
    bool InitSocket(void);
    static DWORD WINAPI RecProc(LPVOID lpParam);
    afx_msg LRESULT OnRecData(WPARAM wParam,LPARAM lParam);
    afx_msg void OnBnClickedBtnSend();

消息映射里加入两条：
ON_MESSAGE(WM_RECDATA, OnRecData)//处理收到消息事件
ON_BN_CLICKED(IDC_BTN_SEND, &CTcpChatDlg::OnBnClickedBtnSend)//处理按钮点击事件

至此，万事具备，只欠东风。

首先窗口初始化函数OnInitDialog里加入

    //构造一个新线程用于监听接收
    HANDLE hThread =
        CreateThread(NULL, 0, RecProc, (LPVOID)m_hWnd, 0, NULL);
    CloseHandle(hThread);

    ((CIPAddressCtrl*)GetDlgItem(IDC_IPADDRESS1))->SetAddress(127, 0, 0, 1);
    SetDlgItemText(IDC_EDIT_PORT, _T("6000"));

后面就是四个相关的成员函数，需要注意的是在线程必须使用静态函数或者全局函数，因为这程序一开始，线程就运行起来了，而成员方法在那个时候可能还没有生成出来。

bool CTcpChatDlg::InitSocket()
{
    WORD wVersionRequested;
    WSADATA wsaData;
    wVersionRequested = MAKEWORD( 2, 2 );

    int err = WSAStartup( wVersionRequested, &wsaData );
    if ( err != 0 ) {
        /* Tell the user that we could not find a usable */
        /* WinSock DLL.                                  */
        return false;
    }

    if ( LOBYTE( wsaData.wVersion ) != 2 ||
        HIBYTE( wsaData.wVersion ) != 2 ) {
            /* Tell the user that we could not find a usable */
            /* WinSock DLL.                                  */
            WSACleanup( );
            return false;
    }
    return true;
}

DWORD WINAPI CTcpChatDlg::RecProc(LPVOID lpParam)
{
    HWND hWnd = (HWND)lpParam;

    //-----------------------------------------------
    // Create a receiver socket to receive datagrams
    SOCKET RecvSocket = socket(AF_INET, SOCK_DGRAM, 0);
    if(INVALID_SOCKET == RecvSocket)
    {
        ::AfxMessageBox(_T("socket创建失败"));
        return 1;
    }

    //-----------------------------------------------
    // Bind the socket to any address and the specified port.
    SOCKADDR_IN RecvAddr;
    RecvAddr.sin_family = AF_INET;
    RecvAddr.sin_port = htons(6000);
    RecvAddr.sin_addr.S_un.S_addr = htonl(INADDR_ANY);

    if(SOCKET_ERROR == bind(RecvSocket, (SOCKADDR *) &RecvAddr, sizeof(RecvAddr)))
    {
        closesocket(RecvSocket);
        ::AfxMessageBox(_T("bind失败"));
        return 1;
    }

    //-----------------------------------------------
    // Call the recvfrom function to receive datagrams
    // on the bound socket.
    int retval;

    char RecvBuf[1024];
    char tmpBuf[1024];

    sockaddr_in SenderAddr;
    int SenderAddrSize = sizeof(SenderAddr);

    while(true)
    {
        retval = recvfrom(RecvSocket,
            RecvBuf,
            1024,
            0,
            (SOCKADDR *)&SenderAddr,
            &SenderAddrSize);
        if(SOCKET_ERROR == retval)
        {
            CString strError;
            strError.Format("error code : %d", WSAGetLastError());
            ::AfxMessageBox(strError);
            break;
        }
        sprintf_s(tmpBuf, 1024, "收到%s消息: %s", inet_ntoa(SenderAddr.sin_addr), RecvBuf);
        //发送消息
        ::PostMessage(hWnd, WM_RECDATA, 0, (LPARAM)tmpBuf);
    }

    //清理工作
    closesocket(RecvSocket);
    WSACleanup();
    return 0;//成功
}

LRESULT CTcpChatDlg::OnRecData(WPARAM wParam,LPARAM lParam)
{
    CString str((char*)lParam);
    CString origin;
    GetDlgItemText(IDC_EDIT_REC,origin);
    str += "\r\n";
    str += origin;
    SetDlgItemText(IDC_EDIT_REC,str);
    SetDlgItemText(IDC_EDIT_SEND, _T(""));
    return 0;
}

void CTcpChatDlg::OnBnClickedBtnSend()
{
    DWORD dwIP;
    ((CIPAddressCtrl*)GetDlgItem(IDC_IPADDRESS1))->GetAddress(dwIP);
    CString strPort;
    GetDlgItemText(IDC_EDIT_PORT, strPort);
    //创建发送地址信息
    SOCKADDR_IN addrTo;
    addrTo.sin_family = AF_INET;
    addrTo.sin_port = htons(atoi(strPort));
    addrTo.sin_addr.S_un.S_addr = htonl(dwIP);

    CString strMsg;
    GetDlgItemText(IDC_EDIT_SEND, strMsg);

    SOCKET sock = socket(AF_INET, SOCK_DGRAM, 0);

    if(SOCKET_ERROR ==
        sendto(
        sock, strMsg,
        strMsg.GetLength()+1, 0,
        (SOCKADDR *)&addrTo, sizeof(addrTo)
        ))
    {
        CString strError;
        strError.FormatMessage("Send Failed, Error Code: %d", WSAGetLastError());
        MessageBox(strError);
    }

    closesocket(sock);
}

Sunshine Alike 2009-05-06 17:08 发表评论

WinSocketTest 1.0

Sunshine Alike — Fri, 17 Apr 2009 01:44:00 GMT

好久没来写点东西,最近鬼事还真是多，破项目搞的人烦死。带队的经理说给我们的要求是日代码100行(核心代码),懒了这么久，一下写起来还真是累啊！
最近来了点劲头,先写上练的几个例子

使用windows套接字的网络小程序-------------------

1.Socket基本操作
　(1)启动/终止
winsock在被调用时以动态链接库的形式实现，所以在它初始化时应首先调用WSAStartup函数进行初始化，同时确定被调用的winsock版本号等。

    //  加载套接字库
    WORD wVersionRequested;
    WSADATA wsaData;
    wVersionRequested = MAKEWORD( 1, 1 );

    int err = WSAStartup( wVersionRequested, &wsaData );
    if ( err != 0 ) {
        /* Tell the user that we could not find a usable */
        /* WinSock DLL.                                  */
        return false;
    }

    if ( LOBYTE( wsaData.wVersion ) != 1 ||
        HIBYTE( wsaData.wVersion ) != 1 ) {
            /* Tell the user that we could not find a usable */
            /* WinSock DLL.                                  */
            WSACleanup( );
            return false;

这里加载了1.1版本的socket。在网络通信完成后，需要使用函数WSACleanup释放资源。
　(2)创建与绑定
　　套接字的创建非常简单，只需要调用socket即可。如下：
    SOCKET sock = socket(AF_INET, SOCK_STREAM, 0);//流式，TCP
　　SOCKET sock = socket(AF_INET, SOCK_DGRAM, 0);//数据报，UDP

　　使用bind函数可以将一个套接字绑定到一个地址上
　　int bind(SOCKET sock, const struct sockaddr* name, int len);//sockaddr是一个用来表示地
　　址信息的结构
　(3)侦听，接受连接与连接
　　listen, accept, connect这三个函数用于建立通信的连接。
　　int listen(SOCKET sock, int backlog);//scok必须是一个已经绑定但是没有连接的套接字，
　　backlog用于设定最大可以等待的连接长度
　　成功调用listen函数后，就可以接受客户机的连接了。
　　SOCKET accept(SOCKET sock, struct sockaddr* addr, int* addrlen);
　　到此一切就绪，当客户机想到连接时可以使用connect进行连接。
　(4)发送，连接
　　用于TCP的：
　　int send(SOCKET sock, const char* buf, int len, int flags);
    int recv(SOCKET sock, char* buf, int len, int flags);
　　用于UDP的：
　　int sendto(SOCKET sock, const char* buf, int len, int flags,
　　　　　　　　　　　　　　const struct sockaddr* to, int tolen);
    int recvfrom(SOCKET sock, char* buf, int len, int flags,
　　　　　　　　　　　　　　　struct sockaddr* from, int formlen);

2.示例
　两个win32的控制台程序，一个TcpSer，一个TcpClient。
　为了使用socket需要包含头文件
　
　TcpSer：
　

#include <Winsock2.h>
#include <iostream>
#include <string>
using namespace std;

void main()
{
    //加载套接字库，版本1.1
    WORD wVersionRequested;
    WSADATA wsaData;
    int err;

    wVersionRequested = MAKEWORD( 1, 1 );

    err = WSAStartup( wVersionRequested, &wsaData );
    if ( err != 0 ) {
        /* Tell the user that we could not find a usable */
        /* WinSock DLL.                                  */
        return;
    }

    if ( LOBYTE( wsaData.wVersion ) != 1 ||
        HIBYTE( wsaData.wVersion ) != 1 ) {
            /* Tell the user that we could not find a usable */
            /* WinSock DLL.                                  */
            WSACleanup( );
            return;
    }

    //创建套接字
    SOCKET sockSer = socket(AF_INET, SOCK_STREAM, 0);
    //地址结构体
    SOCKADDR_IN addrSer;
    addrSer.sin_addr.S_un.S_addr  = htonl(INADDR_ANY);
    addrSer.sin_family = AF_INET;
    addrSer.sin_port = htons(6000);
    //绑定与监听
    bind(sockSer, (SOCKADDR*)&addrSer, sizeof(SOCKADDR));
    listen(sockSer, 5);
    cout<<"Tcp Server Run!"<<endl;

    SOCKADDR_IN addrClient;
    int len = sizeof(SOCKADDR);
　　//收到连接请求，创建一个新socket用于保持连接
    SOCKET sockCon = accept(sockSer, (SOCKADDR*)&addrClient, &len);
    while(true)
    {
        char recBuf[100];
        recv(sockCon, recBuf, 100, 0);
        cout<<"message form clinet : "<<recBuf<<endl;
    }
    //清理工作
    closesocket(sockSer);
    WSACleanup();
}

　TcpClient：

#include <Winsock2.h>
#include <iostream>
#include <string>
using namespace std;

void main()
{
    //加载套接字库
    WORD wVersionRequested;
    WSADATA wsaData;
    int err;

    wVersionRequested = MAKEWORD( 1, 1 );

    err = WSAStartup( wVersionRequested, &wsaData );
    if ( err != 0 ) {
        /* Tell the user that we could not find a usable */
        /* WinSock DLL.                                  */
        return;
    }

    if ( LOBYTE( wsaData.wVersion ) != 1 ||
        HIBYTE( wsaData.wVersion ) != 1 ) {
            /* Tell the user that we could not find a usable */
            /* WinSock DLL.                                  */
            WSACleanup( );
            return;
    }

    //创建套接字
    SOCKET sockClient = socket(AF_INET, SOCK_STREAM, 0);

    SOCKADDR_IN addrSer;
    addrSer.sin_addr.S_un.S_addr  = inet_addr("127.0.0.1");
    addrSer.sin_family = AF_INET;
    addrSer.sin_port = htons(6000);

    cout<<"enter your message: ";
    string sendBuf;
    while(cin>>sendBuf)
    {
        if(sendBuf == "q"　｜｜　sendBuf == "Q")
            break;
        //连接服务器
        connect(sockClient, (SOCKADDR*)&addrSer, sizeof(SOCKADDR));
        send(sockClient, sendBuf.c_str(), sendBuf.length()+1, 0);
        cout<<"enter your message: ";
    }

    //清理工作
    closesocket(sockClient);
    WSACleanup();
}

最后还要注意的就是：在VS下编译时还要在项目属性>配置属性>链接器>命令行里加入附加选项ws2_32.lib
否则链接的时候找不到与socket相关的函数

Sunshine Alike 2009-04-17 09:44 发表评论

WindowsAPI学习笔记五 - 资源在Windows编程中的应用

Sunshine Alike — Fri, 13 Mar 2009 16:24:00 GMT

摘要: 在 windows 应用程序中有几种不同类型的资源，如加速键，位图，光标，对话框，菜单，工具条和字符串等。在最初的 API 编程阶段，程序员可以用文本编辑器来编写资源脚本，这种方式比较灵活，但代码量很大。在 Winodws 的可执行文件中，资源是独立于代码的，使用单独的 Resource Compil... 阅读全文

Sunshine Alike 2009-03-14 00:24 发表评论

WindowsAPI学习笔记四 - 对键盘和鼠标的响应

Sunshine Alike — Thu, 12 Mar 2009 08:17:00 GMT

键盘和鼠标在 windows 中的重要性不必多说，地球人都知道！键盘上每一个有意义的键都对应着一个唯一的标识值，称之为扫描码。但是这种扫描码是硬件相关的，为了实现设备无关性的要求，在 windows 应用程序中，使用的往往是与设备无关的虚拟码。

对键盘操作的响应过程基本如下：

用户按下一个键时，与键盘驱动程序（ KEYBOARD.DRV ）进行中断处理并调用 windows 用户模块（ USER.EXE ）中的有关程序来生成键盘消息，然后消息被发送到系统的消息队列中由相应的应用应用程序进行处理。鼠标的处理过程与键盘类似。但是注意无论是鼠标还是键盘的所产生的消息经过操作系统处理后都只会被发送给特定的窗口，即具有“输入焦点”的窗口来进行处理。

键盘消息
键盘消息通常可分为按键消息和字符消息两类，用户按下或松开一个键时，就产生一个按键消息，当一个按键组合产生了一个可以显示的字条时，就产生了一个字符消息。

按键消息一般又可以分为系统按键和非系统按键。

系统按键：是指使用了 Alt 等与相关输入键组成产生的消息，一般这些消息都由操作系统内部直接处理。如果应用程序处理了这些系统键消息，就要调用 DefWindowProc 函数，以便不影响 windows 对它们的处理。

非系统按键：对应于那些不使用组合键的按键消息。

再对按键消息的两个变量 wParam 和 lParam 做一些解释：（名堂还真不少 T_T ）

1. wParam
包含了识别按下键的虚键码，这些码是由系统定义的设备无关的。可以在 windows.h 中找到找到相关定义。

2. lParam
32 位的变量 lParam 所表示的含义可以分为以下 7 个部分

(1) 重复计数位（ 0~15 位）

表示当前消息的重复次数。

(2) OEM 扫描码（ 16~23 位）

OEM 扫描码是键盘发送的码值，因为是设备相关的帮一般被忽略掉。

(3) 扩展键标志（ 24 位）

在有 Alt 或 Ctrl 键按下时为 1, 否则为 0 。

(4) 保留位（ 25~28 位）

系统保留，一般不用。

(5) 关联码（ 29 位）

主要用来记录某键与 Alt 等键的组合状态，若按下 Alt 键，当 WM_SYSKEYDOWN 消息发送到某个激活窗口时，其值为 1, 否则为 0 。

(6) 键的先前状态（ 30 位）

用于记录先前某键的状态。

(7) 转换状态（ 31 位）

用于记录被始终按下的某键所产生的消息。

在 WinMain 函数里的消息循环中包含了 TranslateMessage 函数，它的主要功能是把按键消息转化为字符消息，即把按键所产生的原始的KEYDOWN/KEYUP消息转化成WM_CHAR消息。同样，字符消息也可以分为系统和非系统消息两类。

Windows 系统支持两类字符集： OEM 和 ANSI 。 OEM 是 IBM 的字符集，在 windows 中使用不多，目前大多使用的是 ANSI 字符集。

鼠标消息

1. 鼠标操作

简单的单击操作包含了按下和松开这一全过程；而双击操作实际上是指用户在知时间内（默认为 0.5 秒）的再次单击操作。

在鼠标消息中，参数 lParam 包含了鼠标的位置，低字节是 X 坐标，高字节是 Y 坐标。参数 wParam 则包含了一个指示各种虚键状态的值。

通过用户区消息的 wParam 和 lParam 参数，程序员就可以确定鼠标的位置和状态。

对于鼠标的消息处理，一般分为两种，一种要对 Ctrl 等键进行监视，另一种则不需要。下面是一个示例

case WM_LbUTTONDWON: // 鼠标按下时 ctrl 和 shift 都被按下

If(( wParam&MK_CONTROL) && ( wParam&MK_SHIFT) )

…

break;

case WM_LBUTTONDOWN: // 不监视组合按键

…

break;

此外，要使窗口能监视双击消息，必须在注册窗口类的时候使该类具有 CS_DBLCLKS 属性才行，否则只能收到两条单击消息。

2. 光标

可以使用系统光标或者调用 LoadCursor 加载自定义光标资源

示例程序

在下面的一个例子中，显示鼠标和键盘的消息响应。程序的用户区被分为四个区域，每个区域里光标设置成不同的样式。通过监视键盘按键，可对一个 10 个字符长的缓冲区里输入字符，并最后显示在鼠标上方，鼠标移动时同时修改字符输出的位置。可以按下 BACK 键删掉已经输入的字符，缓冲区满时再输入和空的时候删字符的操作都被拒绝，并用消息框进行提示。代码如下：

// 定义的静态变量
#define BufSize 10
static char lpszBuffer[BufSize];
static int nNumChar = 0 ;
static int i = 0 ;
static POINT pt;
    ……
LRESULT CALLBACK WndProc(HWND hWnd, UINT iMsg,
                         UINT wParam,
                         LONG lParam)
{
    HDC hdc;
    PAINTSTRUCT ps;
    HCURSOR hCur;
     switch (iMsg)
     {
     case WM_CHAR: // 处理非系统键的消息
         if (wParam == VK_BACK) // 按下退格键
         {
             if (nNumChar == 0 )
             {
                MessageBox(hWnd, " 没有字符可以删除！ " , NULL, MB_OK);
            }
             else
             {
                 -- nNumChar;
                 // 此函数刷新用户区，会产生PAINT消息
                InvalidateRect(hWnd, NULL, TRUE);
            }
             break ;
        }
         if (nNumChar >= BufSize) // 字符超过缓冲区大小
         {
            MessageBox(hWnd, " 缓冲区已满！删除字符请用退格键 " , NULL, MB_OK);
             break ;
        }
        lpszBuffer[nNumChar ++ ] = (unsigned char )wParam;
        InvalidateRect(hWnd, NULL, TRUE);
         break ;

     case WM_PAINT: // 将处理过的字符输出
        hdc = BeginPaint(hWnd, & ps);
         // 调整坐标使字出现在鼠标上方
         TextOut(hdc, pt.x - 15 , pt.y - 15 , lpszBuffer, nNumChar);
        EndPaint(hWnd, & ps);
         break ;

     case WM_MOUSEMOVE: // 移动鼠标后改变文本输出坐标并刷新
        pt.x = LOWORD(lParam);
        pt.y = HIWORD(lParam); // 鼠标的坐标
         // 在不同的区域显示不同的光标
         if (pt.x < 400 && pt.y < 400 )
            hCur = LoadCursor(NULL, IDC_NO);
         else if (pt.x > 400 && pt.y < 400 )
            hCur = LoadCursor(NULL, IDC_HELP);
         else if (pt.x < 400 & pt.y > 400 )
            hCur = LoadCursor(NULL, IDC_SIZEALL);
         else if (pt.x > 400 && pt.y > 400 )
            hCur = LoadCursor(NULL, IDC_CROSS);
        SetCursor(hCur);
        InvalidateRect(hWnd, NULL, TRUE);
         break ;

     case WM_DESTROY:
        PostQuitMessage( 0 );
         return 0 ;
     default :
         return (DefWindowProc(hWnd, iMsg, wParam, lParam));
    }
     return 0 ;
}

Sunshine Alike 2009-03-12 16:17 发表评论

WindowsAPI学习笔记三 - 字体设置与输出

Sunshine Alike — Wed, 11 Mar 2009 08:41:00 GMT

Windows 系统中经常使用 GDI 进行文本输出，从某种意义上来说，图形和文本并没有本质上的界限，很多时候 windows 把文本也当作图形对待。在 windows 编程中，文本操作首先要获得文本句柄，此外，还要设置字体，字符大小，字符颜色等有关属性，并将它们选入设备环境。

设置文本的设备环境

1. 自定义字体
可以使用函数 CreateFont 自定义字体

HFONT hFont = HFONT CreateFont(

int nHeight, int nWidth, // 字体高，宽

int nEscapement, // 文字相对于页底的角度

int nOrientation, // 每个文字相对于页底的角度

int fnWeight, // 字体粗细，范围 0~1000 ， 400 为正常字体， 700 为黑体

DWORD fdwItalic, // 取非零值则为斜体

DWORD fdwUnderline, // 取非零值则下划线

DWORD fdwStrikeOut, // 取非零值则中划线

DWORD fdwCharSet, // 字体所属字符集

DWORD fdwOutputPrecision, // 输出精度（一般取默认值）

DWORD fdwClipPrecision, // 剪裁精度（一般取默认值）

DWORD fdwQuality, // 输出质量（一般取默认值）

DWORD fdwPitchAndFamily, // 字体间距及字体系列（一般取默认值）

LPCTSTR lpszFace // 字体名

);
这个这个......以后这样建字体还不累死才怪咧！而且貌似 API 里带这么多恶心参数的方法还不少，了解一下就行了。一般情况下使用系统默认提供的字体就可以了。

2.         字体句柄
windows 系统提供了七种基本字体：
ANSI_FIXED_FONT ， DEFAULT_GUI_FONT ， ANSI_VAR_FONT
DEVICE_DEFAULT_FONT ， SYSTEM_FIXED_FONT ，
SYSTEM_FONT （系统默认字体）
调用函数 GetStockObject （）即可获得系统默认字体
获得字体之后，有时候还需要设置字体颜色和背景色，可以使用下面两个函数：
SetTextColor          // 设置字体颜色
SetBkColor            // 设置背景颜色

文本输出过程
设置了字体句柄，字体及字体颜色之后就可以把设置字体输入到相应的设备上。 Windows 系统在文本输出上有点小小的偷懒，把很多事情都丢给了程序员来做，应用程序必须自己管理换行，后续字符的位置等输出格式。虽提供了编程的自由，但是程序员的工作量也变的非常大。

文本输出过程包括获取字体信息，格式化文本，调用函数输出文本等过程。

1. 获取字体信息
应用程序在输出字体之前必须先获取当前字体的有关信息，在 windows 程序中通过调用 GetTextMetrics 函数来获取当前字体的信息。其形式为：
GetTextMetrics(hdc, &tm); //tm 为 TEXTMETRIC 结构
TEXTMETRIC 结构也非常复杂，其结构定义如下：

typedef struct tagTEXTMETRIC {

LONG tmHeight;

LONG tmAscent;

LONG tmDescent;

LONG tmInternalLeading;

LONG tmExternalLeading;

LONG tmAveCharWidth;

LONG tmMaxCharWidth;

LONG tmWeight;

LONG tmOverhang;

LONG tmDigitizedAspectX;

LONG tmDigitizedAspectY;

TCHAR tmFirstChar;

TCHAR tmLastChar;

TCHAR tmDefaultChar;

TCHAR tmBreakChar;

BYTE tmItalic;

BYTE tmUnderlined;

BYTE tmStruckOut;

BYTE tmPitchAndFamily;

BYTE tmCharSet;

} TEXTMETRIC, *PTEXTMETRIC;

具体各属性不解释，需要时可以查询 MSDN 。

2. 格式化文本
格式化处理一般针对两种情况，一是文本行中确定后续文本的坐标，二是在换行时确定下一行的坐标。

(1) 确定后续文本坐标

应先获取当前字符的宽度，通过计算字符串起始坐标与字符串宽度之和即可得到后续文本的起始坐标。
这里要使用到函数：
BOOL GetTextExtentPoint32

(

HDC hdc,

LPCTSTR lpsxString, // 指定的字符串

int nLength, // 字符串中字符数

LPSIZE lpSize // 字符串宽度及高度的 SIZE 数据结构

)

(2) 确定换行时文本坐标
通过计算当前文本行字符的高度与行间隔之和，即可得到换行时文本的起始坐标，而上述两个数值均可通过获取当前字体信息得到。

3. 文本输出

最常用的文本输出函数就是 TextOut ，其原型如下：
BOOL TextOut

(

HDC hdc,

int x, int y,

LPCTSTR lpString,

int nCount

)

文本操作实例

因为代码太长，全部贴出来页面不好看。故只给出WndProc函数的实现，程序其它部分可以参考以前的笔记。

LRESULT CALLBACK WndProc(HWND hWnd, UINT iMsg,
                         UINT wParam,
                         LONG lParam)
{
    HDC hdc;
    HFONT hFont;    //字体句柄
    PAINTSTRUCT ps;
    TEXTMETRIC tm;

    char lpszTx1[] = "红色的SYSTEM字体：好好学习，天天向上！";
    char lpszTx2[] = "绿色自定义字体：保护眼睛，注意休息！";
    char lpszTx3[] = "蓝色大号斜体并带有下划线！";
    char lpszTx4[] = "两行文本输出到同一行里！";
    char lpszTx5[] = "今天的学习就到这里，祝你成功！";

    int x = 0, y = 0;
    SIZE size;
    switch(iMsg)
    {

    case WM_PAINT:
            hdc = BeginPaint(hWnd, &ps);

            SetTextColor(hdc, RGB(255, 0, 0));//文本为红色
            TextOut(hdc, x, y, lpszTx1, strlen(lpszTx1));//字体输出

            GetTextMetrics(hdc, &tm);    //获取系统当前字体
            y = y + tm.tmHeight + tm.tmExternalLeading;//计算下一行坐标
            hFont = CreateFont
                        (
                            20,0,    //高度20, 宽取0表示由系统选择最佳值
                            0, 0,    //文本倾斜，与字体倾斜都为0
                            FW_HEAVY,    //粗体
                            0,0,0,        //非斜体，无下划线，无中划线
                            GB2312_CHARSET,    //字符集
                            OUT_DEFAULT_PRECIS,
                            CLIP_DEFAULT_PRECIS,
                            DEFAULT_QUALITY,        //一系列的默认值
                            DEFAULT_PITCH | FF_DONTCARE,
                            "自定义字体"    //字体名称
                        );
            SetTextColor(hdc, RGB(0, 255, 0));
            SelectObject(hdc, hFont);
            TextOut(hdc, x, y, lpszTx2, strlen(lpszTx2));

            GetTextMetrics(hdc, &tm);    //将当前字体信息选入tm结构中
            y = y + tm.tmHeight + 15 * tm.tmExternalLeading;//5倍行间距
            hFont = CreateFont
                        (
                            40,0,    //高度40, 宽取0表示由系统选择最佳值
                            0, 0,    //文本倾斜，与字体倾斜都为0
                            FW_NORMAL,
                            1,1,0,        //斜体，下划线，无中划线
                            GB2312_CHARSET,    //字符集
                            OUT_DEFAULT_PRECIS,
                            CLIP_DEFAULT_PRECIS,
                            DEFAULT_QUALITY,        //一系列的默认值
                            DEFAULT_PITCH | FF_DONTCARE,
                            "大号字体"    //字体名称
                        );
            SetTextColor(hdc, RGB(0, 0, 255));
            SetBkColor(hdc, RGB(160, 160, 160));//设置背景颜色
            SelectObject(hdc, hFont);
            TextOut(hdc, x, y, lpszTx3, strlen(lpszTx3));
            //获取系统提供的字体
            hFont = (HFONT)GetStockObject(SYSTEM_FIXED_FONT);
            y = y + tm.tmHeight + 25 * tm.tmExternalLeading;
            SetTextColor(hdc, RGB(0, 0, 0));
            SetBkColor(hdc, RGB(255, 255, 255));
            SelectObject(hdc, hFont);
            TextOut(hdc, x, y, lpszTx4, strlen(lpszTx4));
            GetTextExtentPoint32(hdc, lpszTx4, strlen(lpszTx4), &size);//计算高宽
            x = x + size.cx;
            TextOut(hdc, x , y ,lpszTx5, strlen(lpszTx5));

            EndPaint(hWnd, &ps);
            DeleteObject(hFont);
            break;
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, iMsg, wParam, lParam);
    }
    return 0;
}

Sunshine Alike 2009-03-11 16:41 发表评论

WindowsAPI学习笔记二 - 图形设备接口及windows绘图

Sunshine Alike — Tue, 10 Mar 2009 13:09:00 GMT

摘要: Windows 图形设备接口（ Graphics Device Interface, GDI ）是为与设备无关的图形设计的，由操作系统屏蔽了硬件设备的差异，简化了程序员的程序编写工作。设备上下文（ ... 阅读全文

Sunshine Alike 2009-03-10 21:09 发表评论

WindowsAPI学习笔记一 - Windows应用程序基本结构

Sunshine Alike — Tue, 10 Mar 2009 04:42:00 GMT

摘要: Windows 应用程序基本结构一个完整的 windos 应用程序通常由下面五种类型的文件组成： 1. 扩展名为 .c/.cpp 的Ｃ语言程序源文件 ... 阅读全文

Sunshine Alike 2009-03-10 12:42 发表评论