#include <cstdio>

int main()

{

    int a,b,c;

    for (c=b=10;a="VAMSI PERI,TFy!QJu ROo TNn(ROo)SLq SLq ULo+ UHs UJq TNn*RPn/QPbEWS_JSWQAIJO^ NBELPeHBFHT}TnALVlBLOFAkHFOuFETp HCStHAUFAgcEAelclcn^r^r\\tZvYxXy T|S~Pn SPm SOn TNn ULo0ULo#ULo-W Hq!WFs XDt!" [b++];)

        for(; a-- > 64 ; )

            putchar ( ++c==90 ? c=10:33^b&1);

}

   照着这样的方法写了个打印字符串的东西，可以按照指定长度换行。

#include <cstdio>

int main()

{

    int a,b,c;

    for (c=b=0;a="www.cppblog.com/gohan        this is a test"[b++];)

        if(a!='\0')

            putchar ( ++c==30 ? c=0,b--,10:a);

    putchar(10);

}

   最后这个是打印一个自己构造的ASC字符，这里构造的是我的名字

#include <cstdio>

int main()

{

    int a,b,c;

    for (c=0,b=0;a="@u@GFLB[@DBJDDFEDEFD@CBBDBBDBBBDBBBCBCBDBC@BBDBBBDBBBDBBBCBCBDBD@CFDDDBDBDGABDBE@v"[b++];)

        for(; a-- > 64 ; )

            putchar ( ++c==54 ? c=0,10:33^b&1);

}

执行效果如图

    ReadConsoleInput是一个Win32 API，  声明如下：

BOOL ReadConsoleInput(

  HANDLE hConsoleInput, //输入句柄

  PINPUT_RECORD lpBuffer, //指向INPUT_RECORD结构体(数组)的指针

  DWORD nLength, //上面那个结构体的大小

  LPDWORD lpNumberOfEventsRead //实际读入输入内容的个数

);

    我把读入的功能写在这个助手类中，ReadConsoleInput的得到VK_CODE的方法可以看ReadKeyDown和ReadKeyPush两个函数，它们的效果略有点不同。右图是效果截图，按ESC跳出循环。助手类以后还可以添加颜色控制位置控制等功能，只要你想，目的就是为了简化API调用。

#pragma once

#include <Windows.h>

class GohanConsoleHelper

{

    HANDLE _hIn;

    HANDLE _hOut;

    INPUT_RECORD _InRec;

    DWORD _NumRead;

public:

    WORD VKey;

    GohanConsoleHelper(void){

        _hIn = GetStdHandle(STD_INPUT_HANDLE);

        _hOut = GetStdHandle(STD_OUTPUT_HANDLE);

        VKey=0;

    }

    bool ReadOneInput()

    {

        return 0!=ReadConsoleInput(_hIn,&_InRec,1,&_NumRead);

    }

    bool ReadOneInput(INPUT_RECORD& InRec)

    {

        return 0!=ReadConsoleInput(_hIn,&InRec,1,&_NumRead);

    }

    DWORD ReadKeyDown()

    {

        if(!ReadConsoleInput(_hIn,&_InRec,1,&_NumRead))

            return 0;

        if(_InRec.EventType!=KEY_EVENT)

            return 0;

        if(_InRec.Event.KeyEvent.bKeyDown > 0)

            return 0;

        VKey = _InRec.Event.KeyEvent.wVirtualKeyCode;

        return VKey;

    }

    DWORD ReadKeyPush()

    {

        if(!ReadConsoleInput(_hIn,&_InRec,1,&_NumRead))

            return 0;

        if(_InRec.EventType!=KEY_EVENT)

            return 0;

        if(_InRec.Event.KeyEvent.bKeyDown == 0)

            return 0;

        VKey = _InRec.Event.KeyEvent.wVirtualKeyCode;

        return VKey;

    }

public:

    ~GohanConsoleHelper(void){}

};

main所在文件内容

#include <windows.h>

#include <iostream>

#include "GohanConsoleHelper.h"

using namespace std;

int main()

{

    GohanConsoleHelper gch;

    while (true)

    {

        if(gch.ReadKeyPush()!=0) //使用ReadKeyDown()捕获按键弹起的VK_CODE

        {

            if(gch.VKey != VK_ESCAPE)

                cout<<"VK_CODE == "<<gch.VKey<<endl;

            else {

                cout<<"Bye~~"<<endl;

                break;

            }

        }

    }

    return 0;

}

    在命令行得到VK_CODE可以干许多事情了，可以写个在Win32命令行下的小游戏，俄罗斯方块啊什么的，呵呵，不过画面稍微好点的就搞不了了，因为毕竟win32命令行分辨率太低了。

   忘了放出参考的资料：

http://adrianxw.dk/ 比较全面的Win32命令行教程

   经过观察我发现重命名时，资源管理器会向他的子窗口listview发送一个LVM_EDITLABELA的控制消息，所以我使用了WH_CALLWNDPROCRET类型的全局挂钩，这个挂钩可以在sendmessage结束以后处理传送和返回的数据。发送了LVM_EDITLABELA消息后，会在lParam得到一个编辑窗口的句柄，只需之后对这个窗口发送EM_SETSEL控制消息就能够改变重命名时候的高亮区域。hook回调函数如下：

   1: static LRESULT CALLBACK msghook(UINT nCode, WPARAM wParam, LPARAM lParam)

   2: {

   3:     if(nCode < 0)

   4:     {

   5:         CallNextHookEx(hook,nCode,wParam,lParam);

   6:         return 0;

   7:     }

   8:     LPCWPRETSTRUCT msg = (LPCWPRETSTRUCT) lParam;

   9:     if(msg->message == LVM_EDITLABELA || msg->message == LVM_EDITLABELW)

  10:     {

  11:         GetClassName(msg->hwnd,className,255);

  12:         GetWindowText(msg->hwnd,wndName,255);

  13:         if(0==_tcscmp(className,_TEXT("SysListView32")))

  14:         {

  15:             if(0==_tcscmp(wndName,_TEXT("FolderView")))

  16:             {

  17:                 hEditWnd = (HWND)msg->lResult;

  18:                 GetWindowText(hEditWnd,className,255);//暂时放入className

  19:                 SendMessage(hEditWnd,EM_SETSEL,0,findDot(className));

  20:             }

  21:         }

  22:     }

  23:     return CallNextHookEx(hook,nCode,wParam,lParam);

  24: }

className与wndName是两个TCHAR数组，从hwnd获取信息存在那里进行判断是否为Shell中的listview，避免在其它使用listview的应用程序里会进行之后的处理。

   工程文件下载，点这里

   程序下载，点这里

   使用方法，编译以后直接运行GRnamer就可以，如果不想用了，从任务管理器把它关闭，没有做trayicon之类的东西，因为只是个demo。

   最后说一下缺陷，缺陷就是这样做没有办法判断文件与文件夹的区别，所以会有如图的效果，我自己没有想到解决的方法，请达人们指点。：）

   参考的文章：

msdn Hooks hook的全部参考

codeproject Hooks and DLLs 我的hook dll都是照着它写的。

   我搜索了一下这个问题的解决，参考了如下资料写了演示代码。

• fstream 和 中文路径  c++博客
• About unicode settings in visual studio 2005, it really puzzled me a lot ms forum
• MSDN

   我综合了以上的内容，总结了3种方法，能够较好解决大家的困扰，包括可能无法使用cout的问题。

   1: /********************************************************************

   2:     created:    2008/05/10

   3:     created:    10:5:2008   23:56

   4:     filename:     k:\sj\fstreamTest\fstreamTest\main.cpp

   5:     file path:    k:\sj\fstreamTest\fstreamTest

   6:     file base:    main

   7:     file ext:    cpp

   8:     author:        Gohan

   9: *********************************************************************/

  10: #include <tchar.h>

  11: #include <fstream>

  12: #include <iostream>

  13: using namespace std;

  14: int main()

  15: {

  16:     /************************************************************************/

  17:     /* 方法1，使用_TEXT()宏定义将字符串常量指定为TCHAR*类型                 */

  18:     /* 如果是我，首选此类型                                                 */

  19:     /************************************************************************/

  20:     fstream file;

  21:     file.open(_TEXT("c:\\测试\\测试文本.txt"));

  22:     cout<<file.rdbuf();

  23:     file.close();

  24:  

  25:     /************************************************************************/

  26:     /* 方法2，使用STL中的locale类的静态方法指定全局locale                   */

  27:     /* 使用该方法以后,cout可能不能正常输出中文，十分蹊跷                    */

  28:     /* 我发现了勉强解决的方法：不要在还原区域设定前用cout或wcout 输出中文   */

  29:     /* 否则后果就是还原区域设定后无法使用cout wcout输出中文                 */

  30:     /************************************************************************/

  31:     locale::global(locale(""));//将全局区域设为操作系统默认区域

  32:     file.open("c:\\测试\\测试文本2.txt");//可以顺利打开文件了

  33:     locale::global(locale("C"));//还原全局区域设定

  34:     cout<<file.rdbuf();

  35:     file.close();

  36:  

  37:     /************************************************************************/

  38:     /* 方法3，使用C函数setlocale，不能用cout输出中文的问题解决方法同上      */

  39:     /************************************************************************/

  40:     setlocale(LC_ALL,"Chinese-simplified");//设置中文环境

  41:     file.open("c:\\测试\\测试文本3.txt");//可以顺利打开文件了

  42:     setlocale(LC_ALL,"C");//还原

  43:     cout<<file.rdbuf();

  44:     file.close();

  45: }

  补充一下，第一种方法，如果不是静态字符串当作路径的话，记得传入TCHAR*类型字符串作为路径，应该就没问题了。

操作系统通过二进制文件格式存储大量文件。一般不指定二进制文件操作的I/O操作是面向文本的，用来读写特定编码的文本。本文介绍用C++的fstream类读写二进制文件。

读写数据以这个WebSite结构体为例

        // Struct for C++ File I/O binary file sample

   1: struct WebSites

   2: {

   3:      char SiteName[100];

   4:      int Rank;

   5: };

写操作

    注意事项

