====================================================

　　前言：

　　本文是源于我在（上海交大）饮水思源BBS 的VC版解答其他网友提出的帮助请求。这是德国 DARMSTADT 工业大学C++作业题目之一，属于非计算机系的题目，题目本身要求完成的那几个辅助函数难度并不高。我在BBS上给出了这道题目的解答，但是同时我也想根据这个题目的说明文档，来仔细回顾一下 Huffman 编码。因此本文是以该题目的说明文档为基本框架的。我将对该文档中的主要部分转用中文叙述，当然里面可能还增加有我个人的理解。同时该文档将一并作为附件提供。

　　该文档是：

　　PD Dr. Ulf Lorenz, 《Introduction to Mathematical Software Examination Sheet (winter term 2009/2010) 》， Department of Mathematics, TECHNISCHE UNIVERSITY DARMSTADT.

 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　--hoodlum1980

　　 =====================================================

 　　Hufmann coding 是最古老，以及最优雅的数据压缩方法之一。它是以最小冗余编码为基础的，即如果我们知道数据中的不同符号在数据中的出现频率，我们就可以对它用一种占用空间最少的编码方式进行编码，这种方法是，对于最频繁出现的符号制定最短长度的编码，而对于较少出现的符号给较长长度的编码。哈夫曼编码可以对各种类型的数据进行压缩，但在本文中我们仅仅针对字符进行编码。

　　1. 压缩数据。

　　压缩数据由以下步骤组成：

　　a）检查字符在数据中的出现频率。

　　b）构建哈夫曼树。

　　c）创建哈夫曼编码表。

　　d）生成压缩后结果，由一个文件头和压缩后的数据组成。

 　　下面介绍这些步骤的一些细节。

　　a）字符出现的频率：

　　我们对要压缩的文本进行扫描，然后记录下各个字符出现的次数（在这里我们的输入文本将仅仅有 ascii 字符构成） ，扫描完成后我们就得到了一个字符的频率表。这个频率表也是后面的文件头的重要组成部分。为了降低文件头的尺寸，我们对字符频率压缩到用一个字节来表示。【注意】，等比例缩小字符频率时，不能把在文本中出现的字符的频率缩小成0！

　　由以下方法来完成：我们首先提供一个用于填充频率结果的数组（unsigned int freqs[NUM_CHARS]，注意尽管这个数组是UINT类型，但是填充数据必须在0~255之间），元素在这个数组中的索引就代表了该字符的 ascii 码。例如填充完毕后，字符‘a’的出现频率即为 freqs['a'];

　　unsigned char* string: 输入的文本。

　　unsigned int size：输入文本的字符数。

code_create_freq_array

//给定一个字符串，把字符的出现频率保存到freqs数组中
//Hint: Be carefull that you don’t scale any frequencies to zero for symbols that do appear in the string!

void create_freq_array(unsigned int freqs[NUM_CHARS], unsigned char* string, unsigned int size)
{
    int i, maxfreq = 0;
    
    //初始化成0
    memset(freqs, 0, sizeof(unsigned int) * NUM_CHARS);
    
    for(i=0; i<size; i++)
    {
        freqs[string[i]]++;
        
        if(freqs[string[i]] > maxfreq)
            maxfreq = freqs[string[i]];
    }
    
    //把字符频率压缩到一个字节。 scaled freqs to (0~255)
    if(maxfreq > 0xff)
    {
        for(i=0; i<NUM_CHARS; i++)
        {            
            if(freqs[i])
            {
                freqs[i] = (int)(freqs[i] * 255.0 / maxfreq + 0.5);
            
                //要确保不会被缩小成0！
                if(freqs[i] == 0)
                    freqs[i] = 1;
            }
        }
    }
}

　　b）构建哈夫曼树（huffman Tree）；

　　哈夫曼编码的核心部分就在于构建哈夫曼树，它是一个二叉树。同时它的贪心策略也现在构建哈夫曼树的方法中。

　　哈夫曼树用下面的方式构建：首先，我们把所有出现的字符作为一个单节点数，在节点上标识一个数字代表字符出现频率。

　　例如如果我们要对字符串“aabbbccccdddddd" 进行编码，则字符频率表如下所示：

　　 ----------------------------

　　|      a       b       c       d    |

 　　----------------------------

　　|      2       3       4       6    |

      ----------------------------

　　一共有4个字符出现，因此最初我们有 4 个单节点的树。然后就是体现贪心策略之处，每次我们选取具有最低频率的两个树，并将他们合并，把两个树的频率相加，赋给新树的根节点。重复这个步骤，直到最后只剩下一棵树，就是最终我们需要的哈夫曼树。合并过程如下图所示：
　　

　　最终的编码方式是，每个 叶子节点代表了一个在原文中出现的字符。每个字符的编码就是从根节点到该叶子节点的路径。由于字节中的每一位由0，1两种状态，这也正是二叉树尤其重要和常用的原因。从根节点出发，如果进入左子树，则在编码上填0，如果进入右子树，则在编码上填1，直到到达叶子节点，就完成了该字符的编码。从上面的哈夫曼树可见，最终的哈夫曼编码表如下：

　　=======================

　　  字符      频率      编码         码长

　　------------------------------------

　　　a        2         110          3

        b        3         111          3

        c        4         10            2

        d        6         0             1

　　======================== 

　　哈夫曼编码是一种前缀码，即任一个字符的编码都不是其他字符编码的前缀。从我们的编码过程中可以很容易看到这一点，因为所有字符都是哈夫曼树中的叶子节点，所以每个字符所在的叶子节点的路径都不会有重叠部分（即代表字符的节点之间不存在以下关系：某节点是另一节点的祖先或后代）。这个特征能够保证解码的唯一性，不会产生歧义（在解码时只需要找到叶子节点即可完成当前字符的解码）。

　　可以看出，出现频率最高的字符，使用最短的编码，字符出现频率越低，编码逐渐增长。这样不同字符在文档中出现的频率差异越大，则压缩效果将会越好。字符的出现频率差异影响了它们最终在哈夫曼树中的深度。

　　因此字符出现频率越大，我们希望给它的编码越短（在哈夫曼树中的深度越浅），即我们希望更晚的将它所在的树进行合并。反之，字符频率越低，我们希望给他的编码最长（在哈夫曼树中的深度越深），因此我们希望越早的将它所在的树进行合并。因此，哈夫曼编码的贪心策略就体现在合并树的过程中，我们每一次总是选择根节点频率最小的两个树先合并，这样就能达到我们所希望的编码结果。

　　在合并树的过程中，为了抽取最小频率的树，我们需要一种重要的数据结构作为辅助：优先级队列（Priority Queue）（最小堆）。什么是优先级队列？优先级队列是指一种维护一组元素的数据结构，它的常用操作是从这些元素中抽取最小的元素，和插入新元素。即他维护了一个动态的元素集合，同时要求插入和抽取尽可能的快。实现优先级队列使用的是数据结构中的堆（Heap）（注意：和内存管理中的堆的概念区别）。

　　最小堆是一个数据结构，在存储方式上使用的是一维线性表（一维数组）存储元素，这些元素在逻辑上组成一个二叉树。

　　最小堆要求满足以下特征：

　　对任何节点：左子 <= 根 <= 右子。

　　最小堆的数组是以 1 为起始索引的，注意，而不是 C / C++ 中管用的 0-based 数组，因此在 C/C++中，第一个元素（索引为0）通常被浪费。其目的完全是为了能够用下面的简便方式在树节点中导航：

　　对最小堆中的某个节点 x[i]  来，可通过以下方式方面的获取到他的相关节点：

　　根节点： x[1]; 　父： x[i/2]；  左子：x[i*2];   右子:  x[i*2+1];

　　一个最小堆的逻辑二叉树范例如下图所示：

　　因此最小堆的最小元素就是根节点。由于最小堆需要经常性的做抽取最小元素和插入操作，因此实际上为了维持堆的特征，每次插入和抽取都要进行节点的调整，因此抽取和插入操作都耗时O（log n）。

　　对于优先级队列来说，主要需要实现两种基本操作：插入新元素，抽取最小元素。他们的步骤如下：

　　（1）插入新元素：把该元素放在二叉树的末端，然后从该新元素开始，向根节点方向进行交换，直到它到达最终位置。

　　（2）抽取最小元素：把根节点取走。然后把二叉树的末端节点放到根节点上，然而把该节点向子结点反复交换，直到它到达最终位置。

　　实现优先级队列的类代码如下所示：

code_PriorityQueue

// This class is used in the construction of the Huffman tree.
// 优先级队列

class HuffNodePriorityQueue
{
public:
    HuffNode* HuffNodes[NUM_CHARS];
    unsigned int size;

    void init() 
    {
        size=0;
    }

    void heapify(int i) 
    {
        int l,r,smallest;
        HuffNode* tmp;
    
        l=2*i; /*left child*/
        r=2*i+1; /*right child*/
    
        if ((l < size)&&(HuffNodes[l]->freq < HuffNodes[i]->freq))
            smallest=l;
        else 
            smallest=i;
        if ((r < size)&&(HuffNodes[r]->freq < HuffNodes[smallest]->freq))
            smallest=r;
    
        if (smallest!=i) 
        {
            /*exchange to maintain heap property*/
            tmp=HuffNodes[smallest];
            HuffNodes[smallest]=HuffNodes[i];
            HuffNodes[i]=tmp;
            heapify(smallest);
        }
    }

    void addItem(HuffNode* node) 
    {
        unsigned int i,parent;  
        size = size+1;
        i = size-1;
        parent = i/2;

        /*find the correct place to insert*/
        while ( (i > 0) && (HuffNodes[parent]->freq > node->freq) )
        {
            HuffNodes[i] = HuffNodes[parent];
            i = parent;
            parent = i/2;
        }
        HuffNodes[i]=node;
    }

    HuffNode* extractMin(void) 
    {
        HuffNode* max;
        if (isEmpty())
            return 0;
        max=HuffNodes[0];
        HuffNodes[0]=HuffNodes[size-1];
        size=size-1;
        heapify(0);
        return max;
    }

    int isEmpty(void) 
    {
        return size==0;
    }

    int isFull(void)
    {
        return size >= NUM_CHARS;
    }
};

　　在上面的代码中，使用的是　heapify 成员函数，将指定的节点交换到最终位置。

　　构建哈夫曼树的步骤如下：

　　a）把所有出现的字符作为一个节点（单节点树），把这些树组装成一个优先级队列；

　　b）从该优先级队列中连续抽取两个频率最小的树分别作为左子树，右子树，将他们合并成一棵树（频率=两棵树频率之和），然后把这棵树插回队列中。

　　c）重复步骤b，每次合并都将使优先级队列的尺寸减小1，直到最后队列中只剩一棵树为止，就是我们需要的哈夫曼树。

　　相关代码如下：

code_build_Huffman_tree

// create the Huffman tree from the array of frequencies
// returns a pointer to the root node of the Huffman tree
// 根据字符频率数组，创建一个huffman树。返回根节点。

