hATEmATH的网上田园

HateMath我最"大"

hATEmATH的网上田园 — Thu, 18 Feb 2010 12:02:00 GMT

    今年回去的很是时候，在回去的当晚就下了大雪，迟一天就怕都很难走了。
    家里天气很冷，我一直纳闷咱家房子怎么盖的，无论何时都比别人家的低几度。回家后第二天就冻着了，连续几天，上吐下泻，很让人崩溃。

    不过其间有件事值得纪念，就是带gf出去看雪。  gf是南方人，用她的话说，长这么大从来没见过真的雪。这回可算见到真的了，而且很大。
    玩的时候突发奇想，用雪来作画，于是有了下面几幅图片：）

猜猜这是哪个卡通？

弯弓射大雕：

某人的杰作，据称是只鸭子

淮河大坝的东坡，留下迄今为止最大的“HateMath”
得使劲往下翻页

修理电磁炉

hATEmATH的网上田园 — Mon, 01 Feb 2010 04:45:00 GMT

家里有个电磁炉，用的时间久了，那个功能调节开关终于不灵了，很多时候按了没反应。于是决定修一下。

自制LED床头触摸延时灯

hATEmATH的网上田园 — Mon, 18 Jan 2010 06:47:00 GMT

2009年终总结

hATEmATH的网上田园 — Thu, 31 Dec 2009 03:03:00 GMT

坐车回家的时候，路上无聊回顾了一下，今年做了3件事。1，辞了工作。2，换了城市。3，欠了一屁股债。

辞了程序员的工作，是因为本人才智平庸，自觉不适应这种不断学习又不断遗忘的猴子摘玉米式的工作。
换了城市的直接原因是为了新工作，间接原因是不喜欢大城市的喧嚣和浮躁。
至于欠银行钱，也是实在没办法的事。

自制呼吸灯电路蓝色绚丽版 [图视频]

hATEmATH的网上田园 — Tue, 08 Dec 2009 06:56:00 GMT

最近在折腾低频震荡电路的制作，闲暇时看到N78的那个呼吸灯，觉得挺有趣的，于是就想做个demo玩玩。

网上搜了一下，大部分都是用一个老外的电路图，用7555集成电路做的。我分析了一下，电路主要由两个部分组成：7555模块主要是产生方波，RC模块是产生渐变的电压，形成呼吸效果。换言之，任何能产生方波和产生渐变电压的模块都可以用来做呼吸灯，不同的是是否便利和成本问题。

下面要介绍的这个呼吸灯电路是我设计的。其中的RC模块借鉴了老外的图，而方波产生模块我用了一种比7555成本更低的方案，用两个三极管构成无稳态多谐振荡电路。由于三极管工作在饱和区，所以不存在调试工作点的问题。

板子正面亮个相：

电路图是这个样子滴：

有了电路图，接下来就是焊板子了。话说这面包板真是难焊接，尤其是想美观点的话。以后搞复杂的电路还是得考虑上三氯化铁腐蚀法。板子背面：

起身捶捶腰，是到看效果的时候啦。电压就设为5V吧，上电！

内幕：刚开始的时候，由于电阻和电容值计算不当，没有得到想要的效果。后来重新调整电阻的阻值，终于可以了：P

在伸手不见黑夜的五指，用手机拍的效果图：
：

我知道你现在想什么。。。。没错儿，手机拍的效果太矬了，也看不出呼吸的感觉。咱还是看看视频吧：

最后补充一点，其实除了上述调节电压的方式，还有一种截然不同的思路，就是用PWM调制来控制灯的亮度。大致想了想，电路肯定比这个复杂，但是好处是不需要用上千微法的大电容了，体积会很小。

就这样了，以后有什么新想法再折腾。

一个把手机号码转为图片的绿色程序，用于论坛帖资料。

hATEmATH的网上田园 — Fri, 27 Nov 2009 03:06:00 GMT

    最近学了一下VB2008，仿佛回到了学生时代。还记得若干年前，我在图书馆翻到一本破烂的VB5.0教程，看了几页恍然大悟：原来优美的windows界面（那时我只见过一种操作系统的界面）是这样搞出来的！于是屁颠屁颠的直接去机房照着书练习，很快出了自己的第一个helloword：英寸和厘米的转换器。

    再次回到vb，恍如隔世，我只能说：脱胎换骨！太好用了！以前，考虑程序的某些高级特性和后续扩展，基本上都用MFC来做的，毕竟VB里用一个API好麻烦。但是现在，很多高级功能都有相关的类直接提供。

    这里贴一个转化手机号码为图片的小程序。有时我们会在网上发布一些信息（比如求购之类的），最后会留下qq或者手机号码。有些很贴心的论坛自动把手机号转为图片，有些则不提供这种功能。要知道，字符形式的手机号码很容易被软件搜出来，然后，你就等着接骚扰电话吧。。。所以发布信息时，把手机号转为图片发上去，是个不错的防骚扰的选择。

    运行图片如下，可以调整文字和背景的颜色：


    以下代码生产一个位图，然后把号码写在位图上，这样就是图片格式了。

    Private Sub String2Pic()
        '得到文字验证码
        Dim random As New Random()
        Dim wz As String
        wz = TextBox1.Text

        '制作图形
        Dim bmp As New Bitmap(105, 20)
        Dim g As Graphics = Graphics.FromImage(bmp)
        g.FillRectangle(New SolidBrush(clrBkgnd), New RectangleF(0, 0, 105, 20))
        g.DrawString(wz, New Font("黑体", 14), New SolidBrush(clrText), 0, 0)

        '显示
        Me.PictureBox1.Image = bmp
    End Sub

源码下载：
http://blog.vckbase.com/Files/HateMath/Phone2Pic.rar

PS：还用VB写了一个支持多光驱的CD播放器，不过这年头大家都听mp3，所以。。。这个程序就不发布了，自己留着用。

我就是那只球球，他nnd！

hATEmATH的网上田园 — Tue, 24 Nov 2009 01:44:00 GMT

    有个old++的笑话，说是一记者去南极采访企鹅，问题是“每天做什么”，一连问了99只，回答都是“吃饭、睡觉、打球球”。到最后一只小企鹅，答“吃饭、睡觉”。记者不解问“你怎么不打球球？”小企鹅怒“我就是那只球球，你奶奶的！”

    不曾料想，我这一个月来也被当了球球，在H市和N市的两个部门之间被踢来踢去，其中还被南京人才服务中心档案处主任卢贱人索贿（老子就是不给，你奶奶的！等着我的检举信吧），这场臭球昨天才落下帷幕。想听听经过？想也我也不讲，有句话叫“痛定思痛，痛何如哉”，干脆不讲。
    此间经历，有车票若干为证，有白发若干为证。
    完。

DIY：降低电脑电源风扇噪声