• 要写的文件需要用到输出模式标志 ios::out和二进制操作模式标志ios::binary。
• write()函数需要两个参数.第一个参数是char*类型用来指定需要写入的数据， 第二个参数是int类型指定写入多少个字节.
• 最后记得要用close()结束.

        // Sample for C++ File I/O binary file write

   1: void write_to_binary_file(WebSites p_Data)

   2: {

   3:     fstream binary_file("c:\\test.dat",ios::out|ios::binary|ios::app); 

   4:     binary_file.write(reinterpret_cast<char *>(&p_Data),sizeof(WebSites));

   5:     binary_file.close();

   6: } 

上面的例子把一个WebSites的对象追加进了c:\test.dat之中，ios::app是追加方式操作文件的标志。

上面的write函数，需要第一个参数为char*类型，所以用 reinterpret_cast转换将这个对象地址转换成char*类型.

读操作

   跟上面的操作流程类似. 唯一不同在于使用输入模式标志ios::in, 使用read()方法.

        // Sample for C++ File I/O binary file read

   1: void read_from_binary_file()

   2: {

   3:     WebSites p_Data;

   4:     fstream binary_file("c:\\test.dat",ios::binary|ios::in);

   5:     binary_file.read(reinterpret_cast<char *>(&p_Data),sizeof(WebSites));

   6:     binary_file.close();

   7:     cout<<p_Data.SiteName<<endl;

   8:     cout<<"Rank :"<< p_Data.Rank<<endl;

   9: } 

本文只是关于文件io流的一些基础介绍，一些高级操作比如seek，检查文件指针的有效性等等，也是需要学习的，这里就不多说了。

文章来源  我只是做一个简短的翻译

Win32命令行应用程序是可以加颜色的，使用SetConsoleTextAttribute就可以实现了，记得前年小学期做的程序作业就用了它。

这篇文章很简单，你可以当作是一个cout <<运算符重载的一个简单例子。本文章来源与这里，我只是做一个很不专业解释。

本文章提供的库可以如下使用，上面是显示效果，想起小时候玩的Mud了吧。

#include "ConsoleColor.h"
std::cout << green << "This text is written in green" << white << std::endl;
std::cout << color(FOREGROUND_RED|FOREGROUND_GREEN) << "This text has a really exiting color !"
<< white << std::endl;

ConsoleColor.h的内容

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

inline std::ostream& blue(std::ostream &s)
{
    HANDLE hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
    SetConsoleTextAttribute(hStdout, FOREGROUND_BLUE
        |FOREGROUND_GREEN|FOREGROUND_INTENSITY);
    return s;
} 

inline std::ostream& red(std::ostream &s)
{
    HANDLE hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
    SetConsoleTextAttribute(hStdout,
        FOREGROUND_RED|FOREGROUND_INTENSITY);
    return s;
} 

inline std::ostream& green(std::ostream &s)
{
    HANDLE hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
    SetConsoleTextAttribute(hStdout,
        FOREGROUND_GREEN|FOREGROUND_INTENSITY);
    return s;
}

inline std::ostream& yellow(std::ostream &s)
{
    HANDLE hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
    SetConsoleTextAttribute(hStdout,
        FOREGROUND_GREEN|FOREGROUND_RED|FOREGROUND_INTENSITY);
    return s;
}

inline std::ostream& white(std::ostream &s)
{
    HANDLE hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
    SetConsoleTextAttribute(hStdout,
        FOREGROUND_RED|FOREGROUND_GREEN|FOREGROUND_BLUE);
    return s;
}//以上这些函数定义本身就是cout的<<操作符的一种参数重载形式,即：
//basic_ostream& operator<<( basic_ostream& (*_Pfn)(basic_ostream&) );

struct color {
    color(WORD attribute):m_color(attribute){};
    WORD m_color;
}; 

template <class _Elem, class _Traits>
std::basic_ostream<_Elem,_Traits>&
operator<<(std::basic_ostream<_Elem,_Traits>& i, color& c)
{
    HANDLE hStdout=GetStdHandle(STD_OUTPUT_HANDLE);
    SetConsoleTextAttribute(hStdout,c.m_color);
    return i;
}

最后这个是对于<<操作符的重载，形式类似于如下

template<class _Tr>
   basic_ostream<char, _Tr>& operator<<(
      basic_ostream<char, _Tr>& _Ostr,
      const unsigned char *_Str);

OK，发挥你的想象力，让c++变得更有趣吧。

参考链接：

Win32 Console Applications - Part 4. 这个就是最初我使用命令行色彩的参考，有兴趣可以看看。今天做了一个归并排序演示程序，还要继续完善，我MFC很烂，完了放出烂烂的代码。

http://www.cppblog.com/danoyang/archive/2006/05/23/7523.html

 1WCHAR wszLnkFile[MAX_PATH] = {0};
 2IShellLink* pShellLink = NULL;
 3   IPersistFile* pPF = NULL;
 4
 5   // Create the appropriate COM server
 6   HRESULT hr = CoCreateInstance(CLSID_ShellLink, NULL,
 7                                 CLSCTX_INPROC_SERVER, IID_IShellLink,
 8                                 reinterpret_cast<LPVOID*>(&pShellLink));
 9   if(FAILED(hr))
10      return hr;
11
12   // Get the IPersistFile interface to load the LNK file
13   hr = pShellLink->QueryInterface(IID_IPersistFile, reinterpret_cast<LPVOID*>(&pPF));
14   if(FAILED(hr))
15   {
16      pShellLink->Release();
17      return hr;
18   }
19 MultiByteToWideChar(CP_ACP, 0, szLnkFile, -1, wszLnkFile, MAX_PATH);
20   hr = pPF->Load(wszLnkFile, STGM_READ);
21   if(FAILED(hr))
22   {
23      pPF->Release();
24      pShellLink->Release();
25      return hr;
26   }
27
28   //现在可以用pShellLink了
29  hr = pPF->Save(wszLnkFile, TRUE);
30
31   // Clean up
32   pPF->Release();
33   pShellLink->Release();
34

下面这段是一个Drag的例子
 WindowFromPoint(pt)感觉很强,可以获取pt点(屏幕坐标系)的窗体对象
DragQueryFile来分析hDrop
hDrop是WM_DROPFILES事件的(wParam)参数,类型为HDROP
一般都用reinterpret_cast转换

      POINT pt;
   DragQueryPoint(hDrop, &pt);
   ClientToScreen(hDlg, &pt);
   HWND hwndDrop = WindowFromPoint(pt);
   if(hwndDrop != GetDlgItem(hDlg, IDC_VIEW))
   {
      Msg(__TEXT("Sorry, you have to drop over the list view control!"));
      return;
   }

   // Now check the files
   int iNumOfFiles = DragQueryFile(hDrop, -1, NULL, 0);
   for(int i = 0 ; i < iNumOfFiles; i++)
   {
      TCHAR szFileName[MAX_PATH] = {0};
      DragQueryFile(hDrop, i, szFileName, MAX_PATH);
      //获得了文件名,index为i的
   }

   DragFinish(hDrop);

IShellFolder Interface 接口的成员

The IShellFolder interface is used to manage folders. It is exposed by all Shell namespace folder objects.

IShellFolder Members

BindToObject	Retrieves an IShellFolder object for a subfolder.书上有讲
BindToStorage	Requests a pointer to an object's storage interface.
CompareIDs	Determines the relative order of two file objects or folders, given their item identifier lists.
CreateViewObject	Requests an object that can be used to obtain information from or interact with a folder object.
EnumObjects	Allows a client to determine the contents of a folder by creating an item identifier enumeration object and returning its IEnumIDList interface. The methods supported by that interface can then be used to enumerate the folder's contents.下面有IEnumIDList的成员
GetAttributesOf	Retrieves the attributes of one or more file or folder objects contained in the object represented by IShellFolder.
GetDisplayNameOf	Retrieves the display name for the specified file object or subfolder. 书上有讲
GetUIObjectOf	Retrieves an OLE interface that can be used to carry out actions on the specified file objects or folders.书上有讲
ParseDisplayName	Translates a file object's or folder's display name into an item identifier list.书上有讲
SetNameOf	Sets the display name of a file object or subfolder, changing the item identifier in the process.

 

IEnumIDList Interface

---

The IEnumIDList interface provides a standard set of methods that can be used to enumerate the pointers to item identifier lists (PIDLs) of the items in a Shell folder. When a folder's IShellFolder::EnumObjects method is called, it creates an enumeration object and passes a pointer to the object's IEnumIDList interface back to the caller.

IEnumIDList Members

Clone	Creates a new item enumeration object with the same contents and state as the current one.
Next	Retrieves the specified number of item identifiers in the enumeration sequence and advances the current position by the number of items retrieved.
Reset	Returns to the beginning of the enumeration sequence.
Skip	Skips over the specified number of elements in the enumeration sequence.

By Yasar Arslan. From codeproject

这篇文章内容比较基础，最近看到觉得有用，顺便翻译一下
有空可以写一个自己的TrayIcon类，化简这些原始的操作。

Introduction

这篇文章解析了 Shell_NotifyIcon 这个函数用法--用来建立你自己的应用程序的系统托盘图标.
这篇文章给了基本的缩小到托盘的操作过程并让你从中了解.
这篇文章提供8个简单的步骤让你成功的实现在你的程序中建立系统托盘图标.
源代码提供了一个基于对话框的演示程序.

Tray Icons

为了用托盘图标你需要用一个shell函数 :)

BOOL Shell_NotifyIcon( DWORD dwMessage, PNOTIFYICONDATA pnid );

The dwMessage 可选的参数包括 the NIM_ADD,NIM_DELETE and NIM_MODIFY功能分别是添加删除以及修改图标于系统图标.

PNOTIFYICONDATA 结构包括这些系统需要处理的任务图标状态区域消息等信息.
typedef  struct _NOTIFYICONDATA {
    DWORD cbSize;
    HWND hWnd;
    UINT uID;
    UINT uFlags;
    UINT uCallbackMessage;
    HICON hIcon;
    #if (_WIN32_IE < 0x0500)
        TCHAR szTip[64];
    #else
        TCHAR szTip[128];
    #endif    #if (_WIN32_IE >= 0x0500)
        DWORD dwState;
        DWORD dwStateMask;
        TCHAR szInfo[256];
        union {
            UINT  uTimeout;
            UINT  uVersion;
        } DUMMYUNIONNAME;
        TCHAR szInfoTitle[64];
        DWORD dwInfoFlags;
    #endif    #if (_WIN32_IE >= 0x600)
        GUID guidItem;
    #endif
} NOTIFYICONDATA, *PNOTIFYICONDATA;