HuffNode* build_Huffman_tree(unsigned int freqs[NUM_CHARS])
{
    // create priority queue
    HuffNodePriorityQueue priority_queue;
    priority_queue.init();

    for (unsigned int i = 0; i < NUM_CHARS; i++)
    {
        if (freqs[i] > 0)
        {
            HuffNode* node = new HuffNode;
            node->c = i;
            node->freq = freqs[i];
            node->left = NULL;
            node->right = NULL;
            priority_queue.addItem(node);
        }
    }

    printf("number of characters: %d\n", priority_queue.size);

    // create the Huffman tree
    while (priority_queue.size > 1)
    {
        HuffNode* left = priority_queue.extractMin();
        HuffNode* right = priority_queue.extractMin();

        HuffNode* root = new HuffNode;
        root->freq = left->freq + right->freq;
        root->left = left;
        root->right = right;
        priority_queue.addItem(root);
    }

    // return pointer to the root of the Huffman tree
    return priority_queue.extractMin();
}

　　d) 压缩数据；

　　我们已经建立了哈夫曼树，并根据哈夫曼树建立了字符的哈夫曼编码表，因此现在压缩数据的方法将是很显而易见的，我们遍历输入的文本，对每个字符，根据编码表依次把当前字符的编码写入到编码结果中去。为了能够解压缩，我们还需要在编码时写入一个文件头，这样我们在解码时能够重建（和编码时同样的）哈夫曼树。最终的文件格式定义如下：

　　File Header（文件头）：

　　　　unsigned int size; 被编码的文本长度（字符数）；

　　　　unsigned char freqs[ NUM_CHARS ]; 字符频率表

　　compressed; (Bits: 压缩后的数据）；

　　注意：压缩后的Bits实际上必须以字节为最小单位。因此 Bits 需要向上取整到整数字节。

　　2. 解压缩数据；

　　解压缩数据的过程是：

　　e) 读取文件头；

　　f）根据文件头重建哈夫曼树；（和压缩数据时的步骤一致，代码是复用的）

　　g）根据哈夫曼树读取并逐个字符解码；

　　e) 读取文件头：

　　这一部是处于文件头的信息，文件头由输入文本的字节数和（已等比例压缩到一个字节）字符频率表组成。根据这些信息构建出字符频率表，这一步骤和压缩数据时一样。

　　g) 解码：

　　我们遍历编码后的Bits，每一次都从哈夫曼树的根节点出发，遇到0时，进入节点的左子树，遇到1时进入节点的右子树，直到到达叶子节点为止，并取得最终的字符。重复这一过程，知道所有字符都已经解码。

　　最后，提供已经补充完整的代码文件和原PDF文档：

　　http://files.cnblogs.com/hoodlum1980/Huffman.rar

　　当我们使用上面的代码对“aabbbccccdddddd”进行哈夫曼编码时，程序产生的输出如下：

　　size of input: 15
　　char: a freq: 2
　　char: b freq: 3
　　char: c freq: 4
　　char: d freq: 6

　　number of characters: 4

　　character encodings:
　　char: a code: 110
　　char: b code: 111
　　char: c code: 10
　　char: d code: 0

　　compressed string: (size: 32 bit) //注意后三个Bit 不携带信息，仅为了补齐成 8 Bits 整数倍；
　　11011011111111110101010000000101

　　size of compressed string: 15
　　number of characters: 4

　　uncompressed string: (size: 120 bit)

　　aabbbccccdddddd

　　【备注】程序也可以接收一个命令行参数（文本文件的文件名）作为输入，在编码后保存成一个二进制文件，然后再从该二进制文件解码并保存到另一个新的文本文件。

评论: 0　查看评论　发表评论

最新新闻：
· 知名扩展 Firebug 的简化版登陆 Chrome(2010-02-09 22:59)
· Google 悄悄地启用 1e100.net，打枪地不要(2010-02-09 22:57)
· 从 Google 代码库找到的好东西(2010-02-09 22:46)
· 苹果在线商店临时关闭 或将推新Macbook(2010-02-09 22:39)
· 豆瓣网推出豆瓣电台iPhone客户端(2010-02-09 21:51)

编辑推荐：2010年2月编程语言排行榜

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

　　这一次我来讲解一个非常简单的倒计时效果（没太大技术含量，所以最初原文发于我的QQZone中）。它的应用场景是这样的，它是一个“全局”性质的提醒，以一种醒目的方式告知用户某个重要事件即将发生，同时不打断用户的当前操作。视觉效果是在屏幕的正中间显示一个正在倒数的数字，如下：

　　然后我们随便用VC创建一个win32应用程序项目，倒计时的数字实际上是用一个窗口来呈现的，也就是在程序中的一个对话框。因此在资源中插入一个对话框，删除掉对话框上的任何控件，然后设置它的属性为 toolwindow，边框为 none。

　　我们可以使用 GDI 在窗口上绘制出倒计时的数字，如果像我一样想要追求更漂亮点的显示效果，我使用了自定义的图片，包括两张位图，一个是绘制了0~9所有我们需要的数字的图片，另一个是窗口的背景（边框）。如下图所示(图片有所缩小)：

　　背景：  

　　数字：

　　倒计时窗口需要有以下窗口样式：

　　WS_EX_TOOLWINDOW: 这个可以在设置窗口属性中打钩设置好。toolwindow的本意通常是指那些可以浮动的工具栏窗口，它们的特点是标题栏比普通窗口要窄，标题栏的标题字体也比普通窗口的标题字体小。最关键的特征是，这种窗口不会在任务栏上显示按钮，也不会出现在Alt-Tab窗口列表中。这正是我们需要这个样式的原因。　

　　WS_EX_LAYERED: 图层窗口。这样我们就可以指定窗口的透明度和透明色。比如背景位图中的圆角处我们使用洋红填充，这样窗口上具有透明色的地方就不会显示出来。同时可以设置窗口使它们具有半透明效果。

　　WS_EX_TRANSPARENT: “透明”的窗口。这个透明不是说视觉上，而是在于鼠标事件上透明。也就是说，我们的窗口不希望接收鼠标事件，不希望拥有焦点，因为倒计时窗口仅仅用于显示信息，不希望干扰用户的正常操作（比如他们正在聊天或者编辑文档）。这样，鼠标在窗口上移动或者点击时，消息都将被发送到下面的窗口。

　　WS_EX_TOPMOST: 顶层窗口。这个简单了，就是永远在最上面的窗口。这个属性我们本质上通过SetWindowPos API 函数设置上去。

　　在原文中我还讲解了很多很基本的东西，比如函数中的 static 的局部变量， QQMUSIC的歌词窗口的实现等。由于这些东西很简单，就不详细陈列了。

以下是其中一条：

　　假设有一个大矩形 rcBig，一个小矩形 rcSmall，我们把小矩形居中的放在大矩形中央，那么小矩形的左上角坐标（以大矩形的左上角为原点）是多少？答案是：

　　left = (rcBig.width - rcSmall.widht) /2;

　　top = (rcBig.height - rcSmall.height)/2;

　　这个计算式在界面布局时经常用到。同理，在上面的绘制代码中我们也是用这种方法定位每个数字的左上角坐标的。也是用这个方法去设置窗口在屏幕上居中的。　　

　　下面我们补充一下源代码的下载连接：

　　http://files.cnblogs.com/hoodlum1980/StretchBlt.rar

　　========================================

　　补充一则：把一个 int 数字 n  格式化成16进制的字符串(前面补零成0位)：

　　例如，输入n=10，要求输出 0x0000000A;

　　C++:  sprintf( buffer, "0x%08X", n);

　　C#:    string s = string.Format( "0x{0:X08}", n);

评论: 0　查看评论　发表评论

最新新闻：
· 知名扩展 Firebug 的简化版登陆 Chrome(2010-02-09 22:59)
· Google 悄悄地启用 1e100.net，打枪地不要(2010-02-09 22:57)
· 从 Google 代码库找到的好东西(2010-02-09 22:46)
· 苹果在线商店临时关闭 或将推新Macbook(2010-02-09 22:39)
· 豆瓣网推出豆瓣电台iPhone客户端(2010-02-09 21:51)

编辑推荐：2010年2月编程语言排行榜

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

　　我们将向一个典型SQL数据库中的某表的 Image 类型的字段（假设字段名称为“PHOTO”）存储一副图片，实际上 Image 字段是一种二进制流，它是由应用程序负责解释的。因此在这里我们是将其当作 jpg 图像文件。换句话说，把 jpg 文件的原始字节流存储到 Image 字段中去。由于通过内存中转，显然，这种文件的尺寸不宜过大。

　　我们假设在一个CImage对象中已经加载的就是要保存的图片，同时也打开了相应表的一个用于插入记录的记录集指针 （_RecordsetPtr ）。

　　则相关代码如下：

代码

//存储图片
bool SaveImage(CImage *lpImg, _RecordsetPtr pRecordset, char* errormsg)
{
    //估算图像需要的内存大小，这里当作 BMP 格式来估算的，所以结果比实际需要的更大。
    SIZE_T buffersize = lpImg->GetWidth() * lpImg->GetHeight() * lpImg->GetBPP()/8 + sizeof(BITMAPINFO);
    HGLOBAL hMem = GlobalAlloc(GMEM_FIXED, buffersize);
    if(hMem != NULL)
    {
        IStream* pStream = NULL;
        CreateStreamOnHGlobal(hMem, FALSE, &pStream);
        if(pStream != NULL)
        {
            LARGE_INTEGER temp;
            ULARGE_INTEGER fileLength;
            temp.QuadPart = 0;

            lpImg->Save(pStream); //写入内存流

            //获取当前文件的位置
            pStream->Seek(temp, STREAM_SEEK_CUR, &fileLength);
            ULONG nLength = (ULONG)(fileLength.QuadPart+1);

            SAFEARRAY* psa; 
            SAFEARRAYBOUND rgsabound[1]; 
            rgsabound[0].lLbound = 0; 
            rgsabound[0].cElements = nLength;

            //VT_UI1 : Variable type is unsigned char. 
            psa = SafeArrayCreate(VT_UI1, 1, rgsabound);

            //锁定内存
            BYTE *lpBytes = (BYTE*)GlobalLock(hMem);
            BYTE *lpTemp = lpBytes;
            for (LONG i = 0; i < nLength; i++) 
                SafeArrayPutElement (psa, &i, lpTemp++);
            //解锁内存
            GlobalUnlock(hMem);

            VARIANT varBLOB;
            varBLOB.vt = VT_ARRAY | VT_UI1;
            varBLOB.parray = psa;

            //存储
            pRecordset->Fields->GetItem("PHOTO")->AppendChunk(varBLOB);
            pStream->Release();

            //
            SafeArrayDestroyData(psa);
        }
        else
        {
            GlobalFree(hMem);
            sprintf(errormsg, "CreateStreamOnHGlobal Failed");
            return false;
        }
        //释放全局内存
        GlobalFree(hMem);
    }
    else
    {
        sprintf(errormsg, "GlobalAlloc Failed!");
        return false;
    }
    return true;
}