hATEmATH的网上田园 — Thu, 12 Nov 2009 01:43:00 GMT

     电源用了1年多，噪声渐渐不能忍受。除尘、滴油，能用的方法都用了，还是吵。在一个周末痛下决心对风扇进行外科手术。
    我是这样想的：自从没了独立显卡，很少打游戏了，机箱的功耗一下降下来很多；加上最近换了新785G主板和CPU，看1080p的高清也不怎么耗电，所以电源的功率不需要那么大了。电源功率变小了，对散热的要求也变小了。于是我决定给电源风扇降速。

    用软件？很遗憾，除了高级电源，大部分电源都不能通过软件调节风扇速度(机箱、主板和CPU风扇可以软件调节)。调速器？NO，花那个钱我还不如换个风扇呢。怎么办呢？追求简洁的我直接串了电阻。通过串联电阻给风扇降压，从而降低转速。电阻至少选1/2W的。
    废话不多说，上图：

    手术后到现在用了一周，效果不错，噪声明显降低，运行时也无死机等异常（我甚至玩了几次“空降兵”游戏(FPS 3D)，长达个把小时也没问题）。本着负责任的态度这才发布到blog上供大家参考。
    风扇灰太多，对不起观众了，呵呵。

推荐阅读：李幺傻《暗访十年》你所不知道的社会角落

hATEmATH的网上田园 — Fri, 30 Oct 2009 08:00:00 GMT

Hatemath说，值得浪费时间看一下。

http://www.xunlei-mz.cn/art_5924_7014.html

最大化资源管理器(explorer.exe/我的电脑)的绿色小程序

hATEmATH的网上田园 — Mon, 19 Oct 2009 04:47:00 GMT

工作用的新台机下来了，这几天一直在整系统。酷睿4核、4GB、Geforce G100 512MB(垃圾！)、320GB，总的来说凑合。整理的时候发现资源管理器打开时无法自动变为最大化窗口，很是不爽。决定写一个小程序，它启动资源管理器并将其最大化，然后自己默默退出。
流程？再简单不过了，用ShellExecute启动explorer.exe并设置最后一个参数为最大化即可。打开久违的VC6，杀鸡焉用MFC，我写成了win32程序，所有代码如下：

#include "stdafx.h"
#include <shellapi.h>

int APIENTRY WinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPSTR     lpCmdLine,
                     int       nCmdShow)
{
     // bring up explorer(whatever as you wish) and Maximize it, then exit program.

    // params
    HWND hwnd = 0;
    LPSTR lpOpr = "open";
    LPSTR lpFile = "c:\windows\explorer.exe";
    LPSTR lpParam = "/e, E:\";
    LPSTR lpDir = "E:\";
    INT nShowCmd = SW_SHOWMAXIMIZED;

    ::ShellExecute(hwnd, lpOpr, lpFile, lpParam, lpDir, nShowCmd);
    return 0;
}

把编译出来的程序建立个快捷方式，把快捷方式图标改为explorer的图标。单击就会打开E盘(如果你有E盘)，当然，是最大化窗口。
目标完成，收工。

程序没有技术含量，但确实是一个实用的小程序。为生活创造便利，这是一直以来我学编程的最根本的动力。虽然不做这行了，但爱好不变。

程序及代码下载：
http://blog.vckbase.com/Files/HateMath/MaxExplorer.rar

随便写写手中的N78
hATEmATH的网上田园 — Thu, 24 Sep 2009 17:19:00 GMT

昨天78出了点问题，x-plorer无法启动了，虽然不是大问题，但是对于一个在某些方面追求完美的人来说，会感觉不爽。于是我格机重装了系统，现在刚好安装调试。

重装时想到了应该给78写个小记。

09年元旦刚过，我决定换机。将当时的E51以1K的低价出了（我承认后来后悔了），添了800元，买了台黑灰亚太版的N78。水货行货？当然是水货，行货没有WIFI没有GPS没有FM发射机，还比水货贵几百元，有钱没文化的暴发户才买呢。

初拿到手中时，我并不是很满意，总爱和之前的E51比较，列举78的缺点。78的缺点中，最让人抓狂的就是经常串键的牙签般的键盘了，绝对是唯美。所谓唯美，包含两层意思，一是美，二是唯美（就是不实用！）。现在调教了大半年，逐渐用顺手了，也渐渐习惯了牙签键盘，并发现了78的N多可爱之处。

下面show一下我调教后的78。

主题：经常用的就是那几个主题，我一般一个主题用几个月的时间，不会经常换。现在用的是这个：

我喜欢简洁的图标。之所以用黑色背景是因为晚上看着不刺眼。

音乐播放器：天天动听

魔法键盘：应该很多78的机友用这个软件吧，活活。78键盘串键的克星。

我的映射方案是这样的：

强大的的uc浏览器：

智能机的软件实在太多，用智能机不装第三方软件绝对是暴殄天物。

这里拿xplorer压轴。太强大了，是xx手机的不二工具：

传说中73的接班人，当红街机N78：

今天是个特别的日子，特此纪念！

hATEmATH的网上田园 — Sun, 20 Sep 2009 11:34:00 GMT

不再给资本家打工了。来到合肥，明天去单位报道。

科普: C++写的任意文件Base64编解码的例子

hATEmATH的网上田园 — Wed, 22 Jul 2009 06:10:00 GMT

    先说说问什么要写这个例子。
    公司出于保密的需要，限制了员工及其几乎所有的对外访问能力。光驱、U盘、邮件、FTP。。。。你能想到的都限制了。那么员工如何上网查资料呢？远程登录。而且使用的远程登录软件只允许服务器和主机间复制/粘贴文本。可是员工毕竟有自己的需要，我自己的代码和文档如何保存供以后参考呢？我以前积累的代码如何使用呢？想起自己好歹也是个搞软件的，有编译器在手里，咱就有办法。
    想到了以前项目中用到的一个技术：Base64编码。可以设想把任意文件转为BASE64编码的文本文件，再粘贴到因特网上，然后回家把文本复制下来然后解码，即可得到恢复的原文件。

    说干就干，这几天抽空搞了下，OK了。为了使用方便，代码中没有使用平台相关的函数，拿个C++编译器就可以编译出程序。

贴代码：

Makefile:

# u see, a very simple Makefile :)
# HateMath, 2009.7

CXX=g++
BIN=base64tools
SRC=base64tools.cpp base64.cpp

all:
$(CXX) -o $(BIN) $(SRC)

clean:
rm -f $(BIN)

base64.cpp 第三方的