*Note: 更完全的信息可以去参考MSDN

Creating the Application

Create a new VC++ dialog based project and call it TrayMin.
创建一个名叫TrayMin的基于对话框的VC++工程

Step: 1

自定义消息于 TrayMinDlg.h 头文件.

				#define WM_TRAY_MESSAGE (WM_USER + 1)
		

The WM_USER 常量用来帮助用户定义自己的消息被用来建立个人的窗口类, 定义时通常用这种格式 WM_USER+X, 这里 X 是一个整形变量.

*更详细的看MSDN

Step: 2

现在在Now add the DECLARE_MESSAGE_MAP() 之前添加下面的用户函数吧（ TrayMinDlg.h file）   afx_msg void OnTrayNotify(WPARAM wParam, LPARAM lParam);
 

当添加一个图标到托盘时这有一个图标的回调消息，注意到 NOTIFYICONDATA 结构中有uCallbackMessage成员是回调消息识别的关键，它会被传给NIM_ADD（我们之后将会见到更详细的）。当添加托盘图标这个事件发生时，系统发送一个回调函数到由hWnd成员对象指定的窗口过程（winproc），wParam 参数可以用来被识别究竟发生了什么操作。lParam参数存放发生事件相关的鼠标或者键盘消息。举个例子，当一个鼠标指针指向一个托盘图标，lParam将包括WM_MOUSEMOVE

Step: 3

现在添加下面的这行在消息宏中（MessageMap）在TrayMinDlg.cpp

ON_MESSAGE(WM_TRAY_MESSAGE,OnTrayNotify)
 

现在应该是这样的.

    BEGIN_MESSAGE_MAP(CTrayMinDlg, CDialog)
      //{{AFX_MSG_MAP(CTrayMinDlg)
      ON_WM_SYSCOMMAND()
      ON_WM_PAINT()
      ON_WM_QUERYDRAGICON()
      ON_MESSAGE(WM_TRAY_MESSAGE ,OnTrayNotify)
      //}}AFX_MSG_MAP
    END_MESSAGE_MAP()

  

Step: 4

现在在TrayMinDlg.cpp 定义OnTrayNotify函数，不要忘记在函数头部添加afx_msg。

  afx_msg void CTrayMinDlg::OnTrayNotify(WPARAM wParam, LPARAM lParam)
  {
    UINT uID; 
    UINT uMsg; 
 
    uID = (UINT) wParam;
    uMsg = (UINT) lParam; 
 
  
    if (uID != 1)
      return;
  
    CPoint pt;  
  
  
    switch (uMsg ) 
    { 

    case WM_LBUTTONDOWN:
      GetCursorPos(&pt);
      ClientToScreen(&pt);
      OnTrayLButtonDown(pt);
      break;
  
    case WM_RBUTTONDOWN:
    case WM_CONTEXTMENU:
      GetCursorPos(&pt);
      OnTrayRButtonDown(pt);
      break;

    } 
    return; 
  }
  

Step: 5

现在在TrayMinDlg类添加两个成员函数来相应鼠标事件。

实现鼠标左键单击的相应

• 函数类型：void  
• 函数声明： OnTrayLButtonDown(CPoint pt)

实现鼠标右键单击的相应

• 函数类型: void
• 函数声明: OnTrayRButtonDown(CPoint pt)

OnTrayLButtonDown(CPoint pt)的定义如下.

				void CTrayMinDlg::OnTrayLButtonDown(CPoint pt)
    {  
      MessageBox("You have clicked Left mouse Button ");
    }
  

The Declaration of OnTrayRButtonDown(CPoint pt) is as following.

				void CTrayMinDlg::OnTrayRButtonDown(CPoint pt)
    {  
      //m_menu is the member of CTrayMinDlg as CMenu m_menu;
      m_menu.GetSubMenu(0)->TrackPopupMenu(TPM_BOTTOMALIGN|
       TPM_LEFTBUTTON|TPM_RIGHTBUTTON,pt.x,pt.y,this);      
    }
  

Step: 6

Add two member variable to the CTrayMinDlg.
为CTrayMinDlg添加两个成员变量

• Variable Type: NOTIFYICONDATA
• Variable Name: m_TrayData;
• Variable Type: CMenu
• Variable Name: m_menu;

现在添加菜单资源

Step: 7

void CShellDlg::OnMinimize() 
  {
    m_TrayData.cbSize = sizeof(NOTIFYICONDATA);
    //Size of this structure, in bytes. 
    
    
    m_TrayData.hWnd  = this->m_hWnd;
    //Handle to the window that receives notification //messages associated with an icon in the taskbar //status area. The Shell uses hWnd and uID to //identify which icon to operate on when //Shell_NotifyIcon is invoked. 
  
    m_TrayData.uID = 1;
    //Application-defined identifier of the taskbar icon.//The Shell uses hWnd and uID to identify which icon //to operate on when Shell_NotifyIcon is invoked. You// can have multiple icons associated with a single //hWnd by assigning each a different uID. 

    m_TrayData.uCallbackMessage  = WM_TRAY_MESSAGE;
    //Application-defined message identifier. The system //uses this identifier to send notifications to the //window identified in hWnd. These notifications are //sent when a mouse event occurs in the bounding //rectangle of the icon, or when the icon is selected //or activated with the keyboard. The wParam parameter //of the message contains the identifier of the taskbar //icon in which the event occurred. The lParam parameter //holds the mouse or keyboard message associated with the// event. For example, when the pointer moves over a //taskbar icon, lParam is set to WM_MOUSEMOVE. 
    


    m_TrayData.hIcon = this->m_hIcon;
    //Handle to the icon to be added, modified, or deleted
    
    strcpy(m_TrayData.szTip,"My Icon");
    //Pointer to a null-terminated string with the text //for a standard ToolTip. It can have a maximum of 64 //characters including the terminating NULL. 
    
    
    m_TrayData.uFlags = NIF_ICON|NIF_MESSAGE;
    //Flags that indicate which of the other members contain 
    valid data.  
  

    BOOL bSuccess = FALSE;
    BOOL BSus = FALSE;

    BSus = m_menu.LoadMenu(IDR_MENU1);
    if(!(BSus))
      MessageBox("Unabled to Loa menu");

    bSuccess = Shell_NotifyIcon(NIM_ADD,&m_TrayData);

    if(!(bSuccess))
      MessageBox("Unable to Set Tary Icon");
    else
    {
      this->ShowWindow(SW_MINIMIZE);
      this->ShowWindow(SW_HIDE);

    }
  }
  
  

Step: 8

在退出菜单的执行函数写下如下

Shell_NotifyIcon(NIM_DELETE,&m_TrayData);
  DestroyWindow();

现在可以运行程序，并且尝试最小化按钮的使用（他会最小化导系统托盘）。
现在尽情发挥，完善这些步骤，完成自己的系统托盘图标吧！

Yasar Arslan

我忘记了我从哪里copy的这些例子代码，他们可是非常简单而有趣的。如果有人知道这些代码的作者，我一定要好好感谢你和这位作者。

注意这里有很多对于没有提及的MFC的支持。像_beginthread（一个C运行时库调用）的API可以在MFC应用程序中替换成AfxBeginThread

无同步（No Synchronization）

这第一个例子描述了两个互不同步的线程。进程中的首要线程--主函数循环，输出全局整形数组的内容。还有一个线程“Thread”不停的给数组每个元素+1。
 The thread called "Thread" continuously populates the global array of integers.

				  #include <process.h>
				  #include <stdio.h>
				int a[ 5 ];
  
  void Thread( void* pParams )
  { int i, num = 0;
  
    while ( 1 )
    { 
       for ( i = 0; i < 5; i++ ) a[ i ] = num;
       num++;
    }
  }
  
  int main( void )
  { 
     _beginthread( Thread, 0, NULL );
  
     while( 1 )
        printf("%d %d %d %d %d\n", 
               a[ 0 ], a[ 1 ], a[ 2 ],
               a[ 3 ], a[ 4 ] );
  
   return0;
  }

注意这个例子的输出，红色的数处在一个主线程抢先于Thread工作过程中执行的打印动作

81751652 81751652 81751651 81751651 81751651
81751652 81751652 81751651 81751651 81751651
83348630 83348630 83348630 83348629 83348629
83348630 83348630 83348630 83348629 83348629
83348630 83348630 83348630 83348629 83348629

关键区域/临界区域 对象（Critical Section Objects）

如果你想让主线程等待Thread线程处理好全局数组再做打印，一种解决方法是使用关键区域对象。
关键区域对象提供同步于使用互斥器（Mutex）对象很相似, 除了关键区域对象之能在一个进程内发挥效用。Event, mutex, 以及 semaphore 对象也可以用在单进程的应用程序中, 但是关键区域对象提供一个相对快捷更加高效的同步机制. 就像互斥器一样, 一个关键区域对象只能同时被一个线程拥有, 这个关键区域能够在同时发生的数据存取时保护共享资源. 获取关键区域的先后顺序不定，可是不用太担心，系统对于每一个线程都是平等的。

     
  CRITICAL_SECTION cs;
  int a[ 5 ];
  
  void Thread( void* pParams )
  {
    int i, num = 0;
  
    while ( TRUE )
    {
       EnterCriticalSection( &cs );
       for ( i = 0; i < 5; i++ ) a[ i ] = num;
       LeaveCriticalSection( &cs );
       num++;
    }
  }
  
  int main( void )

  { 
    InitializeCriticalSection( &cs );
    _beginthread( Thread, 0, NULL );
  
    while( TRUE )
    {
       EnterCriticalSection( &cs );
       printf( "%d %d %d %d %d\n", 
               a[ 0 ], a[ 1 ], a[ 2 ],
               a[ 3 ], a[ 4 ] );
       LeaveCriticalSection( &cs );
    }
    return 0;
  }

If you are running Windows 9x/NT/2000, you can run this program by clicking here.

互斥器（Mutex Objects）