　　下面再列举一下，如何从 image 字段中读取内容，并把它保存到一个磁盘上的普通文件。假设表具有一个自增的数字主键（“ID”）。

代码_ReadImage

//id：主键
void ReadImg(int id)
{
    _RecordsetPtr pRs = NULL; 
    _ConnectionPtr pConnection = NULL; 
    _variant_t varChunk; 
    HRESULT hr; 

    //连接字符串
    _bstr_t strCnn("Provider=SQLOLEDB;Server=...;Database=...;User ID=...;Password=...;"); 
    try
    {
        //Open a connection 
        pConnection.CreateInstance(__uuidof(Connection)); 
        hr = pConnection->Open(strCnn,"","",NULL); 
        pRs.CreateInstance(__uuidof(Recordset)); 

        //表名略
        char cmdText[128];
        sprintf(cmdText, "select PHOTO from ... where ID = %d", id);

        pRs->Open(cmdText,_variant_t((IDispatch *) pConnection,true),adOpenKeyset,adLockOptimistic,adCmdText); 
        //read data 
        long lPhotoSize = pRs->Fields->GetItem("PHOTO")->ActualSize; 
        long llsRead = 0;
        _variant_t varChunk;
        
        BYTE buf[ChunkSize];

        printf("lDatalength = %ld\n", lPhotoSize);

        //保存到C盘
        char filename[128];
        sprintf(filename, "C:\\ID_%d.jpg", id);
        FILE* stream = fopen(filename, "wb");

        while(lPhotoSize > 0)
        {
            llsRead = lPhotoSize >= ChunkSize? ChunkSize:lPhotoSize;

            varChunk = pRs->Fields->GetItem("PHOTO")->GetChunk(llsRead);

            for(long index = 0; index < llsRead; index++)
            {
                SafeArrayGetElement(varChunk.parray, &index, buf+index);
            }

            fwrite(buf, 1, llsRead, stream);
            lPhotoSize -= llsRead;
        }
        fclose(stream);

        printf("Save File Complete: %s\n", filename);
        
        pRs->Close(); 
        pConnection->Close(); 
    }
    catch(_com_error &e) 
    { 
        // Notify the user of errors if any. 
        _bstr_t bstrSource(e.Source()); 
        _bstr_t bstrDescription(e.Description()); 
        CString sError; 
        sError.Format(_T("Source : %s \n Description : %s\n"),(LPCSTR)bstrSource,(LPCSTR)bstrDescription); 
        //AfxMessageBox(sError); 
        //printf("%s\n", sError);
    }
}

评论: 0　查看评论　发表评论

最新新闻：
· 知名扩展 Firebug 的简化版登陆 Chrome(2010-02-09 22:59)
· Google 悄悄地启用 1e100.net，打枪地不要(2010-02-09 22:57)
· 从 Google 代码库找到的好东西(2010-02-09 22:46)
· 苹果在线商店临时关闭 或将推新Macbook(2010-02-09 22:39)
· 豆瓣网推出豆瓣电台iPhone客户端(2010-02-09 21:51)

编辑推荐：2010年2月编程语言排行榜

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

　　==========================================================

　　补充说明： 　　-- hoodlum1980 2010年1月28日

　　==========================================================

　　我很快发现这篇文章实际上意义不大了。因为这是因为没有设置我们需要的拉伸模式导致的问题。

　　图像失真是由于 StretchBlt 的默认模式是 BLACKONWHITE：（对产生重叠的像素进行AND操作）导致的。事实上解决这个问题的正确方式是在 StretchBlt 之前调用 SetStretchBltMode 函数设置模式，下文中采用的方法实际上是 COLORONCOLOR 模式（即删除像素），这种模式将完全舍弃那些产生重叠的行列信息。下面解释一下这些模式：（内容来自 MSDN）

BLACKONWHITE

　　在保留像素和损失像素之间执行逻辑与（AND）操作。如果图片是单色位图，则被舍弃的黑色像素会在被保留的白色像素上保持黑色。

COLORONCOLOR

　　删除像素。不保留那些被舍弃行列上的像素信息。 （备注：即本文后面采用的下采样方式）

HALFTONE

　　把源矩形中的像素映射到目标矩形时，使像素的平均值近似相同。使用这种模式，应用程序必须然后调用  SetBrushOrgEx 校正画刷起始点，否则可能产生偏差。

WHITEONBLACK

　　在保留像素和损失像素之间执行逻辑或（OR）操作。如果图片是单色位图，则被舍弃的白色像素会在被保留的黑色像素上保持白色。

　　在拉伸绘制时，我们应该先进行模式设置：

     hdc = BeginPaint(hWnd, &ps);              
     SetStretchBltMode( hdc,  HALFTONE );
     HDC hMemDC = CreateCompatibleDC(hdc);
     SelectObject(hMemDC, m_Bitmap);
     StretchBlt( hdc, 0, 0, 102, 136, hMemDC, 0, 0, 331,372, SRCCOPY );
     DeleteDC(hMemDC);

　　EndPaint(hWnd, *ps);

　　以下是原文内容：

　　======================

　　本文所提到的问题是一个在实际项目中遇到的问题，在 VC 中，通过 StretchBlt 函数来完成缩小位图，将导致像素堆积（效果可参考下图）。具体体现就是 GDI 可能在 StretchBlt 的实现是比较简单的，导致使用拉伸绘制后的图像分辨率严重失真，以至于不能符合应用的要求。因此我们必须解决这个问题。（PS：在我印象中，可能在 GDI+ 中是不存在这个问题的。）

　　问题出现时，最开始我以为是在保存过程中的图像压缩质量导致的问题，但我把图像质量设置到 100% 时，图像质量依然没有任何改善，然后我发现其实图像质量的降低是发生在 StretchBlt 这一步，（DestRect 比原图小）一旦做了这个操作 ，则图像就变得面目全非，难以辨认细节。因此我很快的在网上搜索一些资料，也想过是不是要放弃CImage，该用网上的开源的CxImage。最终我采用的是在《CTreeCtrl和CListCtrl复杂控件的综合使用》一文中使用的方法：在matlab中叫做重采样（上采样-updample，下采样-downsample）。

　　在GDI中，如果是放大的拉伸绘制，产生的结果就是像素被线性放大，将出现明显锯齿，实际上问题不大。（一般的应用程序在放大图像时， 会在像素方格内进行线性插值来柔和图像。）因此本文主要讨论的是缩小的拉伸绘制。

　　缩小的拉伸绘制的原理非常简单，就是把图像缩小以后，我们把目标图像上的每个像素，按缩放比例去原图中选取相应像素，拷贝到目标图像中。 为了加快操作，我们使用图像的数据块进行操作。（在.NET中对应的大概是Bitmap.LockBits）

　　代码如下：

code_stretchbltfast

//缩放复制
void StretchBltFast(CImage* pDest, int xDest, int yDest, int cxDest, int cyDest, 
    CImage* pSrc, int xSrc, int ySrc, int cxSrc, int cySrc)
{
    int i,j,k;
    LPBYTE pBitsSrc = (LPBYTE)(pSrc->GetBits()); //数据块起始位置
    LPBYTE pBitsDest = (LPBYTE)(pDest->GetBits());//数据块起始位置
    LPBYTE pixAddrSrc = pBitsSrc;
    LPBYTE pixAddrDest = pBitsDest;

    int strideSrc = pSrc->GetPitch(); //pitch有时为负
    int strideDest = pDest->GetPitch();
    int bytesPerPixelSrc = pSrc->GetBPP()/8;
    int bytesPerPixelDest = pDest->GetBPP()/8;
    
    for (j = 0; j < cyDest; j++)
    {
        for (i = 0; i < cxDest; i++)
        {
            pixAddrSrc = pBitsSrc + (j * cySrc / cyDest) * strideSrc + (i * cxSrc / cxDest) *  bytesPerPixelSrc;
            pixAddrDest = pBitsDest + strideDest * j  + i  * bytesPerPixelDest;

            //复制当前像素
            for (k = 0; k < bytesPerPixelDest; k++, pixAddrDest++)
            {
                *pixAddrDest = *pixAddrSrc;

                //是否可以移动到下一个通道？
                if(k < bytesPerPixelSrc - 1) pixAddrSrc++;
            }
        }
    }
}

　　使用上面的重采样方法和GDI的StretchBlt方法绘制的图像效果如下：（可见重采样方法的效果是要好过StretchBlt）

　　补充一些其他讨论：

　　（1）MSDN中提到CImage可以使用32bpp的图片进行 alpha 合成， 即使用第四个通道作为每个像素的 alpha 值。本质上是通过调用 AlphaBlend 来实现的。根据 AlphaBlend 函数的要求，在绘制（draw）前必须预先把alpha通道应用到位图的RGB通道上（RGB*Alpha/255); 绘制结果如下所示：

　　预先应用alpha通道将改变RGB通道中的数据，代码如下所示：

Code_PreMultiplied

//对CImage预先应用alpha通道
void PreMultiplied(CImage* pImg)
{
    int i, j;
    LPBYTE pPixel;

    //必须是32bpp
    if(pImg->GetBPP() != 32)
        return;

    LPBYTE pBytes = (LPBYTE)pImg->GetBits();
    int stride = pImg->GetPitch();

    int width = pImg->GetWidth();
    int height = pImg->GetHeight();

    for(j=0; j<height; j++)
    {
        for(i=0; i<width;i++)
        {
            pPixel = pBytes + j * stride + i * 4;
            pPixel[0] = (BYTE)((UINT)pPixel[0] * pPixel[3]/0xff);
            pPixel[1] = (BYTE)((UINT)pPixel[1] * pPixel[3]/0xff);
            pPixel[2] = (BYTE)((UINT)pPixel[2] * pPixel[3]/0xff);
        }
    }
}

　　在上图中，左上角是一个32bpp的图像绘制结果。 在下方我分别绘制了 0，1，2，3 每个通道的图像（转变成灰度图像），其中RGB通道是在应用Alpha通道前的数据。（可以事先创建一个24bpp的同等大小图像去接收某个通道数据）

code_getchannel

//获取指定的通道，填充到pDest中（灰度图像）
void GetChannel(CImage* pDest, CImage* pSrc, int channel)
{
    int i, j, k;

    LPBYTE pPixelDest, pPixelSrc;
    LPBYTE pBytesDest = (LPBYTE)pDest->GetBits();
    LPBYTE pBytesSrc = (LPBYTE)pSrc->GetBits();

    int strideDest = pDest->GetPitch();
    int strideSrc = pSrc->GetPitch();

    int width = pDest->GetWidth();
    int height = pSrc->GetHeight();
    int bppDest = pDest->GetBPP();
    int bppSrc = pSrc->GetBPP();

    for(j=0; j<height; j++)
    {
        for(i=0; i<width;i++)
        {
            pPixelSrc = pBytesSrc + j * strideSrc + i*bppSrc/8 + channel;
            pPixelDest = pBytesDest + j * strideDest + i*bppDest/8;
            for(k=0; k < bppDest/8; k++, pPixelDest++)
            {
                *pPixelDest = *pPixelSrc;
            }
        }
    }
}

 

 　　本文参考以下资料：