/*
* Copyright (c) 1995-2001 Kungliga Tekniska Högskolan
* (Royal Institute of Technology, Stockholm, Sweden).
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* 3. Neither the name of the Institute nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/

#ifdef HAVE_CONFIG_H
#include <config.h>
RCSID("$Id: base64.c,v 1.5 2004/08/07 13:33:29 tol Exp $");
#endif
#include <stdlib.h>
#include <string.h>
#include "base64.h"

#include <stdio.h>

static char base64_chars[] =
    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

static int
pos(char c)
{
    char *p;
    for (p = base64_chars; *p; p++)
        if (*p == c)
            return p - base64_chars;
    return -1;
}

int
base64_encode(const void *data, int size, char **str)
{
    char *s, *p;
    int i;
    int c;
    const unsigned char *q;


    p = s = (char *) malloc(size * 4 / 3 + 4);
    if (p == NULL)
        return -1;
    q = (const unsigned char *) data;
    i = 0;
    for (i = 0; i < size;) {
        c = q[i++];
        c *= 256;
        if (i < size)
            c += q[i];
        i++;
        c *= 256;
        if (i < size)
            c += q[i];
        i++;
        p[0] = base64_chars[(c & 0x00fc0000) >> 18];
        p[1] = base64_chars[(c & 0x0003f000) >> 12];
        p[2] = base64_chars[(c & 0x00000fc0) >> 6];
        p[3] = base64_chars[(c & 0x0000003f) >> 0];
        if (i > size)
            p[3] = '=';
        if (i > size + 1)
            p[2] = '=';
        p += 4;
    }

    *p = 0;
    *str = s;
    return strlen(s);
}

#define DECODE_ERROR 0xffffffff

static unsigned int
token_decode(const char *token)
{
    int i;
    unsigned int val = 0;
    int marker = 0;
    if (strlen(token) < 4)
        return DECODE_ERROR;
    for (i = 0; i < 4; i++) {
        val *= 64;
        if (token[i] == '=')
            marker++;
        else if (marker > 0)
            return DECODE_ERROR;
        else
            val += pos(token[i]);
    }
    if (marker > 2)
        return DECODE_ERROR;
    return (marker << 24) | val;
}

int
base64_decode(const char *str, void *data)
{
    const char *p;
    unsigned char *q;

    q = (unsigned char *)data;
    for (p = str; *p && (*p == '=' || strchr(base64_chars, *p)); p += 4) {
        unsigned int val = token_decode(p);
        unsigned int marker = (val >> 24) & 0xff;
        if (val == DECODE_ERROR)
            return -1;
        *q++ = (val >> 16) & 0xff;
        if (marker < 2)
            *q++ = (val >> 8) & 0xff;
        if (marker < 1)
            *q++ = val & 0xff;
    }
    return q - (unsigned char *) data;
}

base64.h

/*
* Copyright (c) 1995, 1996, 1997 Kungliga Tekniska Högskolan
* (Royal Institute of Technology, Stockholm, Sweden).
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* 3. Neither the name of the Institute nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/

/* $Id: base64.h,v 1.5 2004/08/07 13:33:29 tol Exp $ */

#ifndef _BASE64_H_
#define _BASE64_H_

int base64_encode(const void *data, int size, char **str);
int base64_decode(const char *str, void *data);

#endif

base64tools.cpp

// Base64Tool.cpp
// Function:
//      1. encode a binary file, and save to TEXT file.
//      2. decode a existing TEXT file which contains base64 code.
// Author: HateMath (http://blog.vckbase.com/HateMath)
// Date: 2009.7
// Any suggestion is welcomed to HateMath2005@163.com

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/stat.h>

#include <fstream>
#include <iostream>

#include "base64.h"

using namespace std;

// set DEBUG  = 1 for verbose log.
#define DEBUG   0

// write "count" bytes of "out" to binary file "file"
void write_to_binary_file(const char * file, char * out, int & count)
{
    fstream binary_file(file, ios::out | ios::binary | ios::trunc);
    binary_file.write(out, count);
    binary_file.close();

    if(DEBUG > 0) printf("write_to_binary_file(): count=%d ", count);
}

// read all bytes from   binary file "file" to "in", , and "count" indicates bytes readed.
// note: "count" should be larger then the "file" size
void read_from_binary_file(const char * file, char * in, int & count)
{
    fstream binary_file(file,ios::binary|ios::in);
    binary_file.read(in, count);
    count = binary_file.gcount();
    binary_file.close();

    if(DEBUG > 0) printf("read_from_binary_file(): count=%d ", count);
}

// write "len" bytes of "data" to txt file "file"
void write_to_txt_file(const char * file, char * data, int & len)
{
    fstream txt_file(file, ios::out | ios::trunc);
    txt_file.write(data, len);
    txt_file.close();
    if(DEBUG > 0) printf("write_to_txt_file()  len=%d ", len);
}

// read all bytes from   txt file "file" to "data", and "len" indicates bytes readed.
// note: "len" should be larger then the "file" size
void read_from_txt_file(const char * file, char * in, int & count)
{
    fstream txt_file(file, ios::in);
    txt_file.read(in, count);
    count = txt_file.gcount();
    txt_file.close();

    if(DEBUG > 0) printf("read_from_txt_file(): count=%d ", count);
}

// return 0 : encode action, 1 : decode action, -1:error.
int parse_args(int argc, char* argv[])
{
    if( argc != 4 )
        return -1;
    else
    {
        if( 0 == strcmp( argv[1], "-E" ) ||
            0 == strcmp( argv[1], "--encode" ) )
        {
            return 0;
        }
        else if( 0 == strcmp( argv[1], "-D" ) ||
                    0 == strcmp( argv[1], "--decode" ) )
        {
            return 1;
        }
        else
        {
            return -1;
        }
    }
}

void show_help()
{
    cout << ""<< endl
            << "Usage: base64tools [OPTION] [SRC] [DST]"    << endl
            << "Encode && decode binary files."                      << endl
            << ""<< endl
            << "  -E,  --encode           Encode binary file [SRC] and write encoded characters to text file [DST]." << endl
            << "  -D,  --decode           Decode text file [SRC] and gernerate binary file [DST]."                              << endl
            << "  --help                  Show help."                    << endl
            << ""<< endl
            << "Examples:"                                                      << endl
            << "    ./base64tools -E in.tar.gz encoded.txt"        << endl
            << "    ./base64tools -D encoded.txt out.tar.gz"     << endl
            << ""<< endl
           << "Author: HateMath"                                            << endl
           << "Report bugs to <HateMath2005@163.com>." << endl;
}

// encode. read from "infile" and write to "outfile"
int perform_encode_action(const char* infile, const char* outfile)
{
        // 0. get object file size.
        struct stat stat_buf;

        if( 0 != stat(infile, &stat_buf) )
        {
            cout << "perform_encode_action(): 0 != _stat( infile, &stat_buf )" << endl;
            return -1;
        }

        int in_len = stat_buf.st_size;

        // 1. read to buffer "in"
        char * in = new char[in_len];
        if(NULL == in)
        {
            cout << "perform_encode_action(): NULL== in" << endl;
            return -1;
        }
        memset(in, 0, in_len);

        read_from_binary_file(infile, in, in_len);

        // 2. encode to "tmp"
        char *tmp;
        int tmp_len = base64_encode( (void *)in, in_len, &tmp );
        if(0 == tmp_len)
        {
            cout << "perform_encode_action(): 0 == tmp_len" << endl;
            return -1;
        }

        // 3. write to "outfile"
        write_to_txt_file(outfile, tmp, tmp_len);

        // 4. free memory
        if(NULL != in) delete []in;
        if(NULL != tmp) delete []tmp;

        return tmp_len; // return size of text file
}