一个互斥器是一个信号状态的同步对象，当它不属于任何一个线程时就用信号来体现，当被拥有时他的信号状态就为None. 同一时刻只有一个线程可以拥有互斥器, 互斥器这个名字来自于他们对于并列的线程存取共享资源时表现出的行为。举个例子,避免两个线程同时写入一个共享内存，每一个线程当需要执行存取共享资源的代码时首先等待直到自己获得拥有权. 在存取共享资源之后，线程释放对互斥器的拥有权。

两个或以上的进程可以调用CreateMutex 来建立同样名字的互斥器. 实际上第一个进程建立的这个互斥器, 随后的进程只是得到了那个存在的互斥器的句柄. 这能使多进程共用一个互斥器, 当然用户应该有确保建立互斥器的进程首先启动的责任. 使用这种技术,你应该将这个 bInitialOwner标记设置成FALSE; 否则, 它可以因不同的进程最初拥有它而带来困难.

多进程可以有同一个mutex对象的句柄, 让mutex对象能够用于多进程间同步. 下面的对象共享机制是适用的:

• 一个子进程通过CreateProcess 函数被建立，当CreateMutex的lpMutexAttributes 参数给予相应的mutex对象指针它可以继承到一个mutex对象的句柄.
• 一个进程可以在DuplicateHandle 函数中指定一个mutex对象句柄来建立一个句柄的拷贝由其他进程使用.
• 一个继承可以指定一个mutex的名字通过 CreateMutex 函数得到这个mutex对象的句柄.

总的来说, 如果你想要进行线程同步，临界区域更高效些.

				#include <windows.h>
				#include <process.h>
				#include <stdio.h>
  
  HANDLE hMutex;
  int a[ 5 ];
  
  void Thread( void* pParams )
  { 
     int i, num = 0;
  
     while ( TRUE )
     { 
        WaitForSingleObject( hMutex, INFINITE );
        for ( i = 0; i < 5; i++ ) a[ i ] = num;
        ReleaseMutex( hMutex );
        num++;
     }
  }
  
  int main( void )
  {
     hMutex = CreateMutex( NULL, FALSE, NULL );
     _beginthread( Thread, 0, NULL );
  
     while( TRUE )

     {
        WaitForSingleObject( hMutex, INFINITE );
        printf( "%d %d %d %d %d\n", 
                a[ 0 ], a[ 1 ], a[ 2 ],
                a[ 3 ], a[ 4 ] );
        ReleaseMutex( hMutex );
     }
     return0;
  }

If you are running Windows 9x/NT/2000, you can run this program by clicking here.

Event Objects事件对象

若我们想要强制第二线程在主线程完成全局数组的内容输出时执行该如何？这样的话每行的输出就只是递增1。

一个事件对象也是一个可以通过SetEvent or PulseEvent 函数设置像信号般的状态的同步对象. 下面是两种类型的事件对象.

event object的用处就在于它可以在它发生时向等待着的线程发出信号标志从而使其wait结束. 举个例子, 在overlapped I/O 操作时, 当异步操作完成时系统设置了那个由程序员指定（specified）的事件对象为信号状态. A 一个单一线程可以指定许多不同的事件对象在许多同时发生的overlapped 操作运作, 调用一个多对象的wait函数可以当任意一个event object激发时结束等待.

在一个线程中可使用 CreateEvent 函数建立一个event object. 在这个线程中指定这个event object 的特性是manual-reset 或者 auto-reset . 在这个线程中也可以命名一个event object. 其他进程中的线程也可以使用 OpenEvent 通过event object的名字打开一个现存event object . 另外关于mutex, event, semaphore, 以及 timer objects的其他信息, 就参考《Interprocess Synchronization》的文章.

一个线程能够用 PulseEvent 函数设置一个event object 为信号状态而后激发当前适当数量的wait线程，之后切换为无信号状态 . 对于一个manual-reset event object, 所有的等待线程被返回（release）. 对于一个auto-reset event object, 这个函数只能释放一个等待的线程, 即使有更多线程在等待. 如果没有线程在函数调用时等待, PulseEvent 只是简单的将事件状态设为无信号并且返回（个人注释，这应该是跟setevent最不相同的地方！）.

Collapse

				  #include <windows.h>
				  #include <process.h>
				  #include <stdio.h>
  
  HANDLE hEvent1, hEvent2;
  int a[ 5 ];
  
  void Thread( void* pParams )
  {
     int i, num = 0;

     while ( TRUE )
     {
        WaitForSingleObject( hEvent2, INFINITE );
        for ( i = 0; i < 5; i++ ) a[ i ] = num;
        SetEvent( hEvent1 );
        num++;
     }
  }
  
  int main( void )
  {
     hEvent1 = CreateEvent( NULL, FALSE, TRUE, NULL );
     hEvent2 = CreateEvent( NULL, FALSE, FALSE, NULL );
  
     _beginthread( Thread, 0, NULL );
  
     while( TRUE )
     { 
        WaitForSingleObject( hEvent1, INFINITE );
        printf( "%d %d %d %d %d\n", 
                a[ 0 ], a[ 1 ], a[ 2 ],
                a[ 3 ], a[ 4 ] );
        SetEvent( hEvent2 );
     }
     return0;
  }

If you are running Windows 9x/NT/2000, you can run this program by clicking here.

Summary of Synchronization Objects

The MSDN News for July/August 1998 has a front page article on Synchronization Objects. The following table is from that article:

by William T. Block

from codeproject

谢谢回复的补充 ~~，上面拼错了个词，改过。。译完了

string stack,requare,start,newStr;
string table;
int num=0,i=0;
void check(string& start,string& stack);
void print(){
  if(newStr==requare)
  cout<<table<<endl;
}
void pushStack(char item,string& start,string& stack){
 table+='i';
 stack+=item;
 check(start,stack);

}
void popStack(string& start,string& stack){
 table+='o';
 newStr+=stack[stack.size()-1];
 stack.erase(stack.size()-1);
 check(start,stack);
}
void delPush(){
  table.erase(table.size()-1);
  stack.erase(stack.size()-1);

}
void delPop(){
  stack+=newStr[newStr.size()-1];
  table.erase(table.size()-1);
  newStr.erase(newStr.size()-1);
}

void check(string& start,string& stack){
 if (num==start.size()*2) {
  print(); 
  return;
 }
 
  
    if((newStr.size()+stack.size())!=start.size()){
    num++;
    pushStack(start[i++],start,stack);
    delPush();
    num--;
    i--;
    }
    if(stack.empty()&&i<start.size()) return;
    num++;
    popStack(start,stack);
    delPop();
    num--;
 
 
}

int main(){

 cin>>start>>requare;

 check(start,stack);
 return 0;
}

很不规范的地柜，还有好多个清理状态的函数。。。
什么时候才能改进阿！！！！！！！！

So far all of the console output I have shown have been in black and white. This part of the tutorial demonstrates how I did this!

Now, before you start getting all excited, let me say from the start, the range of colours available is not huge. You may want to compile and run these programs for yourself, the .jpg's I use on the web site show up fine on the monitor connected to the machine I am using now, but when viewed on my older machine, appear very dark and fuzzy.

We will use the Win32 API function SetConsoleTextAttribute(). This function takes 2 arguments. The first is the standard output handle, we have covered that already. The second is a 16bit WORD bit mask containg 0 or more bits.

It is not necessary to concern yourself over the values of the various bits. There are a series of constants defined in windows.h, (actually in wincon.h but that is included in windows.h), which symbolically allow you to build the required value, it is very easy. Look at this program and it's output.

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

int main()
{
    HANDLE hOut;

    hOut = GetStdHandle(STD_OUTPUT_HANDLE);

    SetConsoleTextAttribute(hOut,
                            FOREGROUND_RED);
    cout << "This text is red." << endl;

    SetConsoleTextAttribute(hOut,
                            FOREGROUND_GREEN);
    cout << "This text is green." << endl;

    SetConsoleTextAttribute(hOut,
                            FOREGROUND_BLUE);
    cout << "This text is blue." << endl;

    return 0;
}

A dingy red green and blue. Being bits, they can be OR'd together to make combinations, the next program shows the result of OR'ing the bits together.

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

int main()
{
    HANDLE hOut;

    hOut = GetStdHandle(STD_OUTPUT_HANDLE);

    SetConsoleTextAttribute(hOut,
                            FOREGROUND_RED | 
                            FOREGROUND_GREEN);
    cout << "This text is yellow." << endl;

    SetConsoleTextAttribute(hOut,
                            FOREGROUND_GREEN | 
                            FOREGROUND_BLUE);
    cout << "This text is cyan." << endl;

    SetConsoleTextAttribute(hOut,
                            FOREGROUND_BLUE | 
                            FOREGROUND_RED);
    cout << "This text is magenta." << endl;

    SetConsoleTextAttribute(hOut,
                            FOREGROUND_RED | 
                            FOREGROUND_GREEN | 
                            FOREGROUND_BLUE);
    cout << "This text is white." << endl;

    return 0;
}

The bitwise OR operator "|" combines the requested bits. Thus red | green gives yellow, green | blue gives cyan, blue | red gives magenta and all three combined gives white. The order is unimportant, red | blue gives the same result as blue | red.

Another bit that can be OR'd in is FOREGROUND_INTENSITY. All the colours I've shown so far are a bit dim, adding the intensity bit brightens them up. This program shows the use and results of the intensity bit.

#include <windows.h>
#include <iostream>
using namespace std;