　　（1） CTreeCtrl和CListCtrl复杂控件的综合使用 ；

评论: 0　查看评论　发表评论

最新新闻：
· 知名扩展 Firebug 的简化版登陆 Chrome(2010-02-09 22:59)
· Google 悄悄地启用 1e100.net，打枪地不要(2010-02-09 22:57)
· 从 Google 代码库找到的好东西(2010-02-09 22:46)
· 苹果在线商店临时关闭 或将推新Macbook(2010-02-09 22:39)
· 豆瓣网推出豆瓣电台iPhone客户端(2010-02-09 21:51)

编辑推荐：2010年2月编程语言排行榜

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

　　本文简要介绍如何为应用程序制作一个帮助文件。

　　我们需要借助的工具软件清单如下：

　　（1）支持Rtf格式的文字处理软件，例如 Office 中的Word。

　　（2）Help WorkShop。（由VC6携带安装的一个工具）

　　步骤1：用文字处理软件编辑你的帮助文件（*.rtf)，这个文件定义你的帮助文件中的一些主题（Topic），每个topic实际上就是用WinHelp显示的一个页面。这一部本质上就属于文字处理了，只是你需要在保存的时候选择rtf格式。需要特别掌握的是以下几点：

　　每个topic结束后追加一个分页符。 在每个topic的最前面可以添加以下脚注（添加的脚注请使用以下编号）：

　　#：你的topic的一个唯一标识符，它是必须的，也是做链接时需要用到的。

　　K：定义该topic的关键字，用英文分号分割；

　　$：定义该topic的标题，它将显示在winhelp的历史窗口，查找等地方。

　　制作链接时，把链接的文本用双下划线格式，然后在文本后面添加一段隐藏文本，输入要链接的topic的唯一标示符。

　　制作出来的rtf文档效果如下图所示： 下图显示的是帮助文件的目录，里面包含了到每个topic的链接。

　　下图显示的是为某个topic添加的脚注：

　　（2）创建一个Help项目：打开 Microsoft help workshop 软件， 点击File -> New ->选择 Help Project；

　　建立好项目以后，我们可以使用右侧的那些按钮去设置这个项目的一些信息，过程很简单，这里就不详细介绍了， 细节可以查阅 help workshop 的帮助文件。设置好的项目如下图所示：

　　（3）先把项目保存，然后我们用help workshop 创建帮助文件的内容文件（*.cnt)。 使用菜单 File->New-> 选择help Contents。然后我们添加目录（Head，一本书的图标）和Topic（文件图标），使用 MoveLeft 和 MoveRight 按钮可以修改缩进。做好的 Contents 效果如下图所示：

　　（4）把 contents文件保存，然后打开刚才的help Project， 在Options的 Files 标签页中填加 Contents 文件。如下图所示：

　　然后我们点击“ Save and compile ” 按钮编译帮助文件，编译成功以后，通过菜单 File -> Run Winhelp 可以看到我们做的帮助文件的效果如下图所示：

　　帮助文件基本做好了，现在我们为我们的应用程序添加对帮助的支持，首先我们在资源中打开窗口的菜单资源，在帮助菜单下添加下面几项：

　　帮助主题（IDM_HELPCONTENTS), 内容（IDM_HELPCONTENTS），搜索帮助（IDM_HELPSEARCH），然后我们在窗口过程中处理WM_COMMAND消息时添加对这几个菜单的处理，相关代码如下：

code_wndproc

//获取和程序位于同一个目录下文件的绝对路径

void GetAppFolderFileName(char *buffer, char* shortFileName)
{
    char* pChar = NULL;
    GetModuleFileName(NULL, buffer, MAX_PATH);
    pChar = strrchr(buffer, '\\');
    if(pChar != NULL)
    {
        strcpy(pChar + 1, shortFileName);
    }
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    WORD ctlId, wmEvent;
    switch (message) 
    {
    case WM_HELP: //F1
        {
            //获取和程序位于同一个目录下文件的绝对路径
            char buffer[MAX_PATH];
            GetAppFolderFileName(buffer, "RFCARD.HLP");
            WinHelp (hWnd, buffer, HELP_CONTENTS,(DWORD)0);

        }
        break;
    case WM_COMMAND:
        ctlId    = LOWORD(wParam); 
        wmEvent = HIWORD(wParam); 
        switch (ctlId)
        {
        case IDM_HELPTOPICS: // "Help Topics..."
            {                
                char buffer[MAX_PATH];
                GetAppFolderFileName(buffer, "RFCARD.HLP");
                WinHelp (hWnd, buffer, HELP_FINDER,(DWORD)0);
            }
            break;
        case IDM_HELPCONTENTS: // "Contents"
            {
                char buffer[MAX_PATH];
                GetAppFolderFileName(buffer, "RFCARD.HLP");
                WinHelp (hWnd, buffer, HELP_CONTENTS,(DWORD)0);
            }
            break;
        case IDM_HELPSEARCH: // "Search for Help On..."
            {
                char buffer[MAX_PATH];
                GetAppFolderFileName(buffer, "RFCARD.HLP");
                WinHelp(hWnd, buffer, HELP_PARTIALKEY, (DWORD)(LPSTR)"");
            }
            break;
        default:
            return DefWindowProc(hWnd, message, wParam, lParam);
        }
        break;
    }
}

　　然后我们重新编译我们的应用程序，成功以后，可以在应用程序处于前台时按下F1键（程序将收到WM_HELP消息），或者点击帮助下面的菜单，查看效果可能如下图所示：

　　本文参考以下资料：

　　（1）崔晓阳，实例简述Hlp帮助文件的制作，《农业网络信息》2007年第9期。

　　（2）MSDN：ms-help://MS.VSCC.v80/MS.MSDN.v80/MS.WIN32COM.v10.en/dnwui/html/msdn_generic.htm

　　　　Robert B. Hess, Generic: Anatomy of a Simple Win32 Application, Windows User Interface Technical Articles, October 17, 1994;　

评论: 0　查看评论　发表评论

最新新闻：
· 知名扩展 Firebug 的简化版登陆 Chrome(2010-02-09 22:59)
· Google 悄悄地启用 1e100.net，打枪地不要(2010-02-09 22:57)
· 从 Google 代码库找到的好东西(2010-02-09 22:46)
· 苹果在线商店临时关闭 或将推新Macbook(2010-02-09 22:39)
· 豆瓣网推出豆瓣电台iPhone客户端(2010-02-09 21:51)

编辑推荐：2010年2月编程语言排行榜

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

　　　　该题目的出处是：“一道比较刁的面试题”，http://www.cnblogs.com/tandly/archive/2010/01/08/1642609.html　　

　　　　要求：

　　　　1.任何语言 任何形式（web,winform,flash,flex,silverlight）等等。。

　　　　2.实现内容

　　　　　　a.初始化一个面板，面板内随机分布着一些按钮  按钮上有一些随机的数字。

　　　　　　b.有一个按钮 名字叫“新增节点” 点击 该按钮后 可以向面板内随机添加新的 按钮。

　　　　　　c.任意顺序点击面板内的按钮。按顺序将所点按钮用线条连接。并且将按钮的 数值进行累加 显示到 文本框。

　　　　　　d.回放 功能。 有一个名叫 “回放的按钮” 点击该按钮后 将所有操作慢动作回放。包括增加节点 和 连接 的一切操作。完整再现。

　　　　我在前几天看到这个题目，自觉是不难，也有一些人说到用到链表，这是不错的。而且这些实现起来并不是那么难，只是需要一定的耐心。而吸引我要把它用VC实现出来的，并不是这几个功能本身，而是如何在两个按钮之间绘制一个箭头型的连线，吸引了我的兴趣。为什么这么说呢，因为按钮随机出现，因此最简单的方法，我在两个按钮的中心点绘制一条线段就可以了，这样当然是最简单的。不过我还想让显示效果更理想化一点，也就是在被指向按钮的线段端点绘制一个三角形的箭头，并且：这个箭头不能覆盖到按钮上，也就是我希望箭头连接到按钮的矩形边框上面，做好的程序如下图所示：

　　　　在上图中，可以看到实际上每个箭头都是连接按钮的中心点的，而且箭头被准确的绘制在合适的位置（上图的按钮有些小，所以效果不够明显）。因此，这里的关键是要计算出连接线和按钮边框的交点。我是这样来做的：首先，在创建按钮时，我以按钮的中心点为圆点，计算出中心点到四个顶点的四条射线的角度，由于我是使用 atan 函数来计算两个按钮连线的角度，因此射线的角度也使他落在（-90~270）范围。如下图示意：

　　　　上图的圆周范围是从-90到270度，采用的坐标都是计算机的屏幕坐标为准（Y正方向向下，和数学中的笛卡尔坐标的Y轴方向相反），角度的正方向也是顺时针（也是和数学中的方向反向）。为了简单直观，上面的角度都使用角度表示，在实际代码中都是采用弧度。大致方法是：

　　　　（1）首先计算出两个按钮中心连线的夹角（-90~270）；

　　　　（2）根据夹角和按钮信息中的 四个对角线射线角 （angle[4]）的大小关系，判断出连线和按钮相交与哪一个边缘。

　　　　（3）由于按钮边缘上的x，y至少有一个是可知的，因此根据 alpha 角度计算出交点坐标的位置。

　　　　大概过程如上，因此代码也就会很直观了：

CODE_BUTTON_AND_LINE

//描述一个按钮
class CNumButton
{
public:
    int left,top,right,bottom;
    //按钮的对角线的4个角度
    double angle[4];
...

    //指定按钮的中心点和高度，宽度，数字
    void Init(int cx, int cy, int width, int height, int number)
    {
        double a;
        left = cx - width/2;
        top = cy - height/2;
        right = cx + width/2;
        bottom = cy + height/2;
        num = number;

        //计算对角线角度
        a = atan(((double)height)/width);
        angle[0] = -a;
        angle[1] = a;
        angle[2] = M_PI - a;
        angle[3] = M_PI + a;
    }

};

//描述两个按钮的连接线
class CLine
{
private:
    int x0, y0; //From，出发点
    int x1, y1; //To，指向点

    //三角箭头的点数组
    POINT ptsArrow[3];

private:
    //计算角度 from POINT0 -> to POINT1
    double GetAngle(int x0, int y0, int x1, int y1)
    {
        double angle;
        if(x1==x0)
        {
            if(y1>=y0) return M_PI_2; //90 度
            else return (3 * M_PI_2); //270
        }
        angle = atan(((double)(y1-y0))/(x1-x0));
        if(x1 < x0) angle += M_PI; //如果to在from左侧，则需要增加180度
        return angle;
    }

