-
Ver 0.1.2 — 2008.12.10更新
1. 输入金额，实时转换。
2. 支持空格，逗号，单引号分隔符分割的金额转换。
下载地址： 可执行程序：Amt2CNY.zip（Ver 0.1.2） 源代码：Src.zip （Ver 0.1.2）
///////////////////////////////////////////////////////////////////////////////////////////////////
Ver 0.1.0 — 2008.12.08更新
1. 转换结果符合财务规范。
2. 小数位数暂时仅支持两位。
3. 支持金额区间：[-9999999999999.99 ~~ 9999999999999.99]。
4. 绿色软件，无需安装，不含任何插件。转换函数使用上篇日志《人民币金额小写转大写代码两枚》中的python版本，GUI: wxpython. 打包：py2exe.
-
############################################################
filename=`ps -ef|grep vi|grep -v view|awk -F ' ' '{print $9}'|grep $1`
if [ $filename = $1 ]
then
echo "文件$1正在被其他人编辑！"
echo "您可以以只读方式打开查看！"
echo -n "您确定要查看它吗？[Y/N]: "
read input
case "$input" in
[y,Y])
echo "您将以只读方式打开查看文件:"
echo $1
view $1
;;
*)
exit 1
;;
esac
else
vi $1
fi
############################################################ -
计算最大公因数（Gcd，Greatest Common Divisor）的欧几里得（Euclid）算法：
两个整数的最大公因数是同时整除二者的最大整数。
以下算法计算Gcd（m, n）, 假设m>=n。（如果n>m, 则循环的第一次迭代将它们互相交换）。
unsigned int Gcd(unsigned int m, unsigned int n)
{
unsigned int rem;while(n>0)
{
rem = m % n;
m = n;
n = rem;
}
return m;
} -
I/O重定向详解及应用实例
1、 基本概念（这是理解后面的知识的前提，请务必理解）
a、 I/O重定向通常与 FD有关，shell的FD通常为10个，即 0～9；
b、 常用FD有3个，为0（stdin，标准输入）、1（stdout，标准输出）、2（stderr，标准错误输出），默认与keyboard、monitor、monitor有关；
c、 用 < 来改变读进的数据信道(stdin)，使之从指定的档案读进；
d、 用 > 来改变送出的数据信道(stdout, stderr)，使之输出到指定的档案；
e、 0 是 < 的默认值，因此 < 与 0<是一样的；同理，> 与 1> 是一样的；
f、 在IO重定向 中，stdout 与 stderr 的管道会先准备好，才会从 stdin 读进资料；
g、 管道“|”(pipe line):上一个命令的 stdout 接到下一个命令的 stdin;
h、 tee 命令是在不影响原本 I/O 的情况下，将 stdout 复制一份到档案去;
i、 bash（ksh）执行命令的过程：分析命令－变量求值－命令替代（``和$( )）－重定向－通配符展开－确定路径－执行命令；
j、 ( ) 将 command group 置于 sub-shell 去执行，也称 nested sub-shell，它有一点非常重要的特性是：继承父shell的Standard input, output, and error plus any other open file descriptors。
k、 exec 命令：常用来替代当前 shell 并重新启动一个 shell，换句话说，并没有启动子 shell。使用这一命令时任何现有环境都将会被清除。exec 在对文件描述符进行操作的时候，也只有在这时，exec 不会覆盖你当前的 shell 环境。
2、 基本IO
cmd > file 把 stdout 重定向到 file 文件中；
cmd >> file 把 stdout 重定向到 file 文件中(追加)；
cmd 1> fiel 把 stdout 重定向到 file 文件中；
cmd > file 2>&1 把 stdout 和 stderr 一起重定向到 file 文件中；
cmd 2> file 把 stderr 重定向到 file 文件中；
cmd 2>> file 把 stderr 重定向到 file 文件中(追加)；
cmd >> file 2>&1 把 stderr 和 stderr 一起重定向到 file 文件中(追加)；
cmd < file >file2 cmd 命令以 file 文件作为 stdin，以 file2 文件作为 stdout；
cat <>file 以读写的方式打开 file；
cmd < file cmd 命令以 file 文件作为 stdin；
cmd << delimiter Here document，从 stdin 中读入，直至遇到 delimiter 分界符。
3、 进阶IO
>&n 使用系统调用 dup (2) 复制文件描述符 n 并把结果用作标准输出；
<&n 标准输入复制自文件描述符 n；
<&- 关闭标准输入（键盘）；
>&- 关闭标准输出；
n<&- 表示将 n 号输入关闭；
n>&- 表示将 n 号输出关闭；
上述所有形式都可以前导一个数字，此时建立的文件描述符由这个数字指定而不是缺省的 0 或 1。如：
... 2>file 运行一个命令并把错误输出(文件描述符 2)定向到 file。
... 2>&1 运行一个命令并把它的标准输出和输出合并。(严格的说是通过复制文件描述符 1 来建立文件描述符 2 ，但效果通常是合并了两个流。)
我 们对 2>&1详细说明一下 ：2>&1 也就是 FD2＝FD1 ，这里并不是说FD2 的值 等于FD1的值，因为 > 是改变送出的数据信道，也就是说把 FD2 的 “数据输出通道” 改为 FD1 的 “数据输出通道”。如果仅仅这样，这个改变好像没有什么作用，因为 FD2 的默认输出和 FD1的默认输出本来都是 monitor，一样的！ 但是，当 FD1 是其他文件，甚至是其他 FD 时，这个就具有特殊的用途了。请大家务必理解这一点。
exec 0exec 1>outfilename # 打开文件outfilename作为stdout。
exec 2>errfilename # 打开文件 errfilename作为 stderr。
exec 0<&- # 关闭 FD0。
exec 1>&- # 关闭 FD1。
exec 5>&- # 关闭 FD5。
问： 如果关闭了 FD0、FD1、FD2，其后果是什么？ 恢复 FD0、FD1、FD2与 关闭FD0、FD1、FD2 有什么区别？代码分别是什么？ 打开了FD3～FD9，我们用完之后，你觉得是将他们关闭还是恢复？
下面是提示（例子来源于CU一帖子，忘记出处，来日再补上）：
exec 6>&2 2>ver
command >>dev/null &
exec 2>&6 # 恢复 FD24、 简单举例
a、stdout和stderr都通过管道送给egrep了：
(ls you no 2>&1;ls yes 2>&1) 2>&1|egrep \* >file
(ls you no 2>&1;ls yes 2>&1)|egrep \* >file
(ls you no;ls yes) 2>&1|egrep \* >file这个例子要注意的就是：
理 解 命令执行顺序 和 管道“|”：在命令执行前，先要进行重定向的处理，并将把 nested sub-shell 的stdout 接到 egrep 命令的 stdin。 nested sub-shell ，在 ( ) 中的两个命令加上（），可以看作一个命令。其 FD1 已经连接到“|”往egrep送了，当遇到 2>&1时，也就是FD2＝FD1，即FD2同FD1一样，往管道 “|”那边送。
b、 没有任何东西通过管道送给egrep，全部送往monitor。 (ls you no 2>&1;ls yes 2>&1) >&2|egrep \* >file。虽然在（）里面将 FD2转往FD1，但在（）外，遇到 >&2 ，结果所有的都送到monitor。 请理解：
(ls you no 2>&1) 1>&2|egrep \* >file ## 送到 monitor
ls you no 2>&1 1>&2|egrep \* >file ## 送给 管道 “|”
ls you no 1>&2 2>&1|egrep \* >file ## 送到 monitor5、 中阶例子
条件： stderr通过管道送给egrep，正确消息仍然送给monitor（不变）
exec 4>&1;(ls you no 2>&1 1>&4 4>&-;ls yes 2>&1 1>
&4 4>&-)|egrep \* >file;exec 4>&-
或者
exec 4>&1;(ls you no;ls yes) 2>&1 1>
&4 4>&-|egrep \* >file;exec 4>&-如果加两个条件：
（1）要求cmd1和cmd2并行运行；
（2）将cmd1的返回值赋给变量 ss。
则为：
exec 3>&1;exec 4>&1
ss=$(((ls you no 2>&1 1>&3 3>&-;echo $? >&4)|egrep \* >file) 4>&1)
exec 3>&-;exec 4>&-说明：
exec 3>&1;4>&1 建立FD3，是用来将下面ls那条语句（子shell）中的FD1 恢复到正常FD1，即输出到monitor，你可以把FD3看作最初始的FD1的硬盘备份（即输出到monitor）；建立FD4，到时用作保存ls的返 回值（echo $?），你可以将FD4看作你考试时用于存放计算“echo $?”的草稿纸；
(ls you no 2>&1 1>&3 3>&-;echo $? >&4) 大家还记得前面说的子shell和管道吧。这条命令首先会继承FD0、FD1、FD2、FD3、FD4，它位于管道前，所以在运行命令前会先把子 shell自己的FD1和管道“|”相连。但是我们的条件是stderr通过管道送往egrep，stdout仍然输出到monitor。 于是通过2>&1，先把 子shell的FD1 的管道“送给”FD2，于是子shell中的stderr送往管道“|”；再通过 1>&3，把以前的“硬盘备份”恢复给子shell的FD1，于是子shell中的FD1变成送到monitor了。再通过 3>&- ，将3关闭；接着运行echo $? ，本来其输出值应该送往管道的，通过 >&4 ，将 输出 送往 “草稿纸”FD4，留以备用。
((ls you no 2>&1 1>&3 3>&-;echo $? >&4)|egrep \* >file) 于是，stderr 通过管道送给 egrep ，stdout 送给monitor，但是，还有 FD4，它送到哪去了？ $(((ls you no 2>&1 1>&3 3>&-;echo $? >&4)|egrep \* >file) 4>&1)最后的 4>&1 ，就是把FD4 重定向到 FD1。但由于其输出在 $( )中，其值就赋给变量ss了。最后一行关闭 FD3、FD4。
6、 高阶例子
命令 cmd1, cmd2, cmd3, cmd4. 如何利用单向管道完成下列功能：
1. 所有命令并行执行。
2. cmd1 和 cmd2 不需要 stdin。
3. cmd1 和 cmd2 的 stdout 定向到 cmd3 的 stdin。
4. cmd1 和 cmd2 的 stderr 定向到 cmd4 的 stdin。
5. cmd3 的 stdout 定向到文件 a, stderr 定向到屏幕。
6. cmd4 的 stdout 定向到文件 b, stderr 定向到屏幕。
7. cmd1 的返回码赋给变量 s。
8. 不能利用临时文件。
解决方法：
exec 3>&1; exec 4>&1
s=$(((((cmd1 1>&3 ; echo $? >&4 )| cmd2 ) 3>
&1 | cmd3 >a 2>&3 ) 2>&1 | cmd4 >b ) 4>&1)
exec 3>&-; exec 4>&-这 个我一步步解释（好复杂，自己感觉看明白了，过一会再看，大脑仍然有几分钟空白～～～，没想到我也能看明白。exec 3>&1; exec 4>&1 前面的例子都有说明了，就是建立FD3 ，给cmd1恢复其FD1用和给cmd3 恢复其FD2用，建立FD4，保存“echo $?”输出值的“草稿纸”。
第一 对括号：(cmd1 1>&3 ; echo $? >&4 ) 和其后（第一个）管道。在第一个括号（子shell）中，其FD1已经连到 管道中了，所以用 FD3 将 FD1恢复正常，不让他往管道跑；这里的cmd1没有stdin，接着将 cmd1 运行的返回码 保存到 FD4 中。
第 二对括号：((cmd1 1>&3 ; echo $? >&4 )| cmd2 ) 3>&1 和其后（第二个）管道。前面的 FD1 已经不送给 cmd2了，FD2 默认也不送过来，所以cmd2 也没有stdin ，所以在第二对括号里面：cmd1和cmd2 的stdout、stderr 为默认输出，一直遇到 “3>&1”为止。请注意：“3>&1”，先将第二对括号看出一个命令，他们遇到 第二个管道时，其FD1 连到 管道 “|”，由于“3>&1”的作用，子shell的FD1 送给FD3 使用，所以所有FD3 的输出都 “流往”cmd3，又由于继承关系（继承第一行的命令），FD3实际上就是cmd1和cmd2的stdout，于是“ cmd1 和 cmd2 的 stdout 定向到 cmd3 的 stdin”
第三对括号：(((cmd1 1>&3 ; echo $? >&4 )| cmd2 ) 3>&1 | cmd3 >a 2>&3 ) 2>&1 和其后的第三个管道。cmd1 和 cmd2 的 stdout 已经定向到 cmd3 的 stdin，处理之后，cmd3 >a 意味着将其 stdout 送给 a 文件。而2>&3的意思是：恢复cmd3的错误输出为FD3，即送往 monitor。于是“cmd3 的 stdout 定向到文件 a, stderr 定向到屏幕”。如果没有“2>&3”，那么cmd3的错误输出就会干扰cmd1和cmd2的错误输出，所以它是必须的！请注意第三对括号后 的 “2>&1”| ，其子shell的FD1 本来连接着管道“|”，但子shell FD1 慷慨大方，送给了 FD2，于是FD2 连接着管道。还记得前面的 cmd1 和 cmd2 吗？他们的stderr一直没动了。于是在这里，通过管道送给了 第四个命令cmd4 了。即“cmd1 和 cmd2 的 stderr 定向到 cmd4 的 stdin”。后面就比较简单了。cmd4 >b 表示“cmd4 的 stdout 定向到文件 b, stderr 定向到屏幕（默认）”
第四 对括号：((((cmd1 1>&3 ; echo $? >&4 )| cmd2 ) 3>&1 | cmd3 >a 2>&3 ) 2>&1 | cmd4 >b ) 与其后的 4>&1。四对括号里面的 FD1、FD2都处理完了。但是还记得前面“echo $? >&4”那块“草稿纸”吗？“4>&1”的作用就是“将草稿纸上的内容送给monitor”，但是由于最外面还有 $() 将其“包着”。于是其值赋给变量“s”。
（本文转载自：http://www.xxlinux.com/linux/article/development/shell/2006-10-16/5018.html）
-
一
最近学习Linux编程，收获真的很多。以前都是别人或man告诉你某个命令怎么使用，但现在我才领悟到，是程序的源代码决定了全部。
linux编程，首先需要安装gcc与其它编程工具与库文件。最简单的方法是进入图形界面的添加删除程序，选上开发工具就可以了。
1.APUE2源代码下载：http://www.apuebook.com/src.tar.gz
2.我保存到了/root下.解压缩:tar -xzvf src.tar.gz
3.cd apue.2e进入apue.2e目录,查看README,告诉我们linux系统只要修改Make.defines.linux再make
4.vi Make.defines.linux 修改WKDIR=/root/apue.2e 就是说工作目录为WKDIR=/root/apue.2e
5.修改/root/apue.2e/std/linux.mk把全部的nawk改为awk.因些linux默认没有nawk
6.make
一个需要注意的地方:
apue编程的例子都有关include "apue.h"的代码,其实apue.h并不是系统自带的,它是作者编写的头文件,源代码在附录B中.因此一个方法是.把刚才生成的 /root/apue.2e/include/apue.h直接复制到/usr/include下.
还有像err_sys 的函数也在附录B中.同样的方法是在/usr/include新建一个 my_err.h的文件,把Figure B.3. Error functions that output to standard error内容复制进去.这样按例子编程就只需要在行首添加:#include "my_err.h"就可以了..
(转载自:http://blog.chinaunix.net/u1/52350/showart_426726.html)
二
APUE2作者提供的源码编译方法及单个源码编译的实现
前面一篇文章讲解了《UNIX环境高级编程》源码编译方法。文中所讲到的编译方法是非作者提供的编译方法，即不使用作者提供的头文件，程序中所有使用的头文件都一一列出。而程序中的出错处理函数则简单的用printf函数替代。随后，也有网友提出如何采用作者的方法来对所有的程序进行编译。出于解决问题，同时也想实现这个方法，毕竟实现之后每个程序都可以直接运行，还是比较方便的。因此，就按照源代码文件夹中的README的步骤，对整个源代码进行了编译。
（1）作者提供的编译方法的实现
README文件中给出的编译方法如下：
To build the source, edit the Make.defines.* file for your system and set WKDIR to the pathname of the tree containing the source code. Then just run "make". It should figure out the system type and build the source for that platform utomatically.
参照该方法，我将源码的编译分为三步。整个步骤都是在root超级用户下进行的，如果其他用户没有权限进行编译，可以通过su命令切换到超级用户。
第一步，编辑Make.defines.*文件。由于我所使用的操作系统是FreeBSD6.1，所以应该编辑文件Make.defines.freebsd。其实，编辑该文件的内容主要是修改其中的WKDIR，即我们源码所在文件夹的绝对路径名。原文件中WKDIR＝/home/sar/apue.2e，我们可以根据我们实际文件夹所在的位置进行相应的修改。我的apue.2e文件夹直接放在/home下了，所以我将WKDIR修改为WKDIR＝/home/apue.2e。其余内容不用修改，保存修改后的文件。
第二步，修改脚本文件systype.sh的权限。由于原始的systype.sh文件不具有可执行的权限。通过执行命令:#chmod +x systype.sh
给当前用户及其所在组和其他组添加可执行权限；或者#chmod u+x systype.sh 仅给当前用户添加可执行权限。
该脚本文件的功能主要是检测操作系统的类型。它可以检测到系统的类型有：FreeBSD，Linux，MacOS和Solaris等。如果单独执行这个shell脚本：
＃./systype.sh 则输出结果为：freebsd。即检测本机的操作系统为FreeBSD。
第三步，进行源码的编译。在命令行下执行make命令。通过查看Makefile文件可知，make之后，首先执行systype.sh脚本，即首先确定操作系统的类型，然后在进行源码的编译。在编译的过程中，会有一些Warning。这些都是正常的，导致警告的原因可能是采用编译起的版本不同或者是同一类型操作系统的版本不同。但是，只要make的过程不出现error，就会顺利的生成可执行文件。我的在编译过程中没有出现error，因此意味着编译成功。
注意：编译的过程中可能会出现的一个问题，也是一个网友曾经问到的问题，就是在编译中出现这个的错误，提示nawk command cannot be found。这个问题可能的原因是，有些操作系统的内核版本较低，可能还不支持nawk(new awk)这个命令。但应该支持awk命令。因此，问题的解决方法就是将相关文件中的nawk命令替换为awk，或者为系统添加一个别名alias，alias nawk awk。这样在编一的过程中，遇到nawk命令时，实际会去执行awk命令。如果还有其他问题，可以去网上搜索相关的解决方法。因为我在编译的过程中没有遇到这样的问题，不再一一赘述。
（2）编译生成可执行文件的位置
在路径/home/apue.2e/下虽然有所有的源文件，都是以figx.x的形式命名。但是实际编译的过程并不是编译的这些文件。而是编译在该路径下各个文件夹中的后缀名为＊.c的程序。作者把同一章节或者相近几个章节的源代码放在某一个文件夹下面（include和lib文件夹除外）。而文件夹的命名一般是和该章对应的标题是一致的，采用的是英文标题的全称或简写。譬如，advio文件夹对应Chapter 14. Advanced I/O，该章的代码就放在该文件夹下面。还有文件夹proc对应Chapter 8. Process Control，文件夹termios对应Chapter 18. Terminal I/O等等，基本上每一章的代码都可以在这些文件夹中找到。
（3）如何编译单独的源文件
通过make命令是直接将所有的源程序编译成可执行文件的。对于喜欢修改和调试程序的朋友来说，make生成的可执行文件显然不具有这样的功能，而且，也不可能修改了一个源文件，然后还要make。如何需要编译和调试单个程序的话，方法如下：
1.首先还是要用make对所有文件进行编译。成功编译后，会在WKDIR／lib／下生成库文件libapue.a，主要是将apue.h（位于WKDIR／include/）中定义的所有内容生成一个静态的库，这样可以方便调用。
2.我们以WKDIR/下的fig1.3（实现ls部分功能）文件为例说明需要修改的地方。将fig1.3文件重命名为fig1.3.c，然后编辑该文件，将包含头文件的一行代码：
＃i nclude "apue.h" //默认所引用头文件的位置为当前的路径WKDIR=/home/apue.2e
修改为
＃i nclude "include/apue.h"
即头文件apue.h的位置为当前路径下inlucde文件夹中，这个就正确的指定了apue.h的位置。
这样就可以进行编译了，但在编译的时候还要加上库文件libapue.a，因为该文件实现了apue.h中的所有功能，主要有常用头文件，宏定义以及自定义函数的实现。
输入命令
#gcc fig1.3.c lib/libapue.a
则会生成可执行文件a.out。执行命令
#./a.out /home
则列出我的/home路径下的所有文件和文件夹：
.
..
david
simsun .ttc
simkai.ttf
simsun.ttf
MYKERNEL
unix_advance_program
freebsd
APUE Source Code
LumaQQ
apue.2e
bash-script
lumaqq_2005_patch_2006.01.22.15.00.zip
lumaqq_2005-linux_gtk2_x86_with_jre.tar
apue_src_complied.tar
当然，如果需要编译的是各个文件夹中的一个源程序时，则只需对所包含的头文件apue.h的路径作相对修改，改为
＃i nclude "../include/apue.h"
以及编译是库文件的位置也相应修改，改为：
#gcc sourcefile.c ../lib/libapue.a
至此，APUE第二版作者提供的源码编译方法和单独源码的编译都已经实现。
(转载自：http://www.blog.edu.cn/user2/shawnchen/archives/2007/1955932.shtml)
------------------------------------------------------------------------------------------
三
我自己首次编译时遇到一个问题，现将现象及解决方法记录在此，供遇到同样问题的童鞋参考。
我的环境是RHEL5.3 按照《一》的方法修改完后，
在编译std目录时仍然报错：undefined reference to `main'
我进入std目录查看时发现生成一个conf.c的空文件，同时目录下还存在一个conf.c.modified文件
我尝试把conf.c.modified修改为conf.c，编译成功，再次删除conf.c之后，编译仍然成功。为什么之前没conf.c编译就报错。复制一个后编译成功，删掉conf.c再编译就能成功，至今还没想明白到底是为什么。 -
Python语言中：”对一个文件已经关闭的文件对象调用 close 不会 引发异常，它静静地失败。“详见《Dive Into Python》(中文版) 6.2 与文件对象共事。
C语言在不同的操作系统下则有不同的结果。
测试程序:
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main()
{
int i;
FILE *fp;
i = 0;
fp = NULL;
printf("----- %d -----\n", ++i);
fp = fopen("testfclose.log","w+");
printf("----- %d -----\n", ++i);
fputs("test",fp);
printf("----- %d -----\n", ++i);
fclose(fp);
printf("----- %d -----\n", ++i);
fclose(fp);
printf("----- %d -----\n", ++i);
return 0;
}Linux（RHEL5.3）下输出结果：
----- 1 -----
----- 2 -----
----- 3 -----
----- 4 -----
*** glibc detected *** ./testfclose: double free or corruption (top): 0x089c6008 ***
======= Backtrace: =========
/lib/libc.so.6[0x88e0f1]
/lib/libc.so.6(cfree+0x90)[0x891bc0]
/lib/libc.so.6(fclose+0x136)[0x87cc56]
./testfclose[0x80484ff]
/lib/libc.so.6(__libc_start_main+0xdc)[0x83ae8c]
./testfclose[0x8048381]
======= Memory map: ========
00807000-00821000 r-xp 00000000 fd:00 4294146 /lib/ld-2.5.so
00821000-00822000 r-xp 00019000 fd:00 4294146 /lib/ld-2.5.so
00822000-00823000 rwxp 0001a000 fd:00 4294146 /lib/ld-2.5.so
00825000-00963000 r-xp 00000000 fd:00 4294423 /lib/libc-2.5.so
00963000-00965000 r-xp 0013e000 fd:00 4294423 /lib/libc-2.5.so
00965000-00966000 rwxp 00140000 fd:00 4294423 /lib/libc-2.5.so
00966000-00969000 rwxp 00966000 00:00 0
00a7a000-00a7b000 r-xp 00a7a000 00:00 0 [vdso]
00dc8000-00dd3000 r-xp 00000000 fd:00 4294429 /lib/libgcc_s-4.1.2-20080825.so.1
00dd3000-00dd4000 rwxp 0000a000 fd:00 4294429 /lib/libgcc_s-4.1.2-20080825.so.1
08048000-08049000 r-xp 00000000 fd:00 4915518 /home/weaver/tmp/testfclose
08049000-0804a000 rw-p 00000000 fd:00 4915518 /home/weaver/tmp/testfclose
089c6000-089e7000 rw-p 089c6000 00:00 0 [heap]
b7e00000-b7e21000 rw-p b7e00000 00:00 0
b7e21000-b7f00000 ---p b7e21000 00:00 0
b7f75000-b7f77000 rw-p b7f75000 00:00 0
b7f84000-b7f85000 rw-p b7f84000 00:00 0
bfa80000-bfa95000 rw-p bffea000 00:00 0 [stack]
已放弃Windows（WinXP SP3）下输出结果：
----- 1 -----
----- 2 -----
----- 3 -----
----- 4 -----
----- 5 -----Unix（AIX 5.2）下输出结果：
----- 1 -----
----- 2 -----
----- 3 -----
----- 4 -----
----- 5 ----- -
看图说话：
1 Don't use Perl; it's counter-revolutionary.
千万不要用 Perl, 它是反革命。
2 Long live in struggle against bracist imperialism.
3 strive for exerllence in modules.
长期不懈的坚持与大括号帝国主义的斗争。
为精通各种模块而努力奋斗。 -
最近遇到了将人民币小写转换成大写的问题，自己写下来，发现代码冗长繁琐。于是Google之，终于找到了一段比较完美的C++语言实现的代码。 源地址请猛击：http://topic.csdn.net/t/20050731/17/4179695.html
现将整理代码记录在此，以备后用：
/*******************************************************
* Name: amt2chn.cpp
* Copyright:
* Author: weaver
* Date: 2008-12-02 20:20:20
* Description: 此C++版根据
http://topic.csdn.net/t/20050731/17/4179695.htm 整理
版权归 ” csdn.net：僵哥 “ 所有
*******************************************************/#include <stdio.h>
#include <math.h>
#include <string.h>
//===== bround Begin =====
//------------------------------------
//四舍五入
//例:1.535
//保留小数点后两位，做四舍五入得1.54
//使用方法:bround(1.535,2)
//返回值:1.54
//------------------------------------
double __stdcall bround( const double Value,
const short int ADigit=0,
const short int RoundMark=0 )
{
double Result=Value;
if(ADigit>18)
return Result;
double DigitValue=powl(10,ADigit);
double DResult=0.00;
char LocalRoundMark=RoundMark;
if(LocalRoundMark>0)
LocalRoundMark=1;
if(LocalRoundMark<0)
LocalRoundMark=-1;
switch(LocalRoundMark)
{
case -1: /* Round Down */
Result*=DigitValue;
if(Value<0.00) /* 负数 */
Result=ceill(Result);
else
Result=floorl(Result);
break;
case 1: /* Round Up */
Result*=DigitValue;
if(Value<0.00) /* 负数 */
Result=floorl(Result);
else
Result=ceill(Result);
break;
default: /* Round 四舍五入 */
if(Value<0.00) /* 负数 */
Result-=0.5/DigitValue;
else
Result+=0.5/DigitValue;
Result*=DigitValue;
DResult=Result;
if(Value<0.00)
{
Result=ceill(Result);
DResult=Result-DResult;
if(DResult>0.99999995) /*0.9999999999*/
Result-=1.0;
}
else
{
Result=floorl(Result);
DResult=DResult-Result;
if(DResult>0.99999995) /*0.9999999999*/
Result+=1.0;
}
}
Result/=DigitValue;
return Result;
}
unsigned char __stdcall amt2chn( const double Num,
const unsigned char BufferLength,
char *Buffer,
const short int ADigit=2,
const short int RoundMark=0 )
{
const char mnUnit[3][3]={"分","角","元"};
const char fixWord[2][3]={"整","负"};
const char chUnit[8][3]={"拾","佰","仟","万","拾","佰","仟","亿"};
const char chCapt[10][3]={"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};
char szChMoney[33*4+1],*szNum;
int iLen,iLen2, iNum, iAddZero=0;
char buff[33];
char *buf=buff;
sprintf( buf,"%0.0f",bround(Num,ADigit,RoundMark)*100.0);
iLen=strlen(buf);
szNum=szChMoney;
if(Num<0.0)
{
*(szNum++)=fixWord[1][0];
*(szNum++)=fixWord[1][1];
buf++;
iLen--;
}
for(int i=1;i<=iLen;i++)
{
iNum=buf[i-1]-48;
iLen2=iLen-i;
if(iNum==0)
{
if((iLen2-2)%4==0&&(iLen2-3)>0&&((iLen2>=8)||iAddZero<3))
{
*(szNum++)=chUnit[(iLen2-3)%8][0];
*(szNum++)=chUnit[(iLen2-3)%8][1];
}
iAddZero++;
}
else
{
if(iLen>1&&iLen2==0&&iAddZero>0)
{
*(szNum++)=chCapt[0][0];
*(szNum++)=chCapt[0][1];
}
if((iAddZero&&iLen2>=2)&&((iLen2-1)%4!=0)||(iAddZero>=4&&(iLen2-1)>0))
{
*(szNum++)=chCapt[0][0];
*(szNum++)=chCapt[0][1];
}
*(szNum++)=chCapt[iNum][0];
*(szNum++)=chCapt[iNum][1];
iAddZero=0;
}
if((iAddZero<1)||(iLen2==2))
{
if(iLen2>=3)
{
*(szNum++)=chUnit[(iLen2-3)%8][0];
*(szNum++)=chUnit[(iLen2-3)%8][1];
}
else
{
*(szNum++)=mnUnit[(iLen2)%3][0];
*(szNum++)=mnUnit[(iLen2)%3][1];
}
}
}
int Result=szNum-szChMoney;
if(Result+(Num<0.0?(-2):0)==0)
{
*(szNum++)=chCapt[0][0];
*(szNum++)=chCapt[0][1];
*(szNum++)=mnUnit[2][0];
*(szNum++)=mnUnit[2][1];
*(szNum++)=fixWord[0][0];
*szNum=fixWord[0][1];
Result+=6;
}
else if(buf[iLen-1]=='0')
{
*(szNum++)=fixWord[0][0];
*szNum=fixWord[0][1];
Result+=2;
}
if(BufferLength)
{
if(BufferLength>0)
Result=(Result>BufferLength)?BufferLength:Result;
memcpy(Buffer,szChMoney,Result);
}
return Result;
}我在写一个Python小程序中用到，于是将其转化为Python代码，附上Python实现代码:
#!/usr/bin/env python
# -*- encoding: UTF-8 -*-
# Filename: amt2chn.py
def amt2chn(amt):
mnUnit = ("分", "角", "元")
fixWord = ("整", "负", "人民币")
chUnit = ("拾", "佰", "仟", "万", "拾", "佰", "仟", "亿")
chCapt = ("零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖")
chn = fixWord[2]
iLen = 0
iLen2 = 0
iNum = 0
iAdd0 = 0
# -----此处插入对amt进行银行家舍入操作代码-----
# ----- ..... -----
# -----此处插入对amt进行银行家舍入操作代码-----
s_amt = str(int(amt*100.0))
iLen = len(s_amt)
if ( amt < 0.00 ):
chn += fixWord[1]
s_amt = s_amt[1:]
iLen -= 1
for i in range(iLen):
iNum = int(s_amt[i])
iLen2 = iLen - i - 1
if ( 0 == iNum):
if ( (iLen2-2)%4==0 and (iLen2-3)>0 and ((iLen2>=8) or iAdd0<3) ):
chn += chUnit[(iLen2-3)%8]
iAdd0 += 1
else:
if ( iLen>1 and iLen2==0 and iAdd0>0 ):
chn += chCapt[0]
if ( (iAdd0 and iLen2>=2) and
((iLen2-1)%4!=0) or (iAdd0>=4 and (iLen2-1)>0) ):
chn += chCapt[0]
chn += chCapt[iNum]
iAdd0 = 0
if ( (iAdd0<1) or (iLen2==2) ):
if( iLen2>=3 ):
chn += chUnit[(iLen2-3)%8]
else:
chn += mnUnit[(iLen2)%3]
l_chn = len(chn) - len(fixWord[2])
l_chn = int(l_chn/1.5)
if( l_chn+(amt<0.00 and (-2) or 0) == 0 ):
chn += chCapt[0]
chn += mnUnit[2]
chn += fixWord[0]
elif ( s_amt[iLen-1] == '0' ):
chn += fixWord[0]
return chn
if __name__ == '__main__':
amt1 = 1231.21
print amt1, ':', amt2chn(amt1) -
四舍五入都是往右边计算：
-----(-5)-----(-4.6)(-4.5)(-4.4)-----(-4)----------(0)----------(4)-----(4.4)(4.5)(4.6)-----(5)-----
-----(-5)<---(-4.6)(-4.5)---------->(-4)----------(0)----------(4)<----------(4.5)(4.6)--->(5)-----
-------------------------------(-4.4)--->(-4)---------(0)-----------(4)<---(4.4)----------------------------
注意这些数字的位置关系，正数和负数并不是对称关系，Math.round()的运算时都是由左向右运算。
舍入方法叫做银行家舍入（Banker’sRound），这就是已经规定下来的标准、Round的标准、世界的标准。
也许我们习惯把Round与四舍五入等同，但是公式可能应该这样写。
Round <> 四舍五入
在微软的主页上也有比较详细的说明，
[url]http://support.microsoft.com/default.aspx?scid=http[/url]://support.microsoft.com:80/support/kb/articles/Q196/6/52.asp&NoWebContent=1
我们这个年代的过来的对四舍五入应该不陌生，但是什么是“银行家舍入”挺起来好像就有些过于专业，但是，现在在上小学的学生对此应该比我们更了解“银行家舍入”，因为它已经被写入了小学数学课本，而且是专门的一个章节。下面我就给大家介绍一下这两个舍入算法。
先看下面的对比表：
我们把原始数据舍入到小数点后两位：
原始数据 四舍五入 银行家舍入
1.000 1.00 1.00
1.111 1.11 1.11
1.444 1.44 1.44
1.465 1.47 1.46
1.555 1.56 1.56
1.565 1.57 1.56
1.666 1.67 1.67
1.849 1.85 1.85
1.999 2.00 2.00
银行家舍入算法用一句形象的话概括就是四舍六入五成双。
个人认为：当我们要使用一种合理的舍入方法来处理货币的时候，我们可以看到：
1 <-> 9
2 <-> 8
3 <-> 7
4 <-> 6
上面的含义是，我们遇到1舍去，那么9可以为此补上；2舍去，8可以来补上；……这样在大量随机数据中，舍去和补上就中和（暂且用这个词）。
5呢，我们到底是舍入还是进位呢。我们采取总是把被舍入处理的数进行双数化处理，这样我们的舍入和补上的比率又是1:1了，这样就能比较合理得处理货币的舍入问题。
我们再来看计算机语言对这些的支持，在IEEE里规定round函数就是要采用Banker’s rounding（银行家舍入）来处理。
C#,vs.net.j#,vbscript都是采用的四舍六入五成双
所以说我们（特指与我受过同样的小学数学教育的中国人）常用的四舍五入算法是不公平的，它总是把数值上推，而银行家舍入算法作为一种国际公认的算法是比较合理的，因此它也被写入了现代的小学数学书中，而且占用了一个章节。本文转载自： http://blog.donews.com/shanyou/archive/2005/03/06/296147.aspx
Collect Erudition ！
Knowledge is infinite ！