int main()
{
    HANDLE hOut;

    hOut = GetStdHandle(STD_OUTPUT_HANDLE);

    SetConsoleTextAttribute(hOut,
                            FOREGROUND_RED);
    cout << "Red     " << flush;
    SetConsoleTextAttribute(hOut,
                            FOREGROUND_RED |
                            FOREGROUND_INTENSITY);
    cout << "Red" << endl;

    SetConsoleTextAttribute(hOut,
                            FOREGROUND_GREEN);
    cout << "Green   " << flush;
    SetConsoleTextAttribute(hOut,
                            FOREGROUND_GREEN |
                            FOREGROUND_INTENSITY);
    cout << "Green" << endl;

    SetConsoleTextAttribute(hOut,
                            FOREGROUND_BLUE);
    cout << "Blue    " << flush;
    SetConsoleTextAttribute(hOut,
                            FOREGROUND_BLUE |
                            FOREGROUND_INTENSITY);
    cout << "Blue" << endl;

    SetConsoleTextAttribute(hOut,
                            FOREGROUND_RED | 
                            FOREGROUND_GREEN);
    cout << "Yellow  " << flush;
    SetConsoleTextAttribute(hOut,
                            FOREGROUND_RED | 
                            FOREGROUND_GREEN |
                            FOREGROUND_INTENSITY);
    cout << "Yellow" << endl;

    SetConsoleTextAttribute(hOut,
                            FOREGROUND_GREEN | 
                            FOREGROUND_BLUE);
    cout << "Cyan    " << flush;
    SetConsoleTextAttribute(hOut,
                            FOREGROUND_GREEN | 
                            FOREGROUND_BLUE |
                            FOREGROUND_INTENSITY);
    cout << "Cyan" << endl;

    SetConsoleTextAttribute(hOut,
                            FOREGROUND_BLUE | 
                            FOREGROUND_RED);
    cout << "Magenta " << flush;
    SetConsoleTextAttribute(hOut,
                            FOREGROUND_BLUE | 
                            FOREGROUND_RED |
                            FOREGROUND_INTENSITY);
    cout << "Magenta" << endl;

    SetConsoleTextAttribute(hOut,
                            FOREGROUND_RED | 
                            FOREGROUND_GREEN | 
                            FOREGROUND_BLUE);
    cout << "White   " << flush;
    SetConsoleTextAttribute(hOut,
                            FOREGROUND_RED | 
                            FOREGROUND_GREEN | 
                            FOREGROUND_BLUE |
                            FOREGROUND_INTENSITY);
    cout << "White" << endl;

    return 0;
}

Black is also a colour, and is made by having no foreground colors set, no red and no green and no blue is nothing, is black. So in all we have 15 colours. I did warn you not to get excited.

In addition to changing the foreground colour, we can also change the background colour. The same colours are available.

#include <windows.h>
#include <iostream>
using namespace std;

int main()
{
    HANDLE hOut;

    hOut = GetStdHandle(STD_OUTPUT_HANDLE);

    SetConsoleTextAttribute(hOut,
                            BACKGROUND_RED);
    cout << "Red     " << flush;
    SetConsoleTextAttribute(hOut,
                            BACKGROUND_RED |
                            BACKGROUND_INTENSITY);
    cout << "Red     " << endl;

    SetConsoleTextAttribute(hOut,
                            BACKGROUND_GREEN);
    cout << "Green   " << flush;
    SetConsoleTextAttribute(hOut,
                            BACKGROUND_GREEN |
                            BACKGROUND_INTENSITY);
    cout << "Green   " << endl;

    SetConsoleTextAttribute(hOut,
                            BACKGROUND_BLUE);
    cout << "Blue    " << flush;
    SetConsoleTextAttribute(hOut,
                            BACKGROUND_BLUE |
                            BACKGROUND_INTENSITY);
    cout << "Blue    " << endl;

    SetConsoleTextAttribute(hOut,
                            BACKGROUND_RED | 
                            BACKGROUND_GREEN);
    cout << "Yellow  " << flush;
    SetConsoleTextAttribute(hOut,
                            BACKGROUND_RED | 
                            BACKGROUND_GREEN |
                            BACKGROUND_INTENSITY);
    cout << "Yellow  " << endl;

    SetConsoleTextAttribute(hOut,
                            BACKGROUND_GREEN | 
                            BACKGROUND_BLUE);
    cout << "Cyan    " << flush;
    SetConsoleTextAttribute(hOut,
                            BACKGROUND_GREEN | 
                            BACKGROUND_BLUE |
                            BACKGROUND_INTENSITY);
    cout << "Cyan    " << endl;

    SetConsoleTextAttribute(hOut,
                            BACKGROUND_BLUE | 
                            BACKGROUND_RED);
    cout << "Magenta " << flush;
    SetConsoleTextAttribute(hOut,
                            BACKGROUND_BLUE | 
                            BACKGROUND_RED |
                            BACKGROUND_INTENSITY);
    cout << "Magenta " << endl;

    SetConsoleTextAttribute(hOut,
                            BACKGROUND_RED | 
                            BACKGROUND_GREEN | 
                            BACKGROUND_BLUE);
    cout << "White   " << flush;
    SetConsoleTextAttribute(hOut,
                            BACKGROUND_RED | 
                            BACKGROUND_GREEN | 
                            BACKGROUND_BLUE |
                            BACKGROUND_INTENSITY);
    cout << "White   " << endl;

    return 0;
}

A space character will just show up as the coloured background. That is how I made the Danish flag at the top of this section.

It is possible to set both the foreground and background colours, here for example, I set the background to low intensity yellow and the foreground to high intensity cyan.

#include <windows.h>
#include <iostream>
using namespace std;

int main()
{
    HANDLE hOut;

    hOut = GetStdHandle(STD_OUTPUT_HANDLE);

    SetConsoleTextAttribute(hOut,
                            BACKGROUND_GREEN |
                            BACKGROUND_RED |
                            FOREGROUND_GREEN | 
                            FOREGROUND_BLUE |
                            FOREGROUND_INTENSITY);
    cout << "Intense Cyan on yellow background." << endl;

    return 0;
}

You can use any combination you like of the available colours, although obviously, setting the foreground and background colour to the same value is a little pointless. Remember also, that setting no foreground bits gives black text, and no background bits, a black background.

A common "gotcha" is forgetting that both the foreground AND background must be set at each call. If you want to write first in green then in red on a yellow background you must set the background in both calls, otherwise the function assumes you want to return to a black background.

#include <windows.h>
#include <iostream>
using namespace std;

int main()
{
    HANDLE hOut;

    hOut = GetStdHandle(STD_OUTPUT_HANDLE);

    SetConsoleTextAttribute(hOut,
                            BACKGROUND_GREEN |
                            BACKGROUND_RED |
                            FOREGROUND_GREEN | 
                            FOREGROUND_INTENSITY);
    cout << "Green " << flush;
    SetConsoleTextAttribute(hOut,
                            BACKGROUND_GREEN |
                            BACKGROUND_RED |
                            FOREGROUND_RED |
                            FOREGROUND_INTENSITY);
    cout << "Red" << endl;

    return 0;
}

If you are going to do a lot of colour changes, rather than OR'ing everything together each time, you may prefer to do it once using a #define. Here, I #define FRI to be Foreground Red Intense, BC to be Background Cyan, FW to Foreground White and BNULL to Background "Nothing" i.e. black. Using these in a small test program does not really make much difference, but in large programs with many colour changes, the code can be much shorter using this technique.

#include <windows.h>
#include <iostream>
using namespace std;

#define FRI FOREGROUND_RED |\
            FOREGROUND_INTENSITY
#define FW  FOREGROUND_RED |\
            FOREGROUND_GREEN |\
            FOREGROUND_BLUE
#define BC  BACKGROUND_GREEN |\
            BACKGROUND_BLUE
#define BNULL 0

int main()
{
    HANDLE hOut;

    hOut = GetStdHandle(STD_OUTPUT_HANDLE);

    cout << "Normal " << flush;

    SetConsoleTextAttribute(hOut,
                            FRI | BC);

    cout <<"coloured" << flush;

    SetConsoleTextAttribute(hOut,
                            FW | BNULL);

    cout << " and back." << endl;

    return 0;
}

Note the backslashes in the #defines, this is necessary when extending a #define onto more than one line. You don't have to do this of course if you are happy with long lines/horizontal scrolling. Finally, in this section, here is a header file that contains a full set of #defines. To use it, copy the code and paste it into a file with a .h extension, say "ShortColours.h" for example. Put a copy of this file into the same directory as your code file, and include it into your program like this.

#include "ShortColours.h"

Enclosing the header file name in quotes rather than a less than/greater than pair tells the compiler to look in the same directory as the code.

#ifndef SHORTCOLOURS_H
#define SHORTCOLOURS_H

#define FW FOREGROUND_RED | \
           FOREGROUND_GREEN | \
           FOREGROUND_BLUE
#define FR FOREGROUND_RED
#define FG FOREGROUND_GREEN
#define FB FOREGROUND_BLUE
#define FY FOREGROUND_RED | \
           FOREGROUND_GREEN
#define FC FOREGROUND_GREEN | \
           FOREGROUND_BLUE
#define FM FOREGROUND_BLUE | \
           FOREGROUND_RED 
#define FWI FOREGROUND_RED | \
            FOREGROUND_GREEN | \
            FOREGROUND_BLUE | \
            FOREGROUND_INTENSITY
#define FRI FOREGROUND_RED | \
            FOREGROUND_INTENSITY
#define FGI FOREGROUND_GREEN | \
            FOREGROUND_INTENSITY
#define FBI FOREGROUND_BLUE | \
            FOREGROUND_INTENSITY
#define FYI FOREGROUND_RED | \
            FOREGROUND_GREEN | \
            FOREGROUND_INTENSITY
#define FCI FOREGROUND_GREEN | \
            FOREGROUND_BLUE | \
            FOREGROUND_INTENSITY
#define FMI FOREGROUND_BLUE | \
            FOREGROUND_RED | \
            FOREGROUND_INTENSITY 
#define FNULL 0
 
#define BW BACKGROUND_RED | \
           BACKGROUND_GREEN | \
           BACKGROUND_BLUE
#define BR BACKGROUND_RED
#define BG BACKGROUND_GREEN
#define BB BACKGROUND_BLUE
#define BY BACKGROUND_RED | \
           BACKGROUND_GREEN
#define BC BACKGROUND_GREEN | \
           BACKGROUND_BLUE
#define BM BACKGROUND_BLUE | \
           BACKGROUND_RED 
#define BWI BACKGROUND_RED | \
            BACKGROUND_GREEN | \
            BACKGROUND_BLUE | \
            BACKGROUND_INTENSITY
#define BRI BACKGROUND_RED | \
            BACKGROUND_INTENSITY
#define BGI BACKGROUND_GREEN | \
            BACKGROUND_INTENSITY
#define BBI BACKGROUND_BLUE | \
            BACKGROUND_INTENSITY
#define BYI BACKGROUND_RED | \
            BACKGROUND_GREEN | \
            BACKGROUND_INTENSITY
#define BCI BACKGROUND_GREEN | \
            BACKGROUND_BLUE | \
            BACKGROUND_INTENSITY