    //获取连线与按钮边缘相交的点坐标
    void GetSidePoint(CNumButton* btn, double angle, int *pX, int *pY)
    {
        if( angle < btn->angle[0] || angle > btn->angle[3]) //上边缘
        {
            *pY = btn->top;
            *pX = btn->GetCX() - (int)(btn->GetHeigth()/2 * tan(M_PI_2-angle) + 0.5);
        }
        else if(angle < btn->angle[1]) //右边缘
        {
            *pX = btn->right;
            *pY = btn->GetCY() + (int)(btn->GetWidth()/2 * tan(angle) + 0.5);
        }
        else if(angle < btn->angle[2]) //下边缘
        {
            *pY = btn->bottom;
            *pX = btn->GetCX() + (int)(btn->GetHeigth()/2 * tan(M_PI_2-angle) + 0.5);
        }
        else if(angle < btn->angle[3]) //左边缘
        {
            *pX = btn->left;
            *pY = btn->GetCY() - (int)(btn->GetWidth()/2 * tan(angle) + 0.5);
        }
    }


    
    void Init(CNumButton* fromBtn, CNumButton* toBtn)
    {
        int arrowsize = 20; //箭头大小
        double angle0, angle1;

        int cx0 = fromBtn->GetCX();
        int cy0 = fromBtn->GetCY();
        int cx1 = toBtn->GetCX();
        int cy1 = toBtn->GetCY();

        angle0 = GetAngle(cx0, cy0, cx1, cy1);
        angle1 = GetAngle(cx1, cy1, cx0, cy0);

        //获取线段两个端点
        GetSidePoint(fromBtn, angle0, &x0, &y0);
        GetSidePoint(toBtn, angle1, &x1, &y1);

        //设置箭头
        ptsArrow[0].x = x1;
        ptsArrow[0].y = y1;

        //获取三角形箭头的其他两个端点
        ptsArrow[1].x = x1 + (int)(arrowsize * cos(angle1-M_PI/12) + 0.5);
        ptsArrow[1].y = y1 + (int)(arrowsize * sin(angle1-M_PI/12) + 0.5);

        ptsArrow[2].x = x1 + (int)(arrowsize * cos(angle1+M_PI/12) + 0.5);
        ptsArrow[2].y = y1 + (int)(arrowsize * sin(angle1+M_PI/12) + 0.5);
    }
...
};

　　　　在前面讲了太多和这个题考察内容无关的方面，下面还是再说说这道题考察的关键部分吧（尽管问题很直观）。

　　　　首先我们需要定义了两个链表来保存信息：

　　　　Buttons链表：实际上保存了窗口上所有的按钮和连接线对象。每个节点都包含一个指向 Button 和一个指向 Line 的指针。注意，每个节点的Button一定存在，而Line可能为NULL。

　　　　Actions链表：保存了当前动作的可重现信息：包括，当前动作类型（增加按钮/点击按钮），当前的Sum值（按钮数字总和）等等。

　　　　链表的节点定义如下： 

CODE_SOLUTION

//动作类型
#define    ACTION_ADDBUTTON    0 //增加按钮
#define ACTION_CLICKBUTTON    1 //按按钮

//保存绘制对象的节点
typedef struct _NODE_BUTTON
{
    CLine        *line;        //相关联的线
    CNumButton    *btn;            //按钮
    struct _NODE_BUTTON *prev;    //双向链表
    struct _NODE_BUTTON *next;
} NUMBUTTON, *LPNUMBUTTON;

//记录动作的节点
typedef struct _NODE_ACTION
{
    int            type;        //动作类型
    int            sum;        //回放时应该显示的总和
    CLine        *line;        //相关联的线
    CNumButton *btn;    //相关联的按钮
    struct _NODE_ACTION *prev;
    struct _NODE_ACTION *next;
} NUMACTION;

...

//解决问题
class CSolution
{
private:
    CNumButton *lastBtn;    //最后点击的按钮（连线的尾部节点）
    NumList<NUMBUTTON> buttons;        //保存所有按钮的链表
    NumList<NUMACTION> actions;        //保存所有动作的链表
    int nSum;            //数字的总和


public:
    bool bDrawRegion; //是否绘制region（按钮的可出现位置）
    bool bPlaying;        //是否正在回放？

...
};

　　　　此外剩余的主要技巧基本都是使用 Platform SDK 的传统Windows 开发技术。特别的，这个例子最初的目的如其名称，它也展示和练习了 Rebar ，ToolBar, StatuBar 等 CommonCtrl 的使用。在工具栏上使用了 CHEVRON （“>>”）按钮。该按钮的显示控制是由系统的Rebar窗口已经实现的。当Rebar的Band小于它的理想宽度时，ReBar就会在这个Band的边缘显示“>>"按钮。点击“>>”按钮时应用程序需要弹出一个上下文菜单来显示那些显示不完全的项目。在这里为了给菜单项目显示左侧的图标，我又对上下文菜单使用了自定义绘制（菜单和工具栏使用的是同一个ImageList）。效果如下图所示：

　　　　有一点不是很好的是，当我对客户区整个刷新时，我发现 Rebar 的显示同时也失效了（Rebar上的Bands会显示不正常），为了不强制rebar重绘，我只好把客户区的画布的顶端向下增加足够的高度。

　　　　最后任务栏上有一个按钮，是“显示Region”，它是CSolution内维护的一个HRGN（区域），主要目的，是我在添加一个按钮后，在画布中把这个按钮占据的区域删去，这样尽可能使增加按钮时，他们不至于很快重叠在一起。

　　　　当（元素）按钮重叠时，这里又有一个小的技巧。即，我们按照 Z 次序 绘制他们，但是在鼠标点击去尝试捕获对象时，则要沿着和绘制相反的顺序捕获。例如，我在这里绘制按钮，是从链表头部 绘制到 链表的尾部，（按照添加顺序），但是在尝试捕获时，则需要从链表尾部检索到头部，这是因为位于最上面的元素是最后绘制的，但是也是最可能被最首先点击到的。

　　　　最后是源代码的下载链接（修复了NumList模板类定义中的一个BUG，该BUG导致获取List的元素个数不正确）：

　　　　http://files.cnblogs.com/hoodlum1980/Rebar3.rar

　　　　BUG修复：

　　　　（1）修复了NumList模板类定义中的一个BUG，该BUG导致获取List的元素个数不正确。

　　　　（2）修复在回放过程中，有些动作中，记录Sum值 的TextBox没有及时刷新的 BUG。

　　　　【附加另一道题目】：为了防止影响对方公司的面试，这里就隐去该题目的出处。这道题目非常基础和简单，这里作为一种练习。题目要求是：

　　　　使用Win32 ( 不用MFC )，写一个Windows程序，实现功能:

　　　　(1) 窗口启动时最大化 ；(2) 窗口的背景色为指定颜色；(3) 左上角显示鼠标客户区坐标；(4) 显示一张牌, 按方向键随之一动，每次移动1像素，并保证不移出窗口。(5) 点击换牌。

　　　　程序运行效果截图是：

　　　　这个程序的关键是在于如何防止卡片移动时的闪烁，实际上这里我采用了一种不能应用于普通情况，而仅适用与该题题意的比较投机的方法去防闪烁（因为这个题目中窗口背景是纯色的，在实际应用中未必有这么好的条件）。“闪烁”是windows程序在绘制方面（GDI）的一个经典话题了。当你使用GDI，（而非DirectX，OPENGL之类），那么不可能不接触到它。当然，如何防止闪烁主要取决于开发人员对窗口绘制的相关消息和过程的理解和掌握，也就是首先要弄清楚闪烁是如何引起的，然后有针对性的尽最大可能减少闪烁的发生。而不应该仅只知道一些 double buffer 之类的术语（却不知所以）。

　　　　原代码：http://files.cnblogs.com/hoodlum1980/ShowPokeCard.rar

评论: 5　查看评论　发表评论

最新新闻：
· 知名扩展 Firebug 的简化版登陆 Chrome(2010-02-09 22:59)
· Google 悄悄地启用 1e100.net，打枪地不要(2010-02-09 22:57)
· 从 Google 代码库找到的好东西(2010-02-09 22:46)
· 苹果在线商店临时关闭 或将推新Macbook(2010-02-09 22:39)
· 豆瓣网推出豆瓣电台iPhone客户端(2010-02-09 21:51)

编辑推荐：2010年2月编程语言排行榜

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

　　==========================================================================

　　补充：

　　（1）为了在预览图中显示动态的 GIF 图片，我舍弃了 CImage， 而引用了 CxImage 类库的代码。这样可以看到动态的 GIF 动画。

　　（2）改进了绘制方法，改为使用内存位图绘制，并把 WM_ERASEBKGND 合并到 WM_PAINT 中，以降低闪烁。

　　（3）修改了鼠标位于表情网格（Cells）的最右边缘时，错误的认为选中表情是下一行的第一个 Cell 的BUG。该 BUG 会导致鼠标在

　　　　最右侧移入移出时在右上角有强烈闪烁感。

　　　　　　　　　　　　　　　　　　　　　　　　--hoodlum1980 　　2010年1月29日

　　==========================================================================

　　最近有好多篇帖子是关于QQ的选择表情的那个窗口实现的。最初以为这是一个比较简单的功能，不过做起来还是发现做了整个一晚上才做的差不多做好。做完我想为什么有很多人愿意尝试它呢？可能是基于它的那个“预览图”对鼠标的“躲藏”功能是它的一个亮点，所以可能是因为这个原因引起很多人的兴趣来实现它。前人已经采用了很多种方式实现，例如 C# 的 winform，等等。在这里是使用 VC 实现的。在这个范例中也展示了如何定制一个特殊外观的窗口，以及自定义绘制（OWNER DRAW）按钮（1/2，上一页，下一页按钮），如何遍历一个文件夹下的所有文件等基本方法。

　　不过这个例子仅仅是模仿QQ的UI，实际上这也是这个例子的唯一意义。由于VC里面对于存在多帧的 gif 格式并没有特别好的支持，包括 CImage 尽管支持大多数图像格式，但是却仅能加载 gif 的一帧，而要展示动画形式的gif，则通常要求助于第三方代码，例如 CxImage 等。因此这里我就仅仅模拟这个界面，实际上在预览框里面我仅仅绘制一下而已。而并没有去真正的做 gif 动画的预览。

　　当鼠标在窗口上移动时，需要绘制一个蓝色小边框反应当前选中的是哪一个cell，而且预览图会尽可能惰性的“远离”鼠标。所谓惰性，是指仅在它发觉鼠标有向它逼近时，它的位置才会突变。例如当预览框位于左上角（跨度占据0，1，2列），而鼠标从右侧首次进入第4列时， 它是不动的，但鼠标在第4列继续移动时，它才会突然移动到右侧。因此为了检测鼠标的这种行为，实际上在范例中我记录了鼠标最近两次的停留位置，即 lastSelection，currentSelection（二者的逻辑关系实际上是一个仅包含两个元素的队列）。

 　　效果如下图所示：

　　这个范例在UI方面基本是采用对QQ2009的表情选择窗口的截图来制作的， 使用的表情文件夹是来自于qq2008的 “Face2” 。但该范例还是和真正的QQ有一些出入的地方，例如：