// decode. read from "infile" and write to "outfile"
int perform_decode_action(const char* infile, const char* outfile)
{
        // 0. get object file size.
        struct stat stat_buf;

        if( 0 != stat(infile, &stat_buf) )
        {
            cout << "perform_decode_action(): 0 != _stat( infile, &stat_buf )" << endl;
            return -1;
        }

        // 1. load from txtfile
        int tmp_len = stat_buf.st_size;
        char * tmp = new char[tmp_len];
        if(NULL == tmp)
        {
            cout << "perform_decode_action(): NULL== tmp" << endl;
            return -1;
        }
        memset(tmp, 0, tmp_len);
        read_from_txt_file(infile, tmp, tmp_len);


        // 2. decode to out
        int out_len = stat_buf.st_size;
        char * out = new char[out_len];
        if(NULL == out)
        {
            cout << "perform_decode_action(): NULL== out" << endl;
            return -1;
        }
        memset(out, 0, out_len);
        out_len = base64_decode(tmp, (void *)out);

        // 3. write to binary file
        write_to_binary_file(outfile, out, out_len );

        if(NULL != out) delete []out;
        if(NULL != tmp) delete []tmp;

        return out_len;
}

int main(int argc, char* argv[])
{
    // parse args
    int ret = parse_args(argc, argv);
    if( 0 == ret )
    {
        // perform encode action:
        cout << "Encoding: " << argv[2] << "" << "be patient please."  << endl;
        if( 0 == perform_encode_action(argv[2], argv[3]) )
            cout << "Encoding done."  << endl;
        else
            cout << "Encoding failure."  << endl;
    }
    else  if( 1 == ret )
    {
        // perform decode action:
        cout << "Decoding: " << argv[2] << "" << "be patient please."  << endl;
        if( 0 == perform_decode_action(argv[2], argv[3]) )
            cout << "Decoding done."  << endl;
        else
            cout << "Decoding failure."  << endl;
   }
    else
    {
        show_help();
    }

    return 0;
}

copy下来自己编译一下就成了。使用方法在--help里说的很清楚。
用的第三方的编解码算法，试验表明编码很快，解码比较慢（文件超过1MB时）

智能小车装配完成 alpha版新鲜出炉

hATEmATH的网上田园 — Sat, 20 Jun 2009 05:55:00 GMT

    智能小车alpha版新鲜出炉啦！
    前阵子决定开始做机器人，所谓万事开头难，从哪里入手呢？左思右想前思后想，觉得先做一个智能小车比较合适。首先完成循迹和自动行走功能，然后在此基础上再做长远计议。

    于是和上学时的老搭档（就是一起做实验、一起参加比赛、一起做单片机课程设计和毕业设计的乌贼同学）踏上了充满激情的设计之路。

1. 定功能需求，根据需求设计原理图

2. 布板
    这可是个很耗智力和体力的“重活”，鉴于板子不大，为了追求最好的效果，我们摒弃了软件自动布局和布线功能，学着瑞士金表的做法，全手工打造：）

3. 漫长的等待后，终于拿回了第一块电路板

4. 焊接
    焊接力求仔细，贴片元件焊接比较麻烦，整整花了一个下午的时间，晚上又做了检查。

5. 安装到小车上，骨架制作完成
Look!

斜视图：

俯视图：

6. 有了骨架后需要什么？对了，是灵魂
    软件是智能机器的灵魂。加紧编写软件中。。。。

7. 未完待续

博客转型

hATEmATH的网上田园 — Tue, 19 May 2009 02:36:00 GMT

博客开通了近4年，谢谢大家长期以来的关注。
从现在起，本博客将作为HateMath进行机器人制作的专题博客。
机器人技术包含电子、软件、机械、人工智能等方面的技术，经过数年的基础积累,我想是开工的时候了。
我会把自己从零开始的制作过程记录在此，和大家分享，敬请关注。

HateMath
2009.5.19

今天，第一份工作结束

hATEmATH的网上田园 — Tue, 21 Apr 2009 05:40:00 GMT

轻轻的我走了，正如我轻轻的来。
我挥一挥鼠标，拷走了所有代码。

vim常用快捷键笔记-vim速成 (4.3第二次更新)

hATEmATH的网上田园 — Wed, 01 Apr 2009 08:31:00 GMT

    （转载请注明出处：HateMath的网上田园）
    （http://blog.vckbase.com/hatemath）

                        k
上下左右移动 h       l
                        j

合并下一行 J

跳转 ctrl+J <----->   ctrl+O

撤销/恢复 u / ctrl+R

插入 i o a

保存退出 ZZ（推荐）

词进退 b <-----> w
空白      B <-----> W

           文首                           gg
行首             行尾          ^              $
          文尾                           G

跳转到66行 66G

显示匹配括号 %

翻页 ctrl+U ctrl+D

当前行置中 zz (zhi zhong)
            置顶 zt (top)

精确搜索 \<word\>
                 ^word$

set hlsearch
set incsearch
set ignorecase
set noignorecase

返回上次行 ``
返回标记行 `[a- z]
做行标记 m[a - z]

做文件标记 m[0 - 9]
返回文件 `[0 - 9]

替换 r      字母
          cw   词
          C     |-->
          cc    <-->

删除   x      字母
          dw   词
          D     |-->
          dd    <-->

删整词 daw

复制 yy    单行
          yw   词

重复上次 .

visual模式 v
整行多选 V
列编辑 ctrl+V
切换选择对角 o

水平分割窗口 :split
垂直                  :vsplit
切换 ctrl+w+arrow
关闭 :close
调高 3ctrl++/-
新建 :new
           vnew

比较不同文件(好用，推荐) vimdiff 1.c 2.c

更改文件格式 :set fileformat=unix
                          :write

宏开始 q[a-z]
    停止 q
    执行 :@[a-z]

统计字行 g^G

linux下为数据采集器开发USB驱动(内核版本 2.6.24)

hATEmATH的网上田园 — Wed, 25 Mar 2009 00:44:00 GMT

    （转载请注明出处：HateMath的网上田园）
    （http://blog.vckbase.com/hatemath）

    有一个数据采集器，和上位机通讯采用的是USB方式，使用的芯片是南京一家公司的ch372B USB芯片。在测试的时候发现，此公司提供的USB驱动存在严重BUG---采集数据的时候一旦拔掉数据线，上位机彻底卡死，只能按reset重启。

    向那个公司的技术部门反应问题1个多月，仍未解决，所谓求人不如求己，于是决定自己弄。以前有些linux驱动开发的经验，又恶补了一下usb驱动的知识，然后开工。

    1. 准备框架代码。在这个搭积木的时代，不要发明相同的轮子。linux内核源码树底下有个 drivers/usb/usb-skeleton.c ，从字面意思我们知道这是usb设备驱动框架，copy出来放在一个文件夹里。

    2. 对usb-skeleton.c源码进行修改：
    1）id

/* Define these values to match your devices */
#define USB_SKEL_VENDOR_ID 0x4348
#define USB_SKEL_PRODUCT_ID 0x5537