#define BMI BACKGROUND_BLUE | \
            BACKGROUND_RED | \
            BACKGROUND_INTENSITY 
#define BNULL 0

#endif

This program produces the same output as the last.

#include <windows.h>
#include <iostream>
#include "ShortColours.h"
using namespace std;

int main()
{
    HANDLE hOut;

    hOut = GetStdHandle(STD_OUTPUT_HANDLE);

    cout << "Normal " << flush;

    SetConsoleTextAttribute(hOut,
                            FRI | BC);

    cout <<"coloured" << flush;

    SetConsoleTextAttribute(hOut,
                            FW | BNULL);

    cout << " and back." << endl;

    return 0;
}

The colour support is not great, but at the end of the day, it can be good enough. Consider, there are probably many of you that have played, or at least seen "BattleChess", where the pieces animated battle when one captured another. I bet nobody played it for long, because after you've seen the animations, they simply slow the game down, and the AI behind the graphics was actually not very good.

You build a really good chess playing AI and put it behind a simple interface like this, people will use it over and over, because, it is good enough to get the job done.

In part 2 of the tutorial, I showed you how to use ReadConsoleOutputCharacter() to retrieve the characters at one or more screen buffer locations. By itself, it is not capable of recovering the foreground and background attributes those characters were written with. This information is also available, the API routine used is ReadConsoleOutputAttribute(), and is really very similar to ReadConsoleOutputCharacter(). The prototype is shown here.

BOOL ReadConsoleOutputAttribute(
  HANDLE hConsoleOutput,
  LPWORD lpAttribute,
  DWORD nLength,
  COORD dwReadCoord,
  LPDWORD lpNumberOfAttrsRead
);

This program sets the foreground colout to FOREGROUND_GREEN | FOREGROUND_RED and outputs a string. It then uses ReadConsoleOutputAttribute() to retrieve the attribute of the character at (4,0). The result is 6, this is because FOREGROUND_GREEN is defined to have the value 0x0002 and FOREGROUND_RED 0x0004. 2+4=6. It may be tempting to use the numerical values rather than the defined constants, but this is not a good idea. At some time in the future, MicroSoft may change the values associated with the constants, (unlikely, but a reserved possibility). Using the constants, the code will still work, use the values and the results may be unpredictable.

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

int main()
{
    HANDLE hOut;
    WORD Attribute;
    COORD Where;
    unsigned long NumRead;

    hOut = GetStdHandle(STD_OUTPUT_HANDLE);

    SetConsoleTextAttribute(hOut,
                            FOREGROUND_GREEN | 
                            FOREGROUND_RED);

    cout << "This text is yellow." << endl;

    Where.X = 4;
    Where.Y = 0;
    ReadConsoleOutputAttribute(hOut,
                               &Attribute,
                               1,
                               Where,
                               &NumRead);

    cout << "Attribute is " << Attribute << endl;

    return 0;
}

The output looks like this.

In the next part of the tutorial, we'll investigate keyboard and mouse events.

I recommend you compile and run this program. It will display the printable characters available to your console. If your console is a different size from mine, you may need to adjust the values for x and y, but this should be trivial. The rest of the tutorial assumes your character map is the same as mine - it should be, but it is possible if you have a different language set loaded into your system the positions of some of these characters may be different, run this, check them and modify the values used later accordingly, (frankly, I've worked with several language settings and never seen the character map to be different, but I'm told it is possible!).

#include <windows.h>
#include <iostream>
using namespace std;

int main()
{
    HANDLE hOut;
    int i;
    int x = 0;
    int y = 0;
    COORD Position;

    hOut = GetStdHandle(STD_OUTPUT_HANDLE);

    for (i=32; i<=255; i++)
    {
        Position.X = x;
        Position.Y = y;
        SetConsoleCursorPosition(hOut,
                                 Position);

        cout.width(3);
        cout << i << " " << (unsigned char)i << flush;

        ++y;
        if(y > 20)
        {
            y = 0;
            x += 6;
        }
    }

    Position.X = 0;
    Position.Y = 22;
    SetConsoleCursorPosition(hOut,
                             Position);
    return 0;
}

Of particular interest to this part of the tutorial are the values between 179 and 218. Shown below is the relevent part of the output from the program.

If you remember part 1 of this tutorial, I said the "normal" characters in the console font filled a 7x11 grid in a larger 8x12 character cell which had the top and row and right column blank to allow for spacing. As you can see from the picture above, these are not normal characters, some have already merged with those above and below them to give some strange glyphs that look like a cross between sanskrit and klingon! Here is the same character range more spread out and easier to see.

Unlike the normal alpha-numerics, (0-9, A-Z, a-z), and puntuation characters, where space between the individual characters is important for clarity, these characters do not have space above and to the right, they run all the way to the edge of their character cell and are designed to be merged. With these characters one can draw lines, boxes and grids. Have a look at this program output for some idea of what you can do.

The figures look a little stupid when drawn this size, but I have done this to keep the size of the image files down, so they load faster, you can make them any size, and if you inspect the character map, you will see that these are not the only possibilities.

To draw these examples, I wrote a very crude function which draws a character at a specified location on the screen, it is shown here.

void At(int x, int y, unsigned char What)
{
    static HANDLE hOut;
    static bool First = TRUE;
    COORD Position;

    if(First)
    {
        hOut = GetStdHandle(STD_OUTPUT_HANDLE);
        First = FALSE;
    }

    Position.X = x;
    Position.Y = y;
    
    SetConsoleCursorPosition(hOut,
                             Position);
    
    cout << What << flush;

    return;
}

As you can see, there is no error or range checking, it simply assumes you know what you are doing. The function retrieves the standard output handle and stores it statically the first time the it is invoked.

This code snippet shows the calls necessary to draw the first box.

    At(9, 0, (unsigned char) 218);
    At(10, 0, (unsigned char) 196);
    At(11, 0, (unsigned char) 191);
    At(9, 1, (unsigned char) 179);
    At(10, 1, (unsigned char) 32);
    At(11, 1, (unsigned char) 179);
    At(9, 2, (unsigned char) 192);
    At(10, 2, (unsigned char) 196);
    At(11, 2, (unsigned char) 217);

Given the character table above and this simple example, (32 is the space character by the way), you should have enough information to create all kinds of boxes, grids, mazes, forms etc. The very playable adventure game "Caverns of Moria" known to many VAX/VMS and UNIX users had a user interface that could easily be copied using these simple graphics.

Whilst drawing boxes or at any time it becomes appropriate, you may want to hide or modify the appearance of the cursor. You can do this with another API routine, SetConsoleCursorInfo(). This takes 2 parameters, the standard output handle, and a pointer to a CONSOLE_CURSOR_INFO structure. This is another relatively simple Windows defined structure. It is looks like this.

typedef struct _CONSOLE_CURSOR_INFO {
    DWORD  dwSize; 
    BOOL   bVisible; 
} CONSOLE_CURSOR_INFO, *PCONSOLE_CURSOR_INFO; 

The first value is a simple integer in the range 1-100, it specifies how much of the character cell the cursor occupies is filled. The program here sets the cursor size to 50. The 3 pictures below show the sizes 1, 50 and 100, you can, of course, use any integer in the range. Note the use of the "&" in front of the ConCurInf, remember, the routine expects a pointer to the structure you have declared.

#include <windows.h>

int main()
{
    HANDLE hOut;
    CONSOLE_CURSOR_INFO ConCurInf;

    hOut = GetStdHandle(STD_OUTPUT_HANDLE);

    SetConsoleTitle("Size 50");

    ConCurInf.dwSize = 50;
    ConCurInf.bVisible = TRUE;

    SetConsoleCursorInfo(hOut,
                         &ConCurInf);

    return 0;
}

The other value is a boolean field and indicates whether the cursor is visible or not. A value of TRUE, (the default), means the cursor is visible, FALSE and it is invisible. The followng program turns the cursor off.

#include <windows.h>

int main()
{
    HANDLE hOut;
    CONSOLE_CURSOR_INFO ConCurInf;

    hOut = GetStdHandle(STD_OUTPUT_HANDLE);

    SetConsoleTitle("No Cursor");

    ConCurInf.dwSize = 10;
    ConCurInf.bVisible = FALSE;

    SetConsoleCursorInfo(hOut,
                         &ConCurInf);

    return 0;
}

To turn the cursor back on, call the function again with the bVisible member set TRUE.

It is a good idea to set up both values, especially the first time you call the function. If you set up bVisible but leave dwSize uninitialised, the unspecified value may be zeroed, or contain a random value, in either case, it could be out of the range 1-100, and the routine will fail. Similaly, if you want to change the size of the cursor, and don't set bVisible to be TRUE, your compiler may have zeroed the uninitialised field and the cursor will disappear instead of changing size. As always, if you check the return value of the call, you will see if any errors have happened along the way.

Remember, the cursor is there to show where the character insertion point is. Setting the cursor to invisible does not change that. Remember also, the cursor is very useful, it shows your user "where they are" on your screen, if you take it away, you must be sure you have other means available that enable your user to navigate the screen.

In the next part of this tutorial, we'll explore the colour issues.

I started part 1 of this tutorial by showing the classic "Hello Worlrd!" program. The output looked like this.

By default, Windows places the path of the executable in the window title. You can change this to a word or phrase of your choice. Here is the Hello World! program modified to do this.

#include <windows.h>
#include <iostream>
using namespace std;

int main()
{
    SetConsoleTitle("Hello!");
    cout << "Hello World!" << endl;
    return 0;
}

Notice I've now added the windows.h header to the program, and a call to SetConsoleTitle(). The output now looks like this.

Later on, we'll see that knowing the name of your window can be useful, and setting it yourself is, of course, an easy way of knowing it!

As an aside, almost all of the API routines return a status indicating success or failure. For clarity of the example code in these tutorials, I am not checking this value. To be more professional, you should check the return values of API routines you call. Even if you cannot recover from the error, it is often useful in debugging to know what routine failed, and if possible, why. This program shows the checking of the return status and aborts the program if the routine fails, (note the inclusion of process.h for the exit() API routine). You should refer to your compiler's help or MSDN to see what the return values of a routine are.

#include <windows.h>
#include <process.h>
#include <iostream>
using namespace std;

int main()
{
    int Status;

    Status = SetConsoleTitle("Hello!");
    if (Status == 0)
    {
        Status = GetLastError();
        cout << "SetConsoleTitle() failed! Reason : " << Status << endl;
        exit(Status);
    }

    cout << "Hello World!" << endl;
    return 0;
}

All consoles have 3 "standard handles" and many of the console handling functions require a "handle" to perform I/O.

A "handle" is simply a 32 bit integer. It is the way Windows differentiates between objects of the same type. Consider the console, it has a title bar, minimize, maximize and close buttons, one or more scroll bars, etc. It is, when you think about it, quite a complicated thing, and somewhere there must be a lot of data that the system is using to make it all work. Windows hides all of that complexity from you, you can play with all this data if you want to of course, but the point here is, you don't have to if you don't want to. Windows looks after it all for you, and all you have to do is tell it the handle of whatever it is you want to use. Once you get into full Windows programming, you'll find a lot of things are used by supplying a "handle". If you don't understand right now, don't worry about it, a handle is easy to get, and easy to use.

To get the standard handles, declare variable of type HANDLE and initialise them with a call to GetStdHandle(). This program, (which doesn't actually do anything!), illustrates the process. We'll use the standard handles later.

#include <windows.h>

int main()
{
    HANDLE hIn;
    HANDLE hOut;
    HANDLE hError;

    hIn = GetStdHandle(STD_INPUT_HANDLE);
    hOut = GetStdHandle(STD_OUTPUT_HANDLE);
    hError = GetStdHandle(STD_ERROR_HANDLE);

    return 0;
}

The standard input handle is used with routines that read data from a console, the standard output handle with routines that send data to a console. The standard error handle also outputs to the console by default, and frankly is not used very much, just be aware of it.

There are a couple of routines ReadConsole() and WriteConsole() that perform I/O using these handles, but for now at least, we'll continue with the standard C++ I/O functions.

Now we've got the handles, lets do something with them, let's move the cursor around. To do this we'll need to use a COORD structure. This is a very simple structure containing an x and y coordinate. It is declared like this.

typedef struct _COORD {
    SHORT X;
    SHORT Y;
} COORD; 

To move the cursor, you simply set up the COORD to the coordinates you want the cursor moved to and call the SetConsoleCursorPosition() API function. Here is a simple program which does just that.

#include <windows.h>
#include <iostream>
using namespace std;

int main()
{
    HANDLE hOut;
    int i;
    COORD Position;

    hOut = GetStdHandle(STD_OUTPUT_HANDLE);

    for(i=0; i<10; i+=2)
    {
        Position.X = i;
        Position.Y = i;
        SetConsoleCursorPosition(hOut,
                                 Position);
        cout << "*" << flush;
    }

    return 0;
}

The output looks like this.

As you see, each iteration of the loop moves the cursor two rows down and two columns right. To return the cursor to the "home" position, (top left corner), send it to (0,0). Creative use of this function can give pleasing effects.

The next routine I want to show you is FillConsoleOutputCharacter(). This routine allows you to write a whole load of characters to the console in one go. The function prototype is shown here.

BOOL FillConsoleOutputCharacter(
  HANDLE hConsoleOutput,
  TCHAR cCharacter,
  DWORD nLength,
  COORD dwWriteCoord,
  LPDWORD lpNumberOfCharsWritten
);

A bit more complicated then any of the routines we've used so far, but really very easy to use. The first parameter is the handle to the output buffer, you know how to get that. The next is the character you want to write, easy enough. The next, is how many times you want it to write the character out, still easy. Next is a COORD telling it where to start, we've already covered that. Finally, the routine wants a place where it can tell you how many characters it actually wrote, this has to be therefore, the address of a variable in your program. You may be wondering why this argument is there at all, but consider the situation where your screen buffer is, for example, 5000 characters long. If you tell the routine to output 5100, it will not error, it will fill the 5000 characters, and then tell you that it did that by setting the value accordingly. If you're not interested, ignore it, but you must supply a place for the routine to use, in this case, I've passed the address of the "Written" variable like this &Written.

This program uses FillConsoleOutputCharacter() to draw a line of 15 "X" characters starting at (4,4), the unsuprising output of the program is also shown below.

#include <windows.h>
#include <iostream>
using namespace std;

int main()
{
    HANDLE hOut;
    COORD Position;
    DWORD Written;

    hOut = GetStdHandle(STD_OUTPUT_HANDLE);

    Position.X = 4;
    Position.Y = 4;

    FillConsoleOutputCharacter(hOut,
                               'X',
                               15,
                               Position,
                               &Written);

    return 0;
}

See what happens if I change the call to output 150 instead of 15 characters, (I've shrunk the picture to make it load faster - changing the call did not change the screen resolution!!!).

The point to note is that when the routine reached the end of the line, it continued at the beginning of the line below. Suppose, instead of line 5 column 5 I'd said (0,0), and suppose I'd used a space character instead of an 'X', and suppose I'd told it to draw enough characters to completely fill the screen buffer - hey - I've cleared the screen! Clearing the screen is THE most common console related question that comes up in the forums, there's the answer.

It is also possible to read one or more characters from a specific position in the screen buffer. To do that, we use the ReadConsoleOutputCharacter() API routine. This routine has very similar parameters to the last, it's prototype is shown here.

BOOL ReadConsoleOutputCharacter(
  HANDLE hConsoleOutput,
  LPTSTR lpCharacter,
  DWORD nLength,
  COORD dwReadCoord,
  LPDWORD lpNumberOfCharsRead 
);

As before, the first is the standard handle. Next, remember, we are reading now, so the routine wants somewhere to write the information to, so it needs a pointer to a place where it can store characters. The rest of the parameters are as before, the number of characters to process, the start point, and a pointer to a place it can write the actual number read.

This program uses the routine twice, once to retrieve the single character at the (0,0) position, and a second time to retrieve 5 characters starting from position (4,0). If the number of characters requested is longer than the current line, reading continues from the first character of the line below as before. Again, as before, if the number requested is more than there are in the buffer, the characters up to the end of the buffer are returned, the actual number appearing in the final parameter.

#include <windows.h>
#include <iostream>
using namespace std;

int main()
{
    HANDLE hOut;
    char Letter;
    char Letters[5];
    COORD Where;
    DWORD NumRead;
    int i;

    hOut = GetStdHandle(STD_OUTPUT_HANDLE);

    cout << "A line of little consequence." << endl;

    Where.X = 0;
    Where.Y = 0;
    ReadConsoleOutputCharacter(hOut,
                               &Letter,
                               1,
                               Where,
                               &NumRead);
    cout << "Letter at (0,0) is " << Letter << endl;

    Where.X = 4;
    ReadConsoleOutputCharacter(hOut,
                               Letters,
                               5,
                               Where,
                               &NumRead);
    cout << "5 letters starting from (4,0) ";
    for (i=0; i<5; i++)
    {
        cout << Letters[i];
    }
    cout << endl;

    return 0;
}

The output from the program looks like this.

It would have been quite permissable to dimension the Letters array to 6, read the 5 characters from the console then manually set the final character to NULL. In that way, the cout could have taken the name of the string, (as it is now NULL terminated), instead of writing the characters out individually in a loop.

In the next part of the tutorial, we'll look at the limited graphical capabilities of consoles, drawing lines, boxes and grids.

Win32 Console Applications - Part 2.

I started part 1 of this tutorial by showing the classic "Hello Worlrd!" program. The output looked like this.

By default, Windows places the path of the executable in the window title. You can change this to a word or phrase of your choice. Here is the Hello World! program modified to do this.

#include <windows.h>
#include <iostream>
using namespace std;

int main()
{
    SetConsoleTitle("Hello!");
    cout << "Hello World!" << endl;
    return 0;
}

Notice I've now added the windows.h header to the program, and a call to SetConsoleTitle(). The output now looks like this.

Later on, we'll see that knowing the name of your window can be useful, and setting it yourself is, of course, an easy way of knowing it!

As an aside, almost all of the API routines return a status indicating success or failure. For clarity of the example code in these tutorials, I am not checking this value. To be more professional, you should check the return values of API routines you call. Even if you cannot recover from the error, it is often useful in debugging to know what routine failed, and if possible, why. This program shows the checking of the return status and aborts the program if the routine fails, (note the inclusion of process.h for the exit() API routine). You should refer to your compiler's help or MSDN to see what the return values of a routine are.

#include <windows.h>
#include <process.h>
#include <iostream>
using namespace std;

int main()
{
    int Status;

    Status = SetConsoleTitle("Hello!");
    if (Status == 0)
    {
        Status = GetLastError();
        cout << "SetConsoleTitle() failed! Reason : " << Status << endl;
        exit(Status);
    }

    cout << "Hello World!" << endl;
    return 0;
}

All consoles have 3 "standard handles" and many of the console handling functions require a "handle" to perform I/O.

A "handle" is simply a 32 bit integer. It is the way Windows differentiates between objects of the same type. Consider the console, it has a title bar, minimize, maximize and close buttons, one or more scroll bars, etc. It is, when you think about it, quite a complicated thing, and somewhere there must be a lot of data that the system is using to make it all work. Windows hides all of that complexity from you, you can play with all this data if you want to of course, but the point here is, you don't have to if you don't want to. Windows looks after it all for you, and all you have to do is tell it the handle of whatever it is you want to use. Once you get into full Windows programming, you'll find a lot of things are used by supplying a "handle". If you don't understand right now, don't worry about it, a handle is easy to get, and easy to use.

To get the standard handles, declare variable of type HANDLE and initialise them with a call to GetStdHandle(). This program, (which doesn't actually do anything!), illustrates the process. We'll use the standard handles later.

#include <windows.h>

int main()
{
    HANDLE hIn;
    HANDLE hOut;
    HANDLE hError;

    hIn = GetStdHandle(STD_INPUT_HANDLE);
    hOut = GetStdHandle(STD_OUTPUT_HANDLE);
    hError = GetStdHandle(STD_ERROR_HANDLE);

    return 0;
}

The standard input handle is used with routines that read data from a console, the standard output handle with routines that send data to a console. The standard error handle also outputs to the console by default, and frankly is not used very much, just be aware of it.

There are a couple of routines ReadConsole() and WriteConsole() that perform I/O using these handles, but for now at least, we'll continue with the standard C++ I/O functions.

Now we've got the handles, lets do something with them, let's move the cursor around. To do this we'll need to use a COORD structure. This is a very simple structure containing an x and y coordinate. It is declared like this.

typedef struct _COORD {
    SHORT X;
    SHORT Y;
} COORD; 

To move the cursor, you simply set up the COORD to the coordinates you want the cursor moved to and call the SetConsoleCursorPosition() API function. Here is a simple program which does just that.

#include <windows.h>
#include <iostream>
using namespace std;

int main()
{
    HANDLE hOut;
    int i;
    COORD Position;

    hOut = GetStdHandle(STD_OUTPUT_HANDLE);

    for(i=0; i<10; i+=2)
    {
        Position.X = i;
        Position.Y = i;
        SetConsoleCursorPosition(hOut,
                                 Position);
        cout << "*" << flush;
    }

    return 0;
}

The output looks like this.

As you see, each iteration of the loop moves the cursor two rows down and two columns right. To return the cursor to the "home" position, (top left corner), send it to (0,0). Creative use of this function can give pleasing effects.

The next routine I want to show you is FillConsoleOutputCharacter(). This routine allows you to write a whole load of characters to the console in one go. The function prototype is shown here.

BOOL FillConsoleOutputCharacter(
  HANDLE hConsoleOutput,
  TCHAR cCharacter,
  DWORD nLength,
  COORD dwWriteCoord,
  LPDWORD lpNumberOfCharsWritten
);

A bit more complicated then any of the routines we've used so far, but really very easy to use. The first parameter is the handle to the output buffer, you know how to get that. The next is the character you want to write, easy enough. The next, is how many times you want it to write the character out, still easy. Next is a COORD telling it where to start, we've already covered that. Finally, the routine wants a place where it can tell you how many characters it actually wrote, this has to be therefore, the address of a variable in your program. You may be wondering why this argument is there at all, but consider the situation where your screen buffer is, for example, 5000 characters long. If you tell the routine to output 5100, it will not error, it will fill the 5000 characters, and then tell you that it did that by setting the value accordingly. If you're not interested, ignore it, but you must supply a place for the routine to use, in this case, I've passed the address of the "Written" variable like this &Written.

This program uses FillConsoleOutputCharacter() to draw a line of 15 "X" characters starting at (4,4), the unsuprising output of the program is also shown below.

#include <windows.h>
#include <iostream>
using namespace std;

int main()
{
    HANDLE hOut;
    COORD Position;
    DWORD Written;

    hOut = GetStdHandle(STD_OUTPUT_HANDLE);

    Position.X = 4;
    Position.Y = 4;

    FillConsoleOutputCharacter(hOut,
                               'X',
                               15,
                               Position,
                               &Written);

    return 0;
}

See what happens if I change the call to output 150 instead of 15 characters, (I've shrunk the picture to make it load faster - changing the call did not change the screen resolution!!!).

The point to note is that when the routine reached the end of the line, it continued at the beginning of the line below. Suppose, instead of line 5 column 5 I'd said (0,0), and suppose I'd used a space character instead of an 'X', and suppose I'd told it to draw enough characters to completely fill the screen buffer - hey - I've cleared the screen! Clearing the screen is THE most common console related question that comes up in the forums, there's the answer.

It is also possible to read one or more characters from a specific position in the screen buffer. To do that, we use the ReadConsoleOutputCharacter() API routine. This routine has very similar parameters to the last, it's prototype is shown here.

BOOL ReadConsoleOutputCharacter(
  HANDLE hConsoleOutput,
  LPTSTR lpCharacter,
  DWORD nLength,
  COORD dwReadCoord,
  LPDWORD lpNumberOfCharsRead 
);

As before, the first is the standard handle. Next, remember, we are reading now, so the routine wants somewhere to write the information to, so it needs a pointer to a place where it can store characters. The rest of the parameters are as before, the number of characters to process, the start point, and a pointer to a place it can write the actual number read.

This program uses the routine twice, once to retrieve the single character at the (0,0) position, and a second time to retrieve 5 characters starting from position (4,0). If the number of characters requested is longer than the current line, reading continues from the first character of the line below as before. Again, as before, if the number requested is more than there are in the buffer, the characters up to the end of the buffer are returned, the actual number appearing in the final parameter.

#include <windows.h>
#include <iostream>
using namespace std;

int main()
{
    HANDLE hOut;
    char Letter;
    char Letters[5];
    COORD Where;
    DWORD NumRead;
    int i;

    hOut = GetStdHandle(STD_OUTPUT_HANDLE);

    cout << "A line of little consequence." << endl;

    Where.X = 0;
    Where.Y = 0;
    ReadConsoleOutputCharacter(hOut,
                               &Letter,
                               1,
                               Where,
                               &NumRead);
    cout << "Letter at (0,0) is " << Letter << endl;

    Where.X = 4;
    ReadConsoleOutputCharacter(hOut,
                               Letters,
                               5,
                               Where,
                               &NumRead);
    cout << "5 letters starting from (4,0) ";
    for (i=0; i<5; i++)
    {
        cout << Letters[i];
    }
    cout << endl;

    return 0;
}

The output from the program looks like this.

It would have been quite permissable to dimension the Letters array to 6, read the 5 characters from the console then manually set the final character to NULL. In that way, the cout could have taken the name of the string, (as it is now NULL terminated), instead of writing the characters out individually in a loop.

In the next part of the tutorial, we'll look at the limited graphical capabilities of consoles, drawing lines, boxes and grids.

Okay, hands up, who here started out with something like this, possibly in another language, possibly on another OS, but whatever, with something like that. I'm willing to bet there are a good few people who can say "yes, that was me". You don't really want to see the source do you? Oh all right then.

#include <iostream>
using namespace std;

int main()
{
    cout << "Hello World!" << endl;
    return 0;
}

8 lines. Could be less, by why make things harder to read? This is really the great strength of a Windows Console Application, you really do not need to do much in order to make a working program. That is why I use consoles. If I want to test out a bit of non GUI code, and I don't have a suitable application I can use as a framework, I knock together a quick console application, and I'm sure just about every other Windows programmer does as well. The user interface only needs to be sophisticated enough to get the job done.

Some of the other tutorials on the site demostrate powerful techniques, but do it in a Console App because that's all that was needed.

Can you do anything else with a Console App? Of course, the answer is yes, you can, and these tutorials demostrate some of the things that can be done with a console. Believe it or not, a huge number of questions concerning consoles crop up in help forums every week, so people are interested. If you are, read on.

What is a Console? It is a Window, a special kind, yes, but it is a Window. You will frequently hear these things called "DOS boxes" because DOS had a character based UI, but this term is incorrect. There is no DOS under the NT cored WIndows operating systems, (NT, 2000, XP), and yet you can use a console. Why? Because it is a Window. (There are actually DOS emulators for these platforms - but this is a totally unrelated topic.)

What makes a Console window special is that it is character based rather than pixel based. A normal window, like this browser window for example, (unless you're using a REALLY basic browser), is measured in pixels, each pixel is individually addressable and modifiable. With a character based medium, that is not the case, the smallest unit that can be addressed and thus modified is a character cell.

A console's display area consist of rows and columns of character cells. It is a grid or two dimensional array or matrix of cells, all these terms are in use - they amount ot the same thing. Traditionally, the character cell at the top left is the origin or "home" position, and is designated (0,0) in an imaginary (x,y) grid. The character cell to it's immediate right is (1,0), the next (2,0) and so on. The cell just below (0,0) is (0,1), the one below that (0,2) and so on. On a typical console there are 80 cell positions across the screen, and 25 down, thus on such a console, the bottom right cell will be (79,24) remembering the grid is zero based. The little picture below shows graphically the cell numbers of the upper left portion of a larger screen or the entire grid of a 4x4 console of course.

Incidently, the reason for chosing 80x25 is historical. In the days before graphical terminals were widely available, people used character based terminals called "Visual Display Units", or VDU's. These typically had an 80x25 screen layout. I was one of those who used these beasts.

Each character cell can contain one and only one character. I'll illustrate an artifact of this below. I type 5 "w" characters, then on the line below, 5 "i" characters...

wwwww
iiiii

... notice the length of the lines. Assuming you are using a modern browser, you should see that the upper line is longer than the lower. Now I'll write a console app which does the same, here is the output...

... as you see, since each cell can only hold a single character, the last "i" character is directly below the last "w". There can be no proportional spacing in a console with the default font, (it is possible to simulate a very crude form of proportional spacing if only a few letters are used - but forget it - it's not worth the hassle).

Okay, so we've got a grid of cells, what is in a cell? Simply, a cell is another grid, each cell being 8 pixels wide and 12 high. The characters that make up the font must be represented within this grid including any spacing - that's right, the pixels of one cell lie directly adjacent to the pixels of the next. This is somewhat limiting, and accounts for the rather poor quality of the console font, but as we will see later, it does have some advantages. The pictures below show how the "w" and "i" characters are encoded into a cell.

Notice the blank column on the right of the "w", this ensures that two adjacent "w" characters will have at least a single pixel space between them. If you look at the last picture, you will see that is the case. Also notice, the dot over the "i" does not go to the top of the cell, this ensures that any character on the line above an "i" that has a descender, an extension below the normal line, "y" for example, will still have at least a one pixel gap between the descender and a "high" character. Thus, normal characters are represented by 7x11 grids with a blank row at the top and a blank column on the right side.

The pixels marked with a "X" in the pictures above are rendered in the foreground colour, those in the empty pixels positions, in the background colour. By default, the foreground is white, the background black. Later on in the tutorial, I will show you how to change these colours, within limits.

There is a one pixel wide gap around the outside edge of the consoles display area. This prevents the top, bottom and edge characters merging with the frame. You cannot write into this gap. Thus a console's display area is 2+(8x) pixels wide, where x is the number of character cells in a row, and 2+(12y) pixels high where y is the number of visible rows, (there may be more rows above or below the current view as determined by the position of the scroll bar).

I'm afraid this first page has really been rather a lot of dry theory. A lot of what you can do with consoles assumes you understand this material though, so read it through, and if later on in this tutorial, you find something that sounds weird, try reading this page again!

In the next part, I'll show you how to name your Console, obtain the consoles standard handles, move the cursor about, write blocks of characters and clear the screen.