C++博客-qiezi的学习园地-随笔分类-学习方向

ABI Specifications 相关链接

qiezi — Thu, 23 Mar 2006 08:08:00 GMT

Itanium C++ ABI ($Revision: 1.86 $)
http://www.codesourcery.com/cxx-abi/abi.html

C++ ABI Summary
http://www.codesourcery.com/cxx-abi/

C++ ABI for IA-64: Code and Implementation Examples
http://www.codesourcery.com/cxx-abi/abi-examples.html

C++ Vtable Example
http://www.codesourcery.com/cxx-abi/cxx-vtable-ex.html

Intel® Itanium® Processor-specific Application Binary Interface (ABI)
http://developer.intel.com/design/itanium/downloads/245370.htm

qiezi 2006-03-23 16:08 发表评论

DMD 0.141发布

qiezi — Tue, 06 Dec 2005 02:41:00 GMT

What's New for D 0.141

Dec 1, 2005

New/Changed Features

The predefined version identifier D_InlineAsm has been changed to D_InlineAsm_X86. The former made no sense, and although it is still defined, it is deprecated.
Added D code coverage analyzer.
Added .mangleof property for types, which gives the 'mangled' type name as a string.

Bugs Fixed

Fixed D.bugs/5643
Fixed D.bugs/5668
Fixed D.bugs/5687
Fixed D.bugs/5690
Fixed D.bugs/5673 (it now issues an OutOfMemoryException)
Fixed D.bugs/5729
Fixed dstress.run.c.creal_26_A regression.
Fixed dstress.run.const_18 regression.