　　（1）QQ的表情选择窗口弹出来时，qq表情按钮是呈现按下状态的。范例为了简单期间，只是弹出模态对话框，所以这里不如QQ的 UI 自定义的那么彻底。

　　（2）QQ的表情选择窗口和其父窗口是非模态性的关系，而范例是模态关系，所以在没有加载任何图片的情况下，为了使窗口能够关闭，我做了一点特殊处理，也就是在范例中可以通过点击“空白处”的表情退出，而在QQ中点击空白位置是没有回应的。

　　（3）QQ的表情选择窗口有Tooltip，不过我不觉得这个功能很必要，估计很少会有人去关注这个功能，而且它还挡住了窗口的一部分。实现起来是很简单的，所以范例中没有tooltip了。

　　（4）QQ的表情选择窗口能自动调节自己的出现位置，尽可能靠近触发按钮，并且保证自身的可见性（完全位于屏幕范围以内）。操作中很多弹出式的窗口具有这种功能，例如 ToolTip ， ComboBox， DateTimePicker 类控件的下拉窗口等。这个功能看起来简单，但是实现起来还是需要一定技巧和复杂度。范例中仅仅让窗口的位置固定出现在按钮上方。

　　（5）QQ的表情选择窗口对用户自己添加的表情在绘制时，使用了拉伸绘制。在范例中为了简单，没有考虑表情图片的大小。

　　本范例使用的代码都属于比较传统的技术，所以并没有什么特别需要单独列出和讲解的地方。由于最近该类实现的文章较多，所以将本文发于首页候选区。

　　在这里仅提供本范例的源代码下载连接：（可执行程序位于Debug目录中）

　　http://files.cnblogs.com/hoodlum1980/QQFaceVC.rar 

　　--hoodlum1980

　　参考资料：

　　【1】 本文代码中，关于 GIF 图片的解码和展示引用了 CxImage 中的代码。关于 CxImage 的介绍地址：

　　http://www.codeproject.com/KB/graphics/cximage.aspx

评论: 0　查看评论　发表评论

最新新闻：
· 知名扩展 Firebug 的简化版登陆 Chrome(2010-02-09 22:59)
· Google 悄悄地启用 1e100.net，打枪地不要(2010-02-09 22:57)
· 从 Google 代码库找到的好东西(2010-02-09 22:46)
· 苹果在线商店临时关闭 或将推新Macbook(2010-02-09 22:39)
· 豆瓣网推出豆瓣电台iPhone客户端(2010-02-09 21:51)

编辑推荐：2010年2月编程语言排行榜

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

　　COM 是 WIN32 系统中最复杂和晦涩，最重要的技术。

　　【备注：以下是个人看法】COM 是比传统的 API 提供方式（*.h, *.lib, *.dll) 更”高“层次的服务标准， 从某种意义上说，COM也是一种”API“，但它的使用和实现都要比传统API复杂的多。COM 的宗旨是提供这样的一种标准，使操作系统，独立软件开发商之间以一种标准方式提供交互性服务。COM 相比传统API合作方式相比：两者本质上都提供的二进制代码（编译后产品），前者是基于有组织的，语言中立的 具有面向对象特性的标准。后者是零散的，语言相关，面向过程的方式。前者的显著优点是，它的组件是共享式的安装在系统上的一种服务，组件位置对用户是透明的，因此它仅需要在每个客户端部署一份（甚至部署在一台远程计算机）。而后者位置不透明因此未必能够做到这一点。COM 技术使用推出新接口实现升级，以降低对客户端的影响。而传统 API 提供方式有可能在升级时导致DLL版本混乱。

　　由于对语言中立性的追求以及COM的标准，COM 的代码相比普通的 C/C++ 可读性更低，但也具有一定规律性。ATL中提供了一些辅助类来降低 COM 代码的使用难度。

　　这里是两个例子。

　　【例子1】： 在 Windows Mobile 上获取收件箱中的短信内容。

　　（1）每个帐户对应的是一个MsgStore。每个MsgStore可包含一组文件夹。

　　（2）提供EntryID，用 OpenEntry 方法打开MAPI对象。

　　（3）MAPI容器 使用 GetContentTable 获取容器内内容的描述表。

　　（4）MAPI Table 使用SetColumns 设定要查询的字段。

　　（5）使用 MAPI 提供的函数释放相关查询信息分配的内存。

　　更多细节参考 相关SDK 文档。

　　下面是代码。当打开收件箱以后，短信是按照时间升序排列的，因此使用 SeekRow 方法把游标游动到最后一行读出既是最近收到的短信。

Code_GetLastMessage

//获取SMS的最近收到的短信，返回为“发件人：内容”的格式。
bool GetLastMessage(TCHAR *buffer, int bufferSize)
{
    HRESULT hr = S_OK;
    ICEMAPISession *pSession = NULL;
    IMsgStore *pMsgStore = NULL;
    IMAPIFolder *pFolder = NULL;
    IMessage *pMsg = NULL;
    
    //和Table有关的MAPI对象
    IMAPITable *pTable = NULL;
    SRowSet *pRows = NULL;    
    SPropValue *pSProps = NULL;
    ULONG ulObjType; //对象类型
    ULONG cCount = 0;
    int remainLength, subjectLength; //字符串长度
    bool result = false;

    //设置MsgStore表的要查询字段
    SizedSPropTagArray(2 , Columns1) = 
    {
        2,
        PR_ENTRYID, //Store的Entry ID
        PR_DISPLAY_NAME //Store的Display Name 
    };
    //设置收件箱内容表要查询的字段
    SizedSPropTagArray(1, Columns2) = 
    {
        1,
        PR_ENTRYID  //获取每个消息的EntryID
    };


    CoInitializeEx(NULL, COINIT_MULTITHREADED);  
    hr = MAPIInitialize(NULL);
    if(FAILED(hr))
    {
        wcscpy_s(buffer, bufferSize, _T("failed at: MAPIInitialize"));
        goto TAG_CLEAR;
    }

    hr = MAPILogonEx(0, NULL, NULL, 0, (LPMAPISESSION *)&pSession);
    if(FAILED(hr))
    {
        wcscpy_s(buffer, bufferSize, _T("failed at: MAPILogonEx"));
        goto TAG_CLEAR;
    }
    hr = pSession->GetMsgStoresTable(0, &pTable);
    if(FAILED(hr))
    {
        wcscpy_s(buffer, bufferSize, _T("failed at: GetMsgStoresTable"));
        goto TAG_CLEAR;
    }

    pTable->SetColumns((LPSPropTagArray)&Columns1, 0); 

    while(SUCCEEDED(pTable->QueryRows(1, 0, &pRows)))
    {
        if (pRows == NULL || pRows->cRows != 1) 
            break; 

        //开始一条条记录查询,
        //pRows->aRow[0].lpProps[0]代表了第一个查询属性，即Entry ID,
        //pRows->aRow[0].lpProps[1]则表示Display Name。 
        if (_tcsicmp(pRows->aRow[0].lpProps[1].Value.lpszW, _T("SMS")) == 0) 
        { 
            //如果是SMS，则获取Store对象 
            pSession->OpenEntry(
                pRows->aRow[0].lpProps[0].Value.bin.cb, (LPENTRYID)pRows->aRow[0].lpProps[0].Value.bin.lpb, 
                NULL, MAPI_BEST_ACCESS,    &ulObjType,(LPUNKNOWN*)&pMsgStore
                );
            break;
        }
        FreeProws(pRows);
        pRows = NULL;
    }
    if(pRows != NULL)
    {
        FreeProws(pRows); 
    }
    if(pTable != NULL)
    {
        pTable->Release();
    }

    if(pMsgStore == NULL)
    {
        wcscpy_s(buffer, bufferSize, _T("Cannot Open MsgStore of SMS."));
        goto TAG_CLEAR;
    }

    //查询“收件箱”的ENTRYID
    ULONG STags[] = { 1,    PR_CE_IPM_INBOX_ENTRYID };
    hr = pMsgStore->GetProps((SPropTagArray*)&STags, 0, &cCount, &pSProps);
    if(FAILED(hr))
    {
        wcscpy_s(buffer, bufferSize, _T("Cannot Get Inbox's EntryID."));

　　    if(pSProps != NULL) MAPIFreeBuffer(pSProps);
        goto TAG_CLEAR;
    }

    //打开收件箱文件夹
    hr = pMsgStore->OpenEntry(pSProps[0].Value.bin.cb, (LPENTRYID)pSProps[0].Value.bin.lpb,NULL,0, &ulObjType, (IUnknown **)&pFolder);

    if(pSProps != NULL)
        MAPIFreeBuffer(pSProps);

    if (FAILED(hr))
    {
        wcscpy_s(buffer, bufferSize, _T("Cannot Open Folder Of Inbox."));
        goto TAG_CLEAR;
    }

    //获取收件箱的内容表。
    pFolder->GetContentsTable(0, &pTable);

    //尝试移动到最后一行（最近收到的短信）
    ULONG rowCount;
    hr = pTable->GetRowCount(0, &rowCount);
    if(FAILED(hr) || rowCount <= 0)
    {
        pTable->Release();
        pTable = NULL;
        wcscpy_s(buffer, bufferSize, _T("收件箱：没有新的消息。"));
        goto TAG_CLEAR;
    }
    hr = pTable->SeekRow(BOOKMARK_BEGINNING, rowCount - 1, NULL);
    hr = pTable->SetColumns((LPSPropTagArray)&Columns2, 0);
    
    //要查询的消息属性：发件人，主题（短信内容）
    ULONG pMsgPropTags[] = { 2, PR_SENDER_EMAIL_ADDRESS, PR_SUBJECT };

    while(SUCCEEDED(pTable->QueryRows(1, 0, &pRows)))
    {
        //通过OpenEntry获取IMessage对象
        pFolder->OpenEntry(
            pRows->aRow[0].lpProps[0].Value.bin.cb,
            (LPENTRYID)pRows->aRow[0].lpProps[0].Value.bin.lpb, //Message's EntryID
            NULL, 
            MAPI_BEST_ACCESS, 
            &ulObjType,
            (LPUNKNOWN*)&pMsg
            );
        //这里拿到每个IMessage对象就代表了Folder里面的每一条Message,可以通过对它的操作来获取想要的信息。
        hr = pMsg->GetProps((SPropTagArray*)&pMsgPropTags, MAPI_UNICODE, &cCount, &pSProps);
        if(SUCCEEDED(hr))
        {
            if(pSProps[0].ulPropTag == PR_SENDER_EMAIL_ADDRESS)
            {
                wcscpy_s(buffer, bufferSize, pSProps[0].Value.lpszW);
                wcscat_s(buffer, bufferSize, _T(": "));
            }
            else
            {
                buffer[0] = '\0';
            }

            if(pSProps[1].ulPropTag == PR_SUBJECT)
            {
                remainLength  = bufferSize - wcslen(buffer) - 1;
                subjectLength = wcslen(pSProps[1].Value.lpszW);
                if(remainLength >= subjectLength)
                    wcscat_s(buffer, bufferSize, pSProps[1].Value.lpszW);
                else
                {
                    //截断字符串，并用三个点表示省略。
                    wcsncpy_s(buffer + wcslen(buffer), bufferSize, pSProps[1].Value.lpszW, remainLength - 3);
                    wcscat_s(buffer, bufferSize, _T("..."));
                }
            }
            result = true;            
        }
        else
        {
            wcscpy_s(buffer, bufferSize, _T("Cannot Get Message."));
        }
        if(pSProps != NULL)
            MAPIFreeBuffer(pSProps);

        //仅仅读取一条Message
        break;
    }

    if(pRows != NULL)
    {
        FreeProws(pRows); 
        pRows = NULL; 
    }
    if(pTable != NULL)
    {
        pTable->Release();
        pTable = NULL;
    }


TAG_CLEAR:

    if(pMsg != NULL)
        pMsg->Release();

    if(pFolder != NULL)
        pFolder->Release();

    if(pMsgStore != NULL)
        pMsgStore->Release();

    if(pSession != NULL)
    {
        pSession->Logoff(0, 0, 0);
        pSession->Release();
    }
    MAPIUninitialize();
    CoUninitialize();
    return result;
}