上述id值如何得到呢？插入USB设备后，使用命令：#cat /proc/bus/usb/devices 可以看到如下信息：
        T: Bus=01 Lev=02 Prnt=02 Port=00 Cnt=01 Dev#= 14 Spd=12 MxCh= 0
        D: Ver= 1.10 Cls=ff(vend.) Sub=80 Prot=37 MxPS= 8 #Cfgs= 1
        P: Vendor=4348 ProdID=5537 Rev= 2.20
        C:* #Ifs= 1 Cfg#= 1 Atr=80 MxPwr= 44mA
        I:* If#= 0 Alt= 0 #EPs= 4 Cls=ff(vend.) Sub=80 Prot=37 Driver=ch37zzh
        E: Ad=82(I) Atr=02(Bulk) MxPS= 64 Ivl=0ms
        E: Ad=02(O) Atr=02(Bulk) MxPS= 64 Ivl=0ms
        E: Ad=81(I) Atr=03(Int.) MxPS=   8 Ivl=1ms
        E: Ad=01(O) Atr=02(Bulk) MxPS=   8 Ivl=0ms

        OK，知道id值从哪来的了吧（注意，是16进制）。

    2）设备节点名称

static struct usb_driver skel_driver = {
    .name =        "ch37zzh",
    .probe =    skel_probe,
    .disconnect =    skel_disconnect,
    .suspend =    skel_suspend,
    .resume =    skel_resume,
    .pre_reset =    skel_pre_reset,
    .post_reset =    skel_post_reset,
    .id_table =    skel_table,
    .supports_autosuspend = 1,
};

    把name字段改一下，作为/dev下面出现的设备节点名称.

    3. 编写Makefile

    2.6内核中写驱动的Makefile比2.4的简单很多：

obj-m += ch37zzh.o

clean:
rm -rf *.o *.ko

为了以后编译别的驱动的方便，我写了个通用的编译脚本make_drv.sh，放在和Makefile同一个目录下。

CC=arm-linux-gcc
KDIR=/root/junzh/linux-2.6.24.3
DSTDIR=/nfs
OBJ=ch37zzh.ko

make -C ${KDIR} SUBDIRS=`pwd` modules
cp -f ${OBJ} ${DSTDIR}

    4. 编译加载
        在控制台输入 sh make_drv.sh 即可。
        然后是插入模块：

        # insmod ch37zzh.ko
        # lsmod |grep ch37zzh
        ch37zzh                 7872  0

5. 测试程序
驱动一旦完成，测试程序就可以向打开普通文件一样打开设备文件。经过验证，读写数据是符合预期的，而且最关键的是，中途拔掉数据线也不会死机（read返回-1而已）。

        /mnt/host $ sh run-seltest.sh
        Begin to write data.
        End write data: write bytes:3
        Begin to read data.
        End read data: read bytes:64
        24 2A
        (05 00 00 00 00 FA 08 C5 07 )     // channel 0
        (00 00 00 00 00 E2 08 79 08 )
        (00 00 00 00 00 5C 09 FE 08 )
        (00 00 00 00 00 79 09 FA 08 )    // channel 3
        7E 90 00 00 89
        Begin to read data.
        End read data: read bytes:64
        24 2A
        (05 00 00 00 00 FE 08 C6 07 )
        (00 00 00 00 00 5F 09 D3 08 )
        (00 00 00 00 00 8A 09 0F 09 )
        (00 00 00 00 00 55 09 DA 08 )
        01 00 00 00 55
        Begin to read data.
           End read data: read bytes:-1
           00
           Begin to read data.
           End read data: read bytes:-1
           00

    6. 参考资料
        Linux下的硬件驱动——USB设备     ，赵明
        http://www.ibm.com/developerworks/cn/linux/l-usb/index1.html
        http://www.ibm.com/developerworks/cn/linux/l-usb/index2.html

添了一台新装备：VC890D数字万用表，纪念我的学生时代

hATEmATH的网上田园 — Mon, 23 Mar 2009 01:00:00 GMT

第一台万用表是初中时候买的，10块钱的那种，后来玩单片机的时候很想拥有一块数字表，最终还是凑合着过来了。前天想起很久没去华龙了，于是去转了转。走在里面熙熙攘攘，想起上学时为了做一个超声波测距的东东坐火车来南京买芯片，不禁感慨那时的自己多么有活力和激情。如今，电子工程师的梦已经远去，这块万用表就当是对学生时代的纪念吧。

VC890D（相册->电子查看大图）：

初中时买的表，新老交班了

瞧这帮搞电子的

hATEmATH的网上田园 — Fri, 20 Feb 2009 06:27:00 GMT

论坛灌水区：

拿个电阻当牙签使。。。。。。。。。。。 - [fdo] 2009-2-20 13:07:17
集成电路可以梳头 - [CreateInstance] 2009-2-20 13:17:32
梳头可以用接插件，双排插针！ - [fdo] 2009-2-20

Linux内核驱动模块编程指南2.4 中文文档(htm)及自己的实验代码

hATEmATH的网上田园 — Fri, 16 Jan 2009 15:55:00 GMT

    这本编程指南是针对2.2-2.4内核的，我用的是2.4.18的内核，在实际学习中发现作者的代码很多需要改动（甚至比较大的改动）才能在我的电脑上跑起来，所以这里把自己的实验代码发布一下，希望有人用得着。

    内含Linux内核驱动模块编程指南2.4 中文文档一份(htm文件)，实验代码若干，编译和调试脚本若干。

    下载:
http://blog.vckbase.com/Files/HateMath/The.Linux.Kernel.Module.Programming.Guide.2.4.learnning.code.rar

    清单：

TOPDIR
│ c
│ i
│ Linux内核驱动模块编程指南2.4.htm.chn.rar
│ note.txt
│ o
│ s
│
├─block
│      chardev.h
│      main.c
│      main.o
│      Makefile
│      test
│      test.cpp
│
├─chardev
│      main.c
│      main.o
│      Makefile
│
├─helloworld
│      main.c
│      main.o
│      Makefile
│
├─hook
│      main.c
│      main.o
│      Makefile
│
├─int
│      main.c
│      main.o
│      Makefile
│
├─ioctl
│      chardev.h
│      main.c
│      main.o
│      Makefile
│      test.bin
│      test.cpp
│
├─multi-c
│      hello2_start.c
│      hello2_start.o
│      hello2_stop.c
│      hello2_stop.o
│      main.o
│      Makefile
│      multi-c.o
│
├─printf
│      main.c
│      main2.o
│      Makefile
│
└─proc
        main.c
        main.o
        Makefile

(对了，hook那个测试没搞定 -_-!)

读书感言：《家家有个机器人》- BillGates

hATEmATH的网上田园 — Sat, 27 Dec 2008 07:59:00 GMT

（节选）我们站在时代的节点：一个崭新的产业即将崛起。若干开创性的新技术为这个产业的崛起奠定了基础；几家口碑颇佳的企业提供了极为专业的商品；一大批新公司迅速壮大，致力于制造新式玩具、为发烧友提供配件，还出售其他各种有趣的利基产品。然而，它也是一个高度分散、各自为政的行业，几乎没有统一的标准或平台。这个行业的开发项目复杂、进展缓慢，可投入实际应用的成果寥若晨星。实际上，尽管它的发展令人振奋，前途一片光明，但谁也说不准这个行业何时才能成长到临界质量，甚至连它是否会达到临界点都无人知晓。不过，只要能发展到临界点，它就可能会彻底改变这个世界。