其中“D代码覆盖分析器”应该是很多人感兴趣的东西了，下面是一个例子(摘自http://digitalmars.com/d/code_coverage.html)：

/* Eratosthenes Sieve prime number calculation. */

bit flags[8191];

int main()
{   int     i, prime, k, count, iter;

    printf("10 iterations\n");
    for (iter = 1; iter <= 10; iter++)
    {    count = 0;
    flags[] = true;
    for (i = 0; i < flags.length; i++)
    {   if (flags[i])
        {    prime = i + i + 3;
        k = i + prime;
        while (k < flags.length)
        {
            flags[k] = false;
            k += prime;
        }
        count += 1;
        }
    }
    }
    printf ("\n%d primes\n", count);
    return 0;
}

编译、运行：

dmd sieve -cov
sieve

结果如下：

       |/* Eratosthenes Sieve prime number calculation. */
       |
       |bit flags[8191];
       |
       |int main()
      5|{   int     i, prime, k, count, iter;
       |
      1|    printf("10 iterations\n");
     22|    for (iter = 1; iter <= 10; iter++)
     10|    {   count = 0;
     10|        flags[] = true;
163840|        for (i = 0; i < flags.length; i++)
81910|        {   if (flags[i])
18990|            {   prime = i + i + 3;
18990|                k = i + prime;
168980|                while (k < flags.length)
       |                {
149990|                    flags[k] = false;
149990|                    k += prime;
       |                }
18990|                count += 1;
       |            }
       |        }
       |    }
      1|    printf ("\n%d primes\n", count);
      1|    return 0;
       |}
sieve.d is 100% covered

另一个惊喜是mangleof属性，可以得到一个类型被编译器mangle后的名字。不知道mangle对应的中文翻译是什么？大概是“名字转换”吧。一点测试代码：

import std.stdio;

void test();

void test1(int n);

void test2(int n);

void main()
{
    void function (int, char[]) f;
    void function (int) f1;
    void function () f2;
    writefln (f.mangleof);
    writefln (f1.mangleof);
    writefln (f2.mangleof);
    writefln (int.mangleof);
    float a;
    writefln (a.mangleof);
    writefln ((&test).mangleof);
    writefln ((&test1).mangleof);
    writefln ((&test2).mangleof);
    writefln (void.mangleof);
}

编译执行结果如下：

PFiAaZv
PFiZv
PFZv
i
f
PFZv
PFiZv
PFiZv
v

qiezi 2005-12-06 10:41 发表评论

DMD 0.140发布

qiezi — Fri, 25 Nov 2005 05:38:00 GMT

Nov 23, 2005

New/Changed Features

Added std.string.soundex.
Added std.string.entab.
Added std.string.wrap.
Added std.string.abbrev.
Added std.windows.charset (thanks to Stewart Gordon, D/28246).
Added std.demangle to demangle D names.
Improved promotion of names inside templates.
Now allows floating point and string literals as template value arguments.
To support the previous, the name mangling of template instances has changed. This will necessitate recompilation of any code that uses templates.
std.utf.UtfError is now deprecated. Use std.utf.UtfException instead.

Bugs Fixed

Fixed D.bugs/5299
Fixed D.bugs/5353
Fixed D.bugs/5360
Fixed D.bugs/5391
Fixed D.bugs/5429
Fixed D.bugs/5464
Fixed std.string.expandtabs so it handles UTF.

比较感兴趣的是浮点数和字符串常量作为模板值参数，简单测试了一下：

import std.stdio;

template TFloat (float F)
{
    float value = F;
}

template TString (char[] S)
{
    char[] value = S;
}

void main()
{
    alias TFloat!(3.14f) PI;
    writefln(PI.value);
    writefln(TString!("hello").value);
}

编译通过，运行结果如下：

3.14
hello

qiezi 2005-11-25 13:38 发表评论

DMDScript脚本工具，DDL项目

qiezi — Sat, 19 Nov 2005 16:20:00 GMT

DMDScript是Digital Mars提供的一个符合ECMA 262规范的脚本语言，采用D语言编写，开放源代码，可以从http://www.digitalmars.com/dscript看到详细信息，另外有一个C++的实现版本。

另外2个符合ECMA 262规范的脚本语言分别是Netscape的javascript和Microsoft的JScript，目前DMDScript和其它2个不完全兼容，不过效率要高一些。DMDScript提供了一个简单的测试，生成8190以内的质数，迭代10次，在我的机器上，javascript执行耗时566毫秒，DMDScript执行耗时188毫秒，整整快了3倍。

如果你想实现一个符合ECMA 262标准的脚本语言，建议看这份代码的实现吧，比较简洁，只有400多K。微软那份估计是很难看到了，Netscape那份用C写的，代码大小就有近3M，宏也比较多，看起来要吃力一些。

DDL是dsource.org上的一个有趣的项目，它可以从.obj或.lib文件中加载代码并执行，目前支持COFF、OMF、ELF格式。

qiezi 2005-11-20 00:20 发表评论

D语言的模板

qiezi — Fri, 11 Nov 2005 09:13:00 GMT

D语言的模板使用非常方便灵活，受够了C＋＋模板编写之苦的同学们可以感受一下D语言的模板，下面先展示一个D语言编写的多分派委托类，在我的旧BLOG上曾经写过一个C＋＋版本的，整个过程感觉非常痛苦。。。

闲话少说，请看代码：

import std.stdio;

template DelegateHandlers(HandlerType, FunctionType)
{
    HandlerType[] handlers;
    FunctionType[] functions;

    void opAddAssign(HandlerType h)
    {
        handlers.length = handlers.length + 1;
        handlers[length-1] = h;
    }
    void opAddAssign(FunctionType f)
    {
        functions.length = functions.length + 1;
        functions[length-1] = f;
    }
}

template Delegate(Ret)
{
    class Delegate
    {
        alias Ret delegate () HandlerType;
        alias Ret function () FunctionType;
        mixin DelegateHandlers!(HandlerType, FunctionType);

        static if(is(Ret: void))
        {
            void opCall ()
            {
                foreach (HandlerType handler; handlers)
                    handler ();
                foreach (FunctionType _function; functions)
                    _function ();
            }
        }
        else
        {
            Ret opCall ()
            {
                Ret ret;
                foreach (HandlerType handler; handlers)
                    ret = handler ();
                foreach (FunctionType _function; functions)
                    ret = _function ();
                return ret;
            }
        }

    }
}

template Delegate(Ret, Arg1)
{
    class Delegate
    {
        alias Ret delegate (Arg1) HandlerType;
        alias Ret function (Arg1) FunctionType;
        mixin DelegateHandlers!(HandlerType, FunctionType);

        static if(is(Ret: void))
        {
            void opCall (Arg1 a1)
            {
                foreach (HandlerType handler; handlers)
                    handler (a1);
                foreach (FunctionType _function; functions)
                    _function (a1);
            }
        }
        else
        {
            Ret opCall (Arg1 a1)
            {
                Ret ret;
                foreach (HandlerType handler; handlers)
                    ret = handler (a1);
                foreach (FunctionType _function; functions)
                    ret = _function (a1);
                return ret;
            }
        }

    }
}

class Test
{
    void test ()
    {
        writefln ("Test.test");
    }
    int test1 ()
    {
        writefln ("Test.test1");
        return 1;
    }
    void test2(int v)
    {
        writefln ("Test.test2");
    }
    int test3(int v)
    {
        writefln ("Test.test3");
        return 7;
    }
}

void test_func ()
{
    writefln ("test_func");
}
int test_func1 ()
{
    writefln ("test_func1");
    return 2;
}
void test_func2(int v)
{
    writefln ("test_func2");
}
int test_func3(int v)
{
    writefln ("test_func3");
    return 9;
}

void main()
{
    Test t = new Test;

    alias Delegate!(void) DDD;
    DDD d = new DDD;
    d += &t.test;
    d += &test_func;

    d ();

    alias Delegate!(int) DDD1;
    DDD1 d1 = new DDD1;
    d1 += &t.test1;
    d1 += &test_func1;

    int a = d1 ();
    assert (a == 2);

    alias Delegate!(void, int) DDD2;
    DDD2 d2 = new DDD2;
    d2 += &t.test2;
    d2 += &test_func2;

    d2 (1);

    alias Delegate!(int, int) DDD3;
    DDD3 d3 = new DDD3;
    d3 += &t.test3;
    d3 += &test_func3;

    int b = d3 (2);
    assert (b == 9);
}

非常干净，非常简洁，不是吗？这个只花了我10分钟时间来写。。。

D语言的委托非常高效，有兴趣的可以测试一下通过委托和直接调用之间的性能差别。上面这个自己实现的多分派委托类，效率也非常高，我的测试结果是对于性能的影响几乎可以忽略。想起那个历尽千辛万苦实现的C＋＋多分派委托类，实现复杂、调试费时、运行效率还很低，每每一想到这心里那个难受啊。。。。

再来看一下D语言强大的静态检查机制：

template XXX (int v)
{
    int n = v;
    static assert (v > 3);
}

void main ()
{
    int n;
    n = XXX!(4).n; // OK
    n = XXX!(3).n; // 编译错误
}

同样很漂亮。

如果你觉得提示信息不够友好，可以修改为：

template XXX (int v)
{
    int n = v;
    static if (v <= 3)
        pragma (msg, "template value must > 3");
    static assert (v > 3);
}

这是编译时的错误提示：

Compiling test.d ...
template value must > 3
D:\workspace\dace\test.d(94): static assert (3 > 3) is false
D:\workspace\dace\test.d(173): template instance test.XXX!(3) error instantiating

我想以后有可能会扩充pragma，支持错误输出，这样就不用写重复的语句了，可以简化成这样：

template XXX (int v)
{
    int n = v;
    static if (v <= 3)
        pragma (error, "template value must > 3");
}

这样看起来更好。不过目前有很多重要特性要实现，这种玩意可能要很久以后才会加入了。

qiezi 2005-11-11 17:13 发表评论

D语言调用ActiveX（在窗口中嵌入ActiveX）

qiezi — Fri, 11 Nov 2005 04:16:00 GMT

摘要: 这是一个从C移植到D的代码，原文请见“Embed an HTML control in your own window using plain C”，它用C结构模拟了虚表，并且实现了多个接口以完成对Web Browser控件的调用。在看完他的代码之后，我对于COM/OLE的了解加深了一些，以前使用VC做过COM方面的应用，也看过不少COM方面的书，不过没有涉及到界面，所以一直不知道如何把Activ... 阅读全文

qiezi 2005-11-11 12:16 发表评论

D语言中的in/inout/out参数

qiezi — Thu, 10 Nov 2005 06:51:00 GMT

private import std.stdio, std.process;

void test(int a, inout int b, out int c)
{
    writefln(a);
    writefln(b);
    writefln(c);
    a = 3;
    b = 5;
    c = 7;
}

void main ()
{
    int a = 0, b = 1, c = 2;
    test(a, b, c);
    assert (a == 0);
    assert (b == 5);
    assert (c == 7);
    std.process.system("pause");
}

在上面的例子里，程序在test函数中的输出语句将输出：
0
1
0
也就是说，out参数取值是无意义的，它只用于赋值。

这里有一个很大的问题，调用test(a,b,c)时，调用者对于c的值被改变可能毫无知觉，甚至成为隐藏很深的BUG。对此，许多人建议加强检查，比如在调用时，必须指明inout/out：

test(a, inout b, out c);

似乎能够起到一些警示作用，不过这样一来，语法上倒不怎么简练了。

qiezi 2005-11-10 14:51 发表评论

DMD最近的一些更新

qiezi — Thu, 10 Nov 2005 04:12:00 GMT

v0.138 实现了字符串直接切片调用：

    char[] a = "abcde"[2..3];
    writefln(a);
    char b = "abcde"[3];
    writefln(b);

另外修复了一些编译器和文档生成的BUG。

v0.137的重要更新有：
隐式类型引用：

auto c = "abcde"; // c变量自动获得类型char[]

extern(linkage)在内嵌函数中使用

void test()
{
extern(C) test1();
}

其它更新则主要集中于编译器工作、文档工具、库等，暂时还没有特别令人兴奋的特性加入进来，比如：stack tracing, relation api等。

qiezi 2005-11-10 12:12 发表评论

D语言令人喜爱的几个地方

qiezi — Wed, 02 Nov 2005 08:35:00 GMT

1、去掉了丑陋的宏。
C/C++中的宏是很令人厌烦的，D不允许再使用它。

2、好用的字符串常量表达式。
除了类C的使用双引号的字符串常量表达式以外，还可以使用`字符。可以使用x"68 65 6C6C 6F"来表示"hello"，r"ab\na"则忽略字符串常量中转义字符的转义作用，还可以在字符串常量后加上c, w或d来指示字符串常量是char[]类型、wchar[]类型还是dchar[]类型。可以使用~运算符连接2个字符串。

3、数字。
数字可以直接使用，还可以这样来定义：int a = 3_029_301_000; 数字直接量(包括整数、浮点数、复数)表达式中，“_”字符是被忽略的。另外还直接提供了复数类型。

4、提供定长数组、变长数组、关联数组。
int[3] a定义一个定长数组；int [] a定义一个变长数组；int[int]定义一个关联数组，键类型是int，值类型是int；int[char[]] a定义一个关联数组，键类型是char[]，值类型是int，使用非常方便。
可以使用foreach来遍历数组：

foreach (int index, int value; a)
printf ("%d: %d\n", index, value);
foreach (char[] key, int value; a)
printf ("%.*s: %d\n", index, value);

可以使用in操作符来判断某个值是否是关联数组的一个键：

int[char[]] a;
if ("hello" in a)
writefln ("hello");

数组可以切片(slice)：

int[] a;
int[] b = a[1..3];
int[] c = a[1..length];

等等。。。。

5、其它还支持委托、函数指针、模板、异常、RAII、契约式编程、单元测试、with语句、auto/typeof、垃圾回收、操作符重载、内联汇编、条件编译、嵌入到HTML等，它还标准化了ABI(这是C/C++最让人头痛的地方之一)。这些特性大部分都比较熟悉和实用，下面简单介绍一下条件编译和嵌入到HTML。

6、条件编译。
在D中，可以使用version(VersionID)来进行条件编译：

version (Win32)
{
//
}
else
{
//..
}

还可以使用debug条件：

debug
{
//
}
else
{
//
}

或者：
debug printf ("hello");
静态条件编译：

const int n=1;
static if (n == 1)
writefln ("hello");
else
writefln ("world");

类型检查：

int n = 3;
if (is(n[]))
writefln ("like array");
if (is(n:int))
writefln ("is an integer");

7、嵌入HTML。
在一个HTML文件中，和之间的部分可以当作D代码来编译。比如下面这段代码：

<h1>This is a testh1>
<code>
import std.c.stdio;

int <font size=+1><b>mainb>font>()
{
<span style="color:red">printfspan>(<u>"hello world\n"u>);
return 0;
}
code>
<hr />
<h1> End h1>

把它存储为HTML文件，可以直接使用dmd编译器编译。

qiezi 2005-11-02 16:35 发表评论

配置D语言编程环境

qiezi — Wed, 02 Nov 2005 03:17:00 GMT

D语言是由Walter Bright开发的，他也是Symantec C++编译器的作者，仅凭这一点就知道D语言一定不错。

D语言的介绍最好是看uframer的blog，他翻译了D语言的大部分文档。当然由于D语言目前一直处于测试版，文档和最新的编译器之间可能有很多不一致。

D语言的编译器目前有2个，DMD和GDC，DMD比较容易配置，可以从http://www.digitalmars.com/d/dcompiler.html下载最新版。下载的压缩包直接解压到任意一个分区的根目录，并把\dm\bin和\dmd\bin加到PATH环境变量里即可使用。

写一个简单的D语言程序，当然还是经典的HelloWorld程序：

void main ()
{
printf ("Hello world!\n");
}

和C程序基本上一样。把它保存为hello_world.d。

下面直接在这个源文件所在的目录下，执行dmd hello_world.d，即可编译出hello_world.exe，执行它就能在控制台打印出Hello world!。

接下来到http://www.dsource.org/projects/build/下载build程序，这是在D社区使用比较广泛的一个程序。由于最新的v2.09版已经发现了一些严重的BUG，所以最好到http://svn.dsource.org/projects/build/downloads/下载v2.08版。把下载的.exe文件改名为build.exe并放置合适的文件夹下，并设置PATH环境变量。(为简单起见我是直接把它放在\dm\bin文件夹下)

下面测试一下build程序，编写一个hello_world.brf文件，保存在hello_world.d同一路径下，文件内容如下：

-cleanup
hello_world.d

然后执行build @hello_world即可编译出hello_world.exe。

akIDE是一个D语言的IDE，可以到http://www.lessequal.com/akide下载，它只需要DMD支持。

D语言编译速度非常快(这也是Walter Bright对C++不满的一个重要原因)。dsource.org中的mango项目包含755个D源文件，但在我的机器上编译成.lib文件只需要4秒时间。

D语言性能也很不错，有2篇D语言和C/C++、Java、C#的性能比较文章：
http://mag.vchelp.net/200312/fanyi.htm
http://mag.vchelp.net/200312/fanyi_2.htm

相关项目介绍：
mango: 这是一个专注于服务端编程的项目，目前主要由Kris开发、维护，实现了servlet，暂时还没有太复杂的功能，不过很值得期待。
dwt: D语言的swt开发包，界面开发首选。看过eclipse界面的应该有比较深的印象。由于大部分代码是从java代码转换过来的，所以类名、接口等都没有改变。
dui: D语言的别一个界面开发包，基于GTK。
build: 上面介绍过的build工具。
dcoder: 基于vs.net的D语言语法高亮插件。
dsp: 全称是Dynamic Servlet Pages。

以上项目都可以在http://www.dsource.org/projects/找到详细资料。

DMDScript是一个类似于JavaScript的脚本系统，可以在http://www.digitalmars.com/dscript/找到详细资料，这个我还没有使用过。

最后附上2个使用dwt开发的界面(注：由于本人不习惯安装杀毒软件，下载请先杀毒)：
1、仿eclipse界面：
http://www.cppblog.com/Files/cpunion/dummyeclipse.rar
2、dwt控件演示：
http://www.cppblog.com/Files/cpunion/controlexample.rar

在windows xp主题下效果比较好。这2个程序在我的机器上分别只占6.4M和7.2M内存，启动时间也不足1秒，不要被eclipse的启动时间吓坏了。

找到了这2张图：

qiezi 2005-11-02 11:17 发表评论

最近比较忙

qiezi — Sat, 08 Oct 2005 15:15:00 GMT

工作忙，学习也忙。

1、Ruby on Rails

前阵子看了一下Ruby on Rails，不禁为其深深折服，为Ruby，也为Rails。

照着Four Days on Rails做了一遍，虽然对Ruby不甚熟悉，不过一路下来感觉非常轻松，在搞明白:xxx和"xxx"是同一个意思以后，终于能看懂大部分代码了，也为这种语法叫好，要知道很多时候引号并不好用，当出现嵌套的时候。(注：在Ruby里，"hello, #{user[:name]}"表示把user["name"]的值放到那个引号里面，这样做可以不仔细去考虑是不是使用单引号)

接着试了一下typo，一个ruby写的blog程序，看到它具有登录功能，而在4 days中并没有看到，于是找了相关资料，原来Rails中已经有这东西了，简单查看了文档以后，就为4 days中的那个演示项目加上了登录功能，前后不过十来分钟。

这样看来，一个人要做一个blog程序，大概2-3小时就够了，包括编写数据库模式、生成管理者使用的MVC结构(具有添加修改删除等功能)、添加登录功能，在此基础上再生成一个Controller，简单修改就能改成供其它用户使用的阅读界面，再稍费点神就能加上评论功能了。当然离标准的blog程序还有段距离，比如还不支持RSS，不过自己用来写点东西记点笔记什么的，足够用了。

2、Ajax on Rails

接着学习了Ajax on Rails，非常好用的东东，文档并不是很多，简单看了一下，觉得离我的想法还有点距离。我希望是可以实现像Gmail一样，读取一些变量过来，在页面上动态生成元素，而不是读取其它页面并把其中的元素替换掉当前页面上的元素，或者是添加到当前页面上这么简单。我查看过Gmail界面的源代码，好像是使用过混淆器，不过还是可以看出来，它是从服务端读取一些变量，读到客户端再把它转成可视的元素。

微软的space.msn.com在注册时，有一个验证码，当你看不清时可以点击右边的按钮再换一个验证码，这时只会刷新验证码而不用刷新整个页面，这种东西使用Ajax on Rails应该很轻松就可以完成。不过我还不知道在Rails中如何生成验证码呢，应该是使用其它的库来生成吧，有空查一下看看。

3、Ruby and Rails

Ruby的语法对于我这样的初学者(实际上并未正式学习)来说，有些地方理解起来还真有点难，不过它的代码看起来却很舒服，简洁美观，似乎很多语法都是为了美观，当然满篇的end除外。

Rails同样给我简洁美观的印象，使用简单，没有什么废话，视图如果不修改的话，甚至可以不生成出来。

不知道效率如何，不过听说Ruby比Python运行效率要高，豆瓣使用Python能做出来，我想使用Ruby应该也可以做出能够接受的东西。

有空要好好学一下Ruby，为了Rails。

4、asgard

最近实在是太忙了，asgard项目起了个头又懒得动了，许多情况下使用C++都意味着要写很多代码，目前完成了异步回调函数的泛类型匹配，在编写调用函数的适配器时，虽然已经想出了解法，只是要写大量的模板，天天在模板堆里头都是痛的，只好先放一放了。

注：
1、上面提到的“异步回调函数的泛类型匹配”，指的是下面的做法：
void callback (int, short, const char*);
Method , in)> method;
method.async_call ('a', 'b', callback);
由于char可以转型到int, short，而out可以转型到const char*，所以让它支持这种“泛”类型匹配也是理所当然的了，这个东西已经完成了。

2、“调用函数的适配器”是更复杂的一个东西，用在服务器端：
Method >, in)> my_strcat;
my_strcat.setMethod (Adapter , Default<2>, ContainerSize<1>)> (strncat) );

这是最终简化了的形式，比上次所说的简单了不少，因为很多东西是可以推导出来的，这也是测试证明可以实现的，一个简单的修改就是把Adapter从类改为一个函数，由于模板函数的参数类型可以推导出来，所以省去了strncat函数类型的描述。

实际上是把char* strncat(char*, const char*, size_t)匹配给上面这个method，Adapter承担解释角色。

它的函数类型的模板参数中，void可以推导为out，strcat的调用结果赋给out，可以不理会，实际上是使用偏特化来忽略它的，因为我的vector 中根本不包括out这个对象。

后面的Default<1>表示使用默认的转换器，即直接把Buffer对象转成char*类型，由于Buffer中实现了operator T*，这个转换不成问题，下一个是Default<2>，在in中也实现了operator const char*，所以这个转换也很顺利，再下一个是ContainerSize<1>表示从Buffer对象中取容器的大小，这也是个模板。

目前一共实现了3个模板，Default默认转换，Size取sizeof，ContainerSize取容器大小。

写模板既有挑战，又有困难，有时甚至有放弃的想法，甚至有朋友笑话说，人家都动态语言了，你还在使用这种宏一样的语言。我也只好一笑置之，这样的功能在动态语言里多么容易呀，的确在做一种不不明智的事。。。

qiezi 2005-10-08 23:15 发表评论

最近要学习的东西。

qiezi — Wed, 14 Sep 2005 03:24:00 GMT

1、动态语言。
C/C++这类静得可怕的语言，很多方面通常会搭配一个动态一点东西。比如python（已经在项目中使用），ruby（还没学习），lua（看样子不错）。
以下是cpp@codingnow.com中的一点评论：
我一直坚信未来会出现高低搭配的局面，像Java/C#这样的半动不静的中级语言会逐渐“沦为”JVM和CLR上的系统语言，应用开发的任务必将由更加动态的脚本语言承担。目前的Python, Ruby和Lua都有可能。如果从我的角度讲，我希望最后胜出的是Lua，因为Python思维有些混乱，Ruby虽然很纯，但是语言设计过于复杂，只有Lua是符合我的美学观——简单而又强大，这一点跟云风意见一致。
我自己只使用过python，确实可以作为静态语言的补充。

2、要深入学习antlr。
很多时候，编程语言不是领域描述的最佳语言，需要找一个或编写一个转换工具。
antlr可以帮我们实现一个自己语言的词法分析程序，而不需要忍受yacc生成的天书代码。

3、lua和boost::python。
大致看了一下它们包装C＋＋类的方式，有点相似。
我打算做一个C＋＋语言的轻量级分布式包装库，有些地方可以参考。

4、prolog。
满好玩的东西。

qiezi 2005-09-14 11:24 发表评论