　　本段代码已运用于 LedScreen插件V2.0 中：　　
　　

　　【例子2】：在ActiveX控件中调用页面上的 JavaScrpt 方法。

　　（1）IE调用ActiveX控件的方法，本质上是通过控件的 IDispatch 接口调用的，该技术也就是自动化技术。该技术绑定时间比自定义接口最晚，因此效率不如通过自定义接口调用，但是也最灵活。 当我们在ActiveX 控件中调用页面的脚本时，我们同样通过脚本对象的 IDispatch 接口调用。

　　（2）假设 ActiveX 控件事先知道页面上的方法的参数列表，（相当于我们已知一个C#委托或者C++函数指针定义），如果不这样假定，则实在意义不大。

　　 (3)  我们在控件接口中添加一个方法，称为InvokeJS。在这个方法里我们试图调用 页面上的一个指定名称的javascript方法。并且我们给这个方法一个字符串参数，内容是”hello world“。代码如下：

code_InvokeJS

//调用JS方法（无参数）
STDMETHODIMP CMyControl::InvokeJS(BSTR funName)
{
    if(m_document == NULL)
        return S_OK;

    CComPtr<IHTMLDocument2> pHtmlDoc;
    CComPtr<IDispatch> pScript; //CComPtr：会自动调用Release();
    
    HRESULT hr;
    CComBSTR bstrMember;
    DISPID dispid; //DISPID即LONG（int32），接口函数的数字序号。

    bstrMember.AssignBSTR(funName);
    hr = this->m_document->QueryInterface(IID_IHTMLDocument2, (void**)&pHtmlDoc);
    hr = pHtmlDoc->get_Script(&pScript);
    hr = pScript->GetIDsOfNames(IID_NULL, &bstrMember, 1, LOCALE_SYSTEM_DEFAULT, &dispid);


    //调用脚本对象的Invoke方法执行脚本函数：
    DISPPARAMS dispparams;
    memset(&dispparams, 0, sizeof dispparams);
    dispparams.cArgs = 1;
    dispparams.rgvarg = new VARIANT[dispparams.cArgs];
  
    for( int i = 0; i < dispparams.cArgs; i++)
    {
        CComBSTR bstr = "hello world"; // back reading
        bstr.CopyTo(&dispparams.rgvarg[i].bstrVal);
        dispparams.rgvarg[i].vt = VT_BSTR;
    }
    dispparams.cNamedArgs = 0;

    EXCEPINFO excepInfo;
    memset(&excepInfo, 0, sizeof excepInfo);
    CComVariant vaResult;

    UINT nArgErr = (UINT)-1;  // initialize to invalid arg
    hr = pScript->Invoke(dispid, IID_NULL, 0, DISPATCH_METHOD, &dispparams, &vaResult, &excepInfo, &nArgErr);

    return S_OK;
}

　　浏览器对象实际上我们是在控件的 SetClientSite 方法中获取的， 该方法在创建控件时由容器调用，以给ActiveX控件一个时机去获取一些容器信息。则在MSDN文档中有专门介绍。控件的SetClientSite代码如下：

code_setClientSite

//以下是控件的两个成员变量：
private:
    IWebBrowser2* m_browser; //浏览器对象
    IDispatch* m_document; //文档对象


STDMETHODIMP CMyControl::SetClientSite(IOleClientSite* pClientSite)
{
    HRESULT hr = S_OK;
    IServiceProvider *isp, *isp2 = NULL;
    //BSTR url;

    if (!pClientSite)
    {
        COMRELEASE(m_browser);
    }
    else
    {
        hr = pClientSite->QueryInterface(IID_IServiceProvider, reinterpret_cast<void **>(&isp));
        if (FAILED(hr))
        {
            hr = S_OK;
            goto cleanup;
        }
        hr = isp->QueryService(SID_STopLevelBrowser, IID_IServiceProvider, reinterpret_cast<void **>(&isp2));
        if (FAILED(hr))
        {
            hr = S_OK;
            goto cleanup;
        }
        hr = isp2->QueryService(SID_SWebBrowserApp, IID_IWebBrowser2, reinterpret_cast<void **>(&m_browser));
        if (FAILED(hr))
        {
            hr = S_OK;
            goto cleanup;
        }

        //获取文档对象
        hr = m_browser->get_Document(&m_document);
        if(FAILED(hr))
        {
            m_document = NULL;
        }
        //m_browser->get_LocationURL(&url);
        //MessageBox((LPCTSTR)url, _T(""), MB_OK);
cleanup:
        // Free resources.
        COMRELEASE(isp);
        COMRELEASE(isp2);
        return hr;
    }

    return S_OK;
}

 　　（4）假设在页面上具有这样一个JS方法：当我们点击按钮时，页面首先通过IDispatch接口找到控件的InvokeJS方法，然后在控件中又通过IDispatch接口找到脚本的AlertMessage方法，弹出一个MessageBox。

code_HTML

<HTML>
<HEAD>
<TITLE>对象测试页</TITLE>
</HEAD>
<BODY>
<script type="text/javascript" >
function AlertMessage(info)
{
    alert(info);
}
</script>
<OBJECT ID="MyControl" CLASSID="CLSID:......"></OBJECT>
<button onclick="MyControl.InvokeJS('AlertMessage');">InvokeJavaScript</button>
</BODY>
</HTML>

 　　【例子3】：通过 ITaskBar 对象隐藏或显示任务栏按钮。

Code_ShowInTaskBar

void ShowInTaskbarList(HWND hWnd, BOOL bShow)
{
    HRESULT hr;
    ITaskbarList* pTaskbarList;

    CoInitialize(NULL);
    hr = CoCreateInstance(CLSID_TaskbarList, NULL, CLSCTX_INPROC_SERVER, 
            IID_ITaskbarList, (void**)&pTaskbarList);

    //==============  HrInit();==================
    //Initializes the taskbar list object. This method must be called before any other 
    //ITaskbarList methods can be called. 
    pTaskbarList->HrInit();

    if(bShow)
    {
        pTaskbarList->AddTab(hWnd);
    }
    else
    {
        pTaskbarList->DeleteTab(hWnd);
    }
    pTaskbarList->Release();

    CoUninitialize();
}

 　　参考内容：

　　《Mapi实例 》：http://bingqingwu5799.blog.163.com/blog/static/338365512009320111114912/

　　MSDN & Windows Mobile 6 SDK Documents；

　　CSDN 关于 ActiveX 调用页面脚本的文章。（原连接未记录）

评论: 0　查看评论　发表评论

最新新闻：
· 知名扩展 Firebug 的简化版登陆 Chrome(2010-02-09 22:59)
· Google 悄悄地启用 1e100.net，打枪地不要(2010-02-09 22:57)
· 从 Google 代码库找到的好东西(2010-02-09 22:46)
· 苹果在线商店临时关闭 或将推新Macbook(2010-02-09 22:39)
· 豆瓣网推出豆瓣电台iPhone客户端(2010-02-09 21:51)

编辑推荐：2010年2月编程语言排行榜

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

　　因为没有原创内容，相当于看书笔记，因此本打算发在QQZone，但因为QQ空间日志忽然服务器繁忙，大骂腾讯无奈还是把此日志临时发布在自己的博客上。

　　参考资料：《计算机算法设计与分析》（第三版）。
　　条件：
　　（1）带权有向图 G = (V, E); 任意边的权 >= 0;

　　算法：
　　贪心法。体现在从源节点开始，每次从集合S外“选一个最近的节点”添加到S中，然后对dist数组做更新。

　　参数说明：

　　T：模板参数，权值类型。（计量长度的数据类型）

　　int n; 图的节点数；　　

　　int v; 出发节点（源节点）的索引。

　　T dist[];  dist[i]表示当前条件下 v 到 i 节点之间的最短距离。求解过程中这个数组随着集合S的扩充而动态变化。

　　int prev[]; prev[i]表示从 v 到 i 节点之间的最短距离路径上的前一个节点。可以通过这个数组反塑获取到完整路径。

　　T *c; 图的矩阵表示。c[i][j]表示边（i，j）的权。当无通路时为一个大数。 

 =========================　　

　　　　　　代码：

========================= 

 Code_Dijkstra
// Dijkstra.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <stdlib.h>
#include <stdio.h>

#define maxint 0x7fffffff

//dijkstra 算法 ，索引是从1开始的

template <class T>
void Dijkstra(int n, int v, T dist[], int prev[], T* c)
{
    int i, j, temp, u;
    T newdist;
    //bool s[6];
    bool *s = (bool*)malloc(n*sizeof(bool));
    printf("sizeof(bool) = %d bytes. \n", sizeof(bool)); //1 bytes;

    //[0] 初始化
    for(i = 0; i < n; i++)
    {
        dist[i] = c[v*n+i]; //c[v][i]
        s[i]=false;            //在集合S外
        if(dist[i] == maxint) prev[i] = 0;
        else prev[i] = v;
    }

    //把节点v放入集合S中
    dist[v]=0;
    s[v] = true;

    //向S集合中依次添加其他（n-1）个节点
    for(i = 0; i < (n-1); i++)
    {
        temp = maxint;
        u = v;

        //[1] 选出S集合外的距离最近的一个点u
        for(j = 0; j < n; j++)
        {
            if(!s[j] && (dist[j] < temp))
            {
                u = j;
                temp = dist[j];
            }
        }

        //[2] 把u放入S集合；
        s[u] = true; 

        //[3] 调整dist数组和prev数组
        for(j = 0; j < n; j++)
        {
            //查看 u 到 j 节点之间有通路？？？
            if( !s[j] && c[u*n+j] < maxint ) //if( !s[j] && c[u][j] < maxint )
            {
                newdist = dist[u] + c[u*n+j]; //newdist = dist[u]+ c[u][j];
                if(newdist < dist[j])
                {
                    dist[j] = newdist;
                    prev[j] =u;
                }
            }
        }
    }

    free(s);
}