毋庸置疑，人们可以用上面这段话来描述20 世纪70 年代中期的计算机行业，那时我和保罗·艾伦（PaulAllen）才刚刚创建微软公司。那个年代的大型计算机体型臃肿、造价高昂，通常是在大型公司、政府部门和其他各种机构中用于后台操作，支持日常运转。顶级大学和工业实验室研究人员正忙于打造基础组件，为信息时代的到来开辟道路。英特尔公司刚刚推出8080 微处理器，而现代家庭电子游戏的鼻祖阿塔里公司（Atari）还在兜售风靡一时的乒乓球电子游戏Pong。发烧友自发组织了俱乐部，千方百计地想找出这项新技术究竟能做点什么。

不过，此刻我心里所想的并不是那些往事，而是现在机器人行业的发展——目前这个领域的状况与30 年前的电脑行业极为相似。今天在汽车装配线上忙碌的一线机器人，正是当年大型计算机的翻版。而机器人行业的利基产品也同样种类繁多，比如协助医生进行外科手术的机械臂、在伊拉克和阿富汗战场上负责排除路边炸弹的侦察机器人、以及负责清扫地板的家用机器人。还有不少电子公司参照人、狗、恐龙的样子制造机器人玩具，而发烧友们都迫切希望能弄到一套最新版的乐高（LEGO）机器人套件。

机器人行业现今面临的挑战，也和30 年前电脑行业遇到的问题如出一辙：机器人制造公司没有统一的操作系统软件，流行的应用程序很难在五花八门的装置上运行。机机器人与个人电脑双剑合璧器人的处理器和其他硬件的标准化工作也未开始，在一台机器人上使用的编程代码，几乎不可能在另一台机器上发挥作用。如果有人想开发新的机器人，通常得从零开始。回想PC发展的初期，当时我们意识到，要将PC的整个开拓性研究推入临界状态，把所有研究成果整合起来，打造出一个能够批量生产实用产品的行业，还需要一项要素。事实证明，我们需要的正是微软的BASIC语言。我们在20世纪70年代开发的这套程序设计语言为计算机行业奠定了统一的基础，有了BASIC语言，针对某套具体硬件开发的程序也可以在另一组硬件上运行了，电脑程序设计的工作轻松多了，吸引了越来越多的人投身计算机行业。为PC发展做出过实质性贡献的人数不胜数，但对软硬件的革新而言，微软的BASIC语言是关键的催化剂之一，而软硬件的革新最终使PC革命成为可能。看来机器人行业也必须找出行业中那个尚未现身的关键要素，才能实现PC行业30年前所经历的脱胎换骨。

（节选自环球科学 2007年第二期, 电驴有下）

gates关于BASIC那段固然有自吹的嫌疑，但是他的结论我是赞同的，机器人行业需要找到那个关键要素，可以让行业达到爆发的临界点。机器人的价格必须降下来，这意味着需要量产；机器人各个配件的接口必须有统一的行业标准，真希望哪天，我们给自己家的机器人换个胳膊就像给现在的电脑换硬盘、显卡一样方便。

冷

hATEmATH的网上田园 — Mon, 22 Dec 2008 00:42:00 GMT

今天寒流来袭，早晨上班走在路上，小风吹的嗖嗖的，脸上和耳朵、鼻子都冰凉，空气冷的仿佛吸进去就能把肺冻上似的。想起昨天下午，在外面跑了一圈也没看到件喜欢的外套，空手而归，心里那个后悔。现在天上掉下个麻袋来我也立马披上暖暖先。

幸好，按照经验，这种酷寒的天气不会太久，但还有一种冷，是注定要持续很久的了。经济危机已现端倪，明年的经济状况会很糟糕，而就在上周，公司说将会陆续降薪和减员，很受打击。自从实习就在这里，毕业后在这工作也快一年了，担负着新项目中嵌入式软件的主要工作，辛辛苦苦干了一年，不仅加薪无望还要降薪，而且年终奖和项目奖金基本都要泡汤。。。。。也许，我该考虑别的出路了。

雷柏(RAPOO)8100无线键鼠套装使用感受

hATEmATH的网上田园 — Tue, 28 Oct 2008 05:41:00 GMT

国庆的时候去珠江路逛，心想大老远跑来岂能空手而归，于是到华海买了个向往已久的无线键鼠套装。

型号是雷柏8100，理由是便宜。这个型号当时正在做活动，￥168. 往柜台里扫一眼，动辄都是三五百的。

使用感受:
    优点：1. 无线的就是爽！无拘无束，想怎么摆就怎么摆。
                2. 键盘噪声不大，不吵人。
                3. 有12个快捷按钮，分别代表休眠、收藏夹、计算器等。最实用的要属音量调节和静音按钮了，很方便（不过我还是习惯用自己写的HotKey2.0调节音量）。还可以下载驱动自己定义其中几个按钮的功能。
                4. 使用方便，插上就能用，驱动安装不是必须的。
                5. 鼠标上有个电源开关，利于长时间不用时省电。

    缺点:
                1. 没有CAPSLOCK和NUMLOCK指示灯，不太方便。
                2. 个别按键不灵，比如回车键，如果用小拇指按左侧，经常没反应。写代码经常用下划线，shift+-的组合有时会不灵。
                3. 休眠键位置不合理，经常是想按escape结果按了休眠。当然，如果你不像我这样偏爱键盘操作，倒也没大影响。

    忘了个最大的优点：便宜。

(转载)C/C++数组名与指针区别深层探索

hATEmATH的网上田园 — Fri, 26 Sep 2008 02:00:00 GMT

早看到这篇文章就好了，免得自己摸索了很久。不过，文章如果能进一步说明数组地址++和指向数组的指针++对地址的影响，就更能说明问题。

C/C++数组名与指针区别深层探索
作者：宋宝华 e-mail:21cnbao@21cn.com

1. 引言
指针是C/C++语言的特色，而数组名与指针有太多的相似，甚至很多时候，数组名可以作为指针使用。于是乎，很多
程序设计者就被搞糊涂了。而许多的大学老师，他们在C 语言的教学过程中也错误得给学生讲解：“数组名就是指针”。
很幸运，我的大学老师就是其中之一。时至今日，我日复一日地进行着C/C++项目的开发，而身边还一直充满这样的
程序员，他们保留着“数组名就是指针”的误解。

2. 魔幻数组名
请看程序（本文程序在WIN32 平台下编译）：
1. #include <iostream.h>
2. int main(int argc, char* argv[])
3. {
4. char str[10];
5. char *pStr = str;
6. cout << sizeof(str) << endl;
7. cout << sizeof(pStr) << endl;
8. return 0;
9. }
2.1 数组名不是指针
我们先来推翻“数组名就是2.1 数组名不是指针
我们先来推翻“数组名就是指针”的说法，用反证法。
证明数组名不是指针
假设：数组名是指针；
则：pStr 和str 都是指针；
因为：在WIN32 平台下，指针长度为4；
所以：第6 行和第7 行的输出都应该为4；
实际情况是：第6 行输出10，第7 行输出4；
所以：假设不成立，数组名不是指针
2.2 数组名神似指针
上面我们已经证明了数组名的确不是指针，但是我们再看看程序的第5 行。该行程序将数组名直接赋值给指针，这显得数组名又的确是个指针！
我们还可以发现数组名显得像指针的例子：
1. #include <string.h>
2. #include <iostream.h>
3. int main(int argc, char* argv[])
4. {
5. char str1[10] = "I Love U";
6. char str2[10];
7. strcpy(str2,str1);
8. cout << "string array 1: " << str1 << endl;
9. cout << "string array 2: " << str2 << endl;
10. return 0;
11. }
标准C 库函数strcpy 的函数原形中能接纳的两个参数都为char 型指针，而我们在调用中传给它的却是两个数组名！
函数输出：
string array 1: I Love U
string array 2: I Love U
数组名再一次显得像指针！
既然数组名不是指针，而为什么到处都把数组名当指针用？于是乎，许多程序员得出这样的结论：数组名（主）是（谓）
不是指针的指针（宾）。
整个一魔鬼。

3. 数组名大揭密
那么，是揭露数组名本质的时候了，先给出三个结论：
(1)数组名的内涵在于其指代实体是一种数据结构，这种数据结构就是数组；
(2)数组名的外延在于其可以转换为指向其指代实体的指针，而且是一个指针常量；
(3)指向数组的指针则是另外一种变量类型（在WIN32 平台下，长度为4），仅仅意味着数组的存放地址！
3.1 数组名指代一种数据结构：数组
现在可以解释为什么第1 个程序第6 行的输出为10 的问题，根据结论1，数组名str 的内涵为一种数据结构，即一
个长度为10 的char 型数组，所以sizeof(str)的结果为这个数据结构占据的内存大小：10 字节。
再看：
1. int intArray[10];
2. cout << sizeof(intArray) ;
第2 行的输出结果为40（整型数组占据的内存空间大小）。
如果C/C++程序可以这样写：
1. int[10] intArray;
2. cout << sizeof(intArray) ;
我们就都明白了，intArray 定义为int[10]这种数据结构的一个实例，可惜啊，C/C++目前并不支持这种定义方式。
3.2 数组名可作为指针常量
根据结论2，数组名可以转换为指向其指代实体的指针，所以程序1 中的第5 行数组名直接赋值给指针，程序2 第7
行直接将数组名作为指针形参都可成立。
下面的程序成立吗？
1. int intArray[10];
2. intArray++;
读者可以编译之，发现编译出错。原因在于，虽然数组名可以转换为指向其指代实体的指针，但是它只能被看作一个指针常量，不能被修改。
而指针，不管是指向结构体、数组还是基本数据类型的指针，都不包含原始数据结构的内涵，在WIN32 平台下，sizeof
操作的结果都是4。
顺便纠正一下许多程序员的另一个误解。许多程序员以为sizeof 是一个函数，而实际上，它是一个操作符，不过其
使用方式看起来的确太像一个函数了。语句sizeof(int)就可以说明sizeof 的确不是一个函数，因为函数接纳形参
（一个变量），世界上没有一个C/C++函数接纳一个数据类型（如int）为“形参”。
3.3 数据名可能失去其数据结构内涵
到这里似乎数组名魔幻问题已经宣告圆满解决，但是平静的湖面上却再次掀起波浪。请看下面一段程序：
1. #include <iostream.h>
2. void arrayTest(char str[])
3. {
4. cout << sizeof(str) << endl;
5. }
6. int main(int argc, char* argv[])
7. {
8. char str1[10] = "I Love U";
9. arrayTest(str1);
10. return 0;
11. }
程序的输出结果为4。不可能吧？
4，一个可怕的数字，前面已经提到其为指针的长度!
结论1 指出，数据名内涵为数组这种数据结构，在arrayTest 函数体内，str 是数组名，那为什么sizeof 的结果却
是指针的长度？这是因为：
(1)数组名作为函数形参时，在函数体内，其失去了本身的内涵，仅仅只是一个指针；
(2)很遗憾，在失去其内涵的同时，它还失去了其常量特性，可以作自增、自减等操作，可以被修改。
所以，数据名作为函数形参时，其全面沦落为一个普通指针！它的贵族身份被剥夺，成了一个地地道道的只拥有4
个字节的平民。
以上就是结论4。

另外附一篇：
用变量a给出下面的定义
　　a) 一个整型数（An integer）
　　b)一个指向整型数的指针（ A pointer to an integer）
　　c)一个指向指针的的指针，它指向的指针是指向一个整型数（ A pointer to a pointer to an intege）r
　　d)一个有10个整型数的数组（ An array of 10 integers）
　　e) 一个有10个指针的数组，该指针是指向一个整型数的。（An array of 10 pointers to
　　integers）
　　f) 一个指向有10个整型数数组的指针（ A pointer to an array of 10 integers）
　　g) 一个指向函数的指针，该函数有一个整型参数并返回一个整型数（A pointer to a function
　　that takes an integer as an argument and returns an integer）
　　h) 一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数（ An array of ten pointers to functions that take an integer argument and return an integer ）
　　答案是：
　　a) int a; // An integer
　　b) int *a; // A pointer to an integer
　　c) int **a; // A pointer to a pointer to an integer
　　d) int a[10]; // An array of 10 integers
　　e) int *a[10]; // An array of 10 pointers to integers
　　f) int (*a)[10]; // A pointer to an array of 10 integers
　　g) int (*a)(int); // A pointer to a function a that
　　takes an integer argument and returns an integer
　　h) int (*a[10])(int); // An array of 10 pointers to
　　functions that take an integer argument and return an integer

图文并茂教你机箱美化 - 第一季

hATEmATH的网上田园 — Mon, 08 Sep 2008 04:59:00 GMT

    为什么叫第一季呢，因为这次美化只是我整个CASE-MOD计划的序幕。

   【转载请注明原创出处：HateMath的网上田园(http://blog.vckbase.com/HateMath/)】

     1. 我用的是鑫谷的小机箱  ，一直对单调的外观不甚满意，最近喜欢上了红黑搭配的主题，于是想把机箱也改造一下。

2. 将准备好的LOGO（猜猜这是什么LOGO？是EA经典游戏大作《命令与征服 3 》中GDI的徽章）打印在纸上，并用美工刀将图案镂空。这可是细致的活，得有耐心，尤其是圆弧处。注意，刀锋与纸张最好保持45度左右的角度，否则会拉纸。

3. 将镂空后的纸用胶水粘在机箱面板上，注意图案边缘一定要粘牢，否则等着哭吧（自喷漆的压力很大，可能会通过缝隙落到不该着色的地方）。接着用报纸将机箱周围全部遮住，防止漆雾散落到别处或者地板上，最好四周用东西挡一下，这里用的是薯片筒 -_-!

4. 上家伙。我用的是这种自喷漆，很便宜的--业余MOD嘛，不用那么好的漆了。

5.喷漆！场所一般选择室外通风处，没有人觉得油漆的味道好闻吧？如果你没有喷漆经验，最好先找的别的练练，别一上来就往机箱上碰。因为喷漆讲究技术性，漆多了少了效果都不好。这个没别的方法，只有多练习。

6. 之后便是耐心的等待。油漆干大约要1-2小时，完全无味道至少要半天。把面板放在通风荫凉的地方，该干啥干啥去吧。油漆干了之后，将贴在面板上的纸张除掉，可以用水浸泡。

7. 下面我们要把图案喷成红色。有人不解：为什么绕这个弯子呢？因为黑色面板上直接喷红色漆不明显，效果不好，所以刚才我们上白色漆只是个铺垫罢了。这次喷漆才是真正的目的，嘿嘿。面板完成后，把机箱前面板拆下来，也喷成红色。

8. 经典的红黑搭配，沉稳中蕴藏着活力。对比第一幅图，漂亮很多吧，呵呵。

完成，收工~

BASE64编解码JPG图片的例子(C++ VS2005)

hATEmATH的网上田园 — Mon, 01 Sep 2008 01:48:00 GMT

BASE64这种编码挺有意思的，可以把每3个（二进制）字节编码成以ASCII码表示的4个字节。可能会有人觉得奇怪，网页保存为mht格式后，明明只有一个文本文件，可是用浏览器打开后居然还有图片。其实，用记事本打开这些mht文件，可以看到一堆堆的”乱码“，这往往就是BASE64编码后的图片了。由于最近项目用到这个东西，于是去CSDN上下了个BASE64编解码的C++类。因为对效率没有特别的要求，所以只是用小图片试了一下，能用。

该类使用起来很简单：

int main(int argc, char* argv[])
{
    string strJpg;
    Base64 bs;

    read_from_binary_file(strJpg); // 读取文件

    string strEncode = bs.base64_encode(strJpg); // 编码
    string strDecode = bs.base64_decode(strEncode); //解码

    write_to_binary_file(strDecode); // 写入文件

    printf("%s %s ", strEncode.c_str(), strDecode.c_str()); // 在控制台打印
    return 0;
}

例子（源码+demo）下载：
http://blog.vckbase.com/Files/HateMath/base64_codec_jpg_test.rar

后补：上面那个理论上只适合文本文件，对于二进制文件，有时是不行的。这个例子更具有通用性：
http://blog.vckbase.com/Files/HateMath/test_base64_bmp.rar

飞了一趟广州

hATEmATH的网上田园 — Tue, 12 Aug 2008 06:11:00 GMT

《高质量C++编程指南》摘录

hATEmATH的网上田园 — Tue, 29 Jul 2008 09:32:00 GMT

是摘录，所以只是自己感兴趣的部分，一般是自己不熟悉的地方和觉得讲述的很好的地方。

第六章函数设计

> 如果函数没有参数，则用void 填充.明确的告诉别人，此函数没有参数。

> 有时候函数原本不需要返回值，但为了增加灵活性如支持链式表达，可以附加返回值。
例如字符串拷贝函数strcpy 的原型：
char *strcpy(char *strDest，const char *strSrc);

> 断言用来捕捉程序员认为不应该发生的情况
在编写函数时，先自问：“我打算做哪些假定？”一旦确定了的假定，就要使用断言对假定进行检查。

> int m;
int & n = m;
n 相当于m 的别名（绰号），对n 的任何操作就是对m 的操作。例如有人名叫王小毛，
他的绰号是“三毛”。说“三毛”怎么怎么的，其实就是对王小毛说三道四。

引用和指针的区别：
（1）引用被创建的同时必须被初始化（指针则可以在任何时候被初始化）。
（2）不能有NULL 引用，引用必须与合法的存储单元关联（指针则可以是NULL）。
（3）一旦引用被初始化，就不能改变引用的关系（指针则可以随时改变所指的对象）。

> 实际上“引用”可以做的任何事情“指针”也都能够做，为什么还要“引用”这东西？
答案是“用适当的工具做恰如其分的工作”。
指针能够毫无约束地操作内存中的如何东西，尽管指针功能强大，但是非常危险。如果只需要借用一下某个对象的“别名”，那么就用“引用”，而不要用“指针”，以免发生意外。比如说，某人需要一份证明，本来在文件上盖上公章的印子就行了，如果把取公章的钥匙交给他，那么他就获得了不该有的权利，从而产生潜在的危险。

第7 章内存管理

> C++/C 语言没有办法知道指针所指的内存容量，除非在申请内存时记住它。

> 当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针

> 如果函数的参数是一个指针，不要指望用该指针去申请动态内存。因为编译器总是要为函数的每个参数制作临时副本，指针亦同。

第9 章类的构造函数、析构函数与赋值函数

> 构造函数有个特殊的初始化方式叫“初始化表达式表”（简称初始化表）。初始化表
位于函数参数表之后，却在函数体 {} 之前。这说明该表里的初始化工作发生在函数体
内的任何代码被执行之前。

> 如果类存在继承关系，派生类必须在其初始化表里调用基类的构造函数。

> 类的const 常量只能在初始化表里被初始化，因为它不能在函数体内用赋值的方式
来初始化

> 构造从类层次的最根处开始，在每一层中，首先调用基类的构造函数，然后调用成
员对象的构造函数。析构则严格按照与构造相反的次序执行，该次序是唯一的，否则编
译器将无法自动执行析构过程。

> 一个有趣的现象是，成员对象初始化的次序完全不受它们在初始化表中次序的影响，
只由成员对象在类中声明的次序决定。这是因为类的声明是唯一的，而类的构造函数可
以有多个，因此会有多个不同次序的初始化表。如果成员对象按照初始化表的次序进行
构造，这将导致析构函数无法得到唯一的逆序。

> 注意不要将检查自赋值的if 语句
if(this == &other)
错写成为
if( *this == other)

> 如果我们实在不想编写拷贝构造函数和赋值函数，又不允许别人使用编译器生成的
缺省函数，怎么办？偷懒的办法是：只需将拷贝构造函数和赋值函数声明为私有函数，不用编写代码。

<边看边补充>

不小心掉进深度拷贝的陷阱

hATEmATH的网上田园 — Mon, 21 Jul 2008 01:44:00 GMT

感言：看书时啥都知道，一旦用起来头脑就不一定那么清楚了。这个陷阱我爬了两天才出来，算是个教训。

现象：某个绘图函数里，如果用selectfont选择自己创建的字体，就会被killed。有时用到了两个内存dc，只要涉及对memdc的操作，哪怕是改一个前景色也killed。奇怪的是打印所有变量和指针都有效。

原因：对象的深度拷贝问题。
由于我没写拷贝构造函数，临时对象创建后按位拷贝加入vector，临时对象被析构时将已经分配的GDI资源（字体，memdc）销毁，但vector中对象关于资源的指针不是NULL。于是执行和字体、memdc有关的操作时程序killed。

结论：当一个对象内部分配了资源（new的内存，GDI资源等等），就需要定义自己的拷贝构造函数。或者说，只要对象析构时释放了资源，就必须自定义拷贝构造函数。否则代码多了以后，debug的代价会非常高昂。