int main(int argc, char* argv[])
{
    int i, dist[5], prev[5];
    int c[5][5] = 
    {
        //     0       1       2       3       4
        {      0,     10, maxint,     30,    100 }, //0
        {     10,      0,     50, maxint, maxint }, //1
        { maxint,     50,      0,     20,     10 }, //2
        {     30, maxint,     20,      0,     60 }, //3
        {    100, maxint,     10,     60,      0 }  //4
    };


    //调用算法 节点数=5，出发节点=0
    Dijkstra<int>(5, 0, dist, prev, (int*)c);

    //【1】打印节点1到其他节点的最短距离
    printf("dist: ");
    for(i=0; i<5; i++)    printf("%d,", dist[i]);
    printf("\n");

    //【2】打印prev数组，记录从出发点到本节点的最短路径的上一个节点
    printf("prev: ");
    for(i=0; i<5; i++) printf("%d,", prev[i]);
    printf("\n");

    //【3】打印从0到4的最短路径
    printf("0->4 Path: ");
    int stack[5], top=-1;
    stack[++top] = 4;
    //逆向追溯节点（入栈）
    while(true)
    {
        stack[top+1] = prev[stack[top]];
        top++;

        //栈顶是否已经是出发点
        if(stack[top] == 0)
            break;
    }
    //节点依次出栈
    for(;top>0;top--)
        printf("%d - ", stack[top]);
    //栈中最后一个节点
    printf("%d\n", stack[top]);
    return 0;
}

=========================
　　　　　　输出：
=========================
sizeof(bool) = 1 bytes.
dist: 0,10,50,30,60,
prev: 0,0,3,0,2,
0->4 Path: 0 - 3 - 2 - 4 

评论: 0　查看评论　发表评论

最新新闻：
· 知名扩展 Firebug 的简化版登陆 Chrome(2010-02-09 22:59)
· Google 悄悄地启用 1e100.net，打枪地不要(2010-02-09 22:57)
· 从 Google 代码库找到的好东西(2010-02-09 22:46)
· 苹果在线商店临时关闭 或将推新Macbook(2010-02-09 22:39)
· 豆瓣网推出豆瓣电台iPhone客户端(2010-02-09 21:51)

编辑推荐：2010年2月编程语言排行榜

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

Code_magicCube
#include "stdafx.h"

/*
魔方——操作阶数实验
从一个已复原的魔方开始，重复某一个操作序列，必然会在有限次重复操作之后又复原，设计程序，输入任意一个操作序列，
输入它的复原重复次数。
操作有18个：
L，L'，L"：分别为左面顺时针转90度、逆时针转90度和180度翻转；
R，R'，R"：分别为右面顺时针转90度、逆时针转90度和180度翻转；
T，T'，T"：分别为顶面顺时针转90度、逆时针转90度和180度翻转；
D，D'，D"：分别为底面顺时针转90度、逆时针转90度和180度翻转；
F，F'，F"：分别为前面顺时针转90度、逆时针转90度和180度翻转；
B，B'，B"：分别为背面顺时针转90度、逆时针转90度和180度翻转。
在实验报告中记录如下事项：
输入L，则输出4。
输入L"，则输出2。
输入D" R，则输出30。
输入D R，则输出105。
以及其它自定的操作序列。
*/
#include <stdio.h>
#include <string.h>

//面索引
#define P_LEFT      0
#define P_FRONT  1
#define P_RIGHT  2
#define P_BACK     3
#define P_TOP         4
#define P_BOTTOM 5

//六个面, 
//cells[0]: Left
//cells[1]: Front
//cells[2]: Right
//cells[3]: Back
//cells[4]: Top
//cells[5]: Bottom
//面内索引：
// 0 1 2
// 7 * 3
// 6 5 4
//================
char cells[6][8];

//初始化魔方
void init()
{
    int i,j;
    for(i=0;i<6;i++)
        for(j=0;j<8;j++)
            cells[i][j]=i;
}

//复原了吗？
bool isdone()
{
    int i,j;
    for(i=0;i<6;i++)
        for(j=0;j<8;j++)
        {
            if(cells[i][j] != i)
                return false;
        }
    return true;
}

//获取旋转的信息
void getinfo(char* mode, int* angle, int* sides)
{
    //获取角度
    switch(mode[1])
    {
    case 0: 
        *angle = 90;
        break;
    case '\'': 
        *angle = -90;
        break;
    case '"':
        *angle = 180;
        break;
    }
    
    //获取五个受影响的面，第一个是主面，其他四个是从主面看过去的顺时针顺序影响面
    switch(mode[0])
    {
    case 'L': //左
        sides[0]=P_LEFT;
        sides[1]=P_TOP;
        sides[2]=P_FRONT;
        sides[3]=P_BOTTOM;
        sides[4]=P_BACK;
        break;
    case 'R': //右
        sides[0]=P_RIGHT; //主旋转面
        sides[1]=P_TOP;
        sides[2]=P_BACK;
        sides[3]=P_BOTTOM;
        sides[4]=P_FRONT;
        break;
    case 'T': //顶面
        sides[0]=P_TOP;
        sides[1]=P_BACK;
        sides[2]=P_RIGHT;
        sides[3]=P_FRONT;
        sides[4]=P_LEFT;
        break;
    case 'D': //底面
        sides[0]=P_BOTTOM;
        sides[1]=P_FRONT;
        sides[2]=P_RIGHT;
        sides[3]=P_BACK;
        sides[4]=P_LEFT;
        break;
    case 'F': //前面
        sides[0]=P_FRONT;
        sides[1]=P_TOP;
        sides[2]=P_RIGHT;
        sides[3]=P_BOTTOM;
        sides[4]=P_LEFT;
        break;
    case 'B': //背面
        sides[0]=P_BACK;
        sides[1]=P_TOP;
        sides[2]=P_LEFT;
        sides[3]=P_BOTTOM;
        sides[4]=P_RIGHT;
        break;
    }
}

//传入一个操作字符串，进行相应操作

void rotate(char* mode)
{
    char temp[8],temp2[3];
    int i, angle, sides[5];
    //获取角度和5个面
    getinfo(mode, &angle, sides);

    //复制主面到一个临时备份
    for(i=0;i<8;i++)
        temp[i]=cells[ sides[0] ][i];

    switch(angle)
    {
    case 90: //顺时针旋转90, offset = 6
        //[1]主面内部旋转
        for(i=0;i<8;i++)
            cells[sides[0]][i]=temp[(i+6)%8];

        //备份影响面的数字
        temp2[0]=cells[sides[4]][4];
        temp2[1]=cells[sides[4]][3];
        temp2[2]=cells[sides[4]][2];

        //4个受影响面
        cells[sides[4]][4]=cells[sides[3]][2];
        cells[sides[4]][3]=cells[sides[3]][1];
        cells[sides[4]][2]=cells[sides[3]][0];

        cells[sides[3]][2]=cells[sides[2]][0];
        cells[sides[3]][1]=cells[sides[2]][7];
        cells[sides[3]][0]=cells[sides[2]][6];

        cells[sides[2]][0]=cells[sides[1]][6];
        cells[sides[2]][7]=cells[sides[1]][5];
        cells[sides[2]][6]=cells[sides[1]][4];

        cells[sides[1]][6]=temp2[0];
        cells[sides[1]][5]=temp2[1];
        cells[sides[1]][4]=temp2[2];

        break;

    case -90: //逆时针旋转90, offset = 2
        //[1]主面内部旋转
        for(i=0;i<8;i++)
            cells[sides[0]][i]=temp[(i+2)%8];

        //备份影响面的数字
        temp2[0]=cells[sides[1]][6];
        temp2[1]=cells[sides[1]][5];
        temp2[2]=cells[sides[1]][4];

        //4个受影响面
        cells[sides[1]][6]=cells[sides[2]][0];
        cells[sides[1]][5]=cells[sides[2]][7];
        cells[sides[1]][4]=cells[sides[2]][6];

        cells[sides[2]][0]=cells[sides[3]][2];
        cells[sides[2]][7]=cells[sides[3]][1];
        cells[sides[2]][6]=cells[sides[3]][0];

        cells[sides[3]][2]=cells[sides[4]][4];
        cells[sides[3]][1]=cells[sides[4]][3];
        cells[sides[3]][0]=cells[sides[4]][2];

        cells[sides[4]][4]=temp2[0];
        cells[sides[4]][3]=temp2[1];
        cells[sides[4]][2]=temp2[2];

        break;

    case 180: //翻转180, offset = 4
        //[1]主面内部旋转
        for(i=0;i<8;i++)
            cells[sides[0]][i]=temp[(i+4)%8];

        //备份影响面的数字
        //上下对换
        temp2[0]=cells[sides[1]][6];
        temp2[1]=cells[sides[1]][5];
        temp2[2]=cells[sides[1]][4];

        cells[sides[1]][6]=cells[sides[3]][2];
        cells[sides[1]][5]=cells[sides[3]][1];
        cells[sides[1]][4]=cells[sides[3]][0];

        cells[sides[3]][2]=temp2[0];
        cells[sides[3]][1]=temp2[1];
        cells[sides[3]][0]=temp2[2];

        //左右对换
        temp2[0]=cells[sides[4]][4];
        temp2[1]=cells[sides[4]][3];
        temp2[2]=cells[sides[4]][2];

        cells[sides[4]][4]=cells[sides[2]][0];
        cells[sides[4]][3]=cells[sides[2]][7];
        cells[sides[4]][2]=cells[sides[2]][6];

        cells[sides[2]][0]=temp2[0];
        cells[sides[2]][7]=temp2[1];
        cells[sides[2]][6]=temp2[2];

        break;
    }        
}

//
int _tmain(int argc, _TCHAR* argv[])
{
    char* token=NULL;
    char step[128][4];
    char line[512];
    int i, length = 0; //每一次有几步操作
    int result = 0;

    //初始化
    init();

    gets(line);
    
    //用空格分割
    token=strtok(line, " ");

    //复制动作
    while(token!=NULL)
    {
        strcpy(step[length++], token);
        token = strtok(NULL, " ");
    }

    while(true)
    {
        //执行一次动作序列
        for(i=0;i<length;i++)
            rotate(step[i]);

        result++;

        //复原了吗?
        if(isdone())
            break;
    }

    printf("%d\n", result);
    getchar();
    return 0;
}

评论: 0　查看评论　发表评论

最新新闻：
· 知名扩展 Firebug 的简化版登陆 Chrome(2010-02-09 22:59)
· Google 悄悄地启用 1e100.net，打枪地不要(2010-02-09 22:57)
· 从 Google 代码库找到的好东西(2010-02-09 22:46)
· 苹果在线商店临时关闭 或将推新Macbook(2010-02-09 22:39)
· 豆瓣网推出豆瓣电台iPhone客户端(2010-02-09 21:51)

编辑推荐：2010年2月编程语言排行榜

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库