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

[D语言] D语言数组

qiezi — Sat, 07 Oct 2006 08:21:00 GMT

先看一段代码：

void main(){
    int[] c = [1,2,3];
    foreach(inout int i; c){
        writef(&i);
        writef(", ");
    }
    writefln("");

    c.length = 2;
    foreach(inout int i; c){
        writef(&i);
        writef(", ");
    }
    writefln("");

    c.length = 3;
    foreach(inout int i; c){
        writef(&i);
        writef(", ");
    }
    writefln("");

    c.length = 4;
    foreach(inout int i; c){
        writef(&i);
        writef(", ");
    }
    writefln("");
}

它输出结果如下：

B7D19FB0, B7D19FB4, B7D19FB8,
B7D19FB0, B7D19FB4,
B7D19FB0, B7D19FB4, B7D19FB8,
B7D1CFA0, B7D1CFA4, B7D1CFA8, B7D1CFAC,

可以看到前3行地址相同，后面一行地址不同。为什么？

D语言的数组分配是内存紧凑的，当减小数组长度减小时，只需要修改切片大小而不需要重新分配。当长度变大时，也会检查原来的缓冲区是否够大，以确定是否需要重新分配空间。注意第2次操作时把长度恢复为原来大小时，并非真的恢复了原来的状态，后面长出来的元素会被初始化为默认值。

再来看一个：

void main(){
    int[] c = [1,2,3];
    int[] d = c;

    foreach(inout int i; c){
        writef(&i);
        writef(", ");
    }
    writefln("");

    foreach(inout int i; d){
        writef(&i);
        writef(", ");
    }
    writefln("");

    d.length = 2;

    foreach(inout int i; c){
        writef(&i);
        writef(", ");
    }
    writefln("");

    foreach(inout int i; d){
        writef(&i);
        writef(", ");
    }
    writefln("");

    d.length = 4;

    foreach(inout int i; c){
        writef(&i);
        writef(", ");
    }
    writefln("");

    foreach(inout int i; d){
        writef(&i);
        writef(", ");
    }
    writefln("");
}

在执行int[] d = c;以后，d的确是和c共享了存储区。不过在改变d的长度以后，它就和c分道扬镳了。所以int[] d = c不能理解为d是一个指向c的引用，它实际上创建了一个新的数组对象，但并不拷贝数组元素，它和int[] d = c[0 .. length]是等价的，都是数组切片操作。

这个问题让我困惑不已。比如你用char[]表示一个单词，用char[][]表示一行，char[][][]表示多行。如何引用这个单词？你当然可以每次使用lines[i][j]，但如果处理步骤很多，这会不会看起来很头大？

看上去应该这样使用：

char[][][] lines;
char[][] line = lines[0];
line.length = line.length + 1;
line[length - 1] = ",";

可惜根据前面的结论，这将无法影响到lines。如果找不到一个引用类型指向数组，有时候使用起来还真是很麻烦。看起来把Line/Word包装成类是个勉强凑合的主意。。。

qiezi 2006-10-07 16:21 发表评论

[D语言] Array slicing

qiezi — Fri, 06 Oct 2006 01:35:00 GMT

数组slicing操作并不复制数据。

指针的slicing操作和数组slicing语意是相同的。

通过slicing生成D数组，比原来直接使用指针的好处是可以有边界检查。

最近刚好犯了这个错误，在使用freetype时，render出来的位图数据直接使用slicing生成数组保存起来。由于slicing并不复制数据，这样后面的render操作会覆盖前面的数据，所以我保存的数组其实都指向同一个缓冲区。当释放face对象时，缓冲区也没了，再访问恐怕要段错误了。

这个是D文档中明确描述了的，我却花了点时间才排除这个错误，写下来记录之～

qiezi 2006-10-06 09:35 发表评论

[D语言] DMD 0.168发布

qiezi — Thu, 05 Oct 2006 01:23:00 GMT

新特性：
1、给委托增加ptr属性，指向委托所绑定的对象。
这是一个语法糖，dg.ptr被转化为cast(void*)dg，它只能作右值，所以除了能读取它以外，在语法上禁止对它赋值。要想把委托绑定到不同的对象，你只能自己实现：

class Foo{
    int foo;
public:
    this(int foo){
        this.foo = foo;
    }

    void bar(){
        writefln(foo);
    }
}

void main(){

    alias void delegate() DG;
    DG dg = &(new Foo(1)).bar;

    Foo[10] foos;
    foreach(int i, inout Foo foo; foos){
        foo = new Foo(i);
    }

    void** ptr = cast(void**)&dg;
    foreach(Foo foo; foos){
        *ptr = cast(void*)foo;
        dg();
    }
}

这种方式也不是我们所希望的，一般来说委托绑定到多个对象时，因为是取到某成员函数指针，再进行绑定。比如模拟一个ActiveSupport所扩展的一个ruby.Array#map用法：

import std.stdio;

class Foo{
    int foo;
public:
    this(int foo){
        this.foo = foo;
    }

    void bar(){
        writefln(foo);
    }
}

class Array(T){
    private:
    T[] data;

    public:
    this(T[] data){
        this.data = data[0 .. length];
    }

    void map(void function() func){
        void delegate() dg;
        void** funcPtr = cast(void**)&dg + 1;
        *funcPtr = func;
        void ** ptr = cast(void**)&dg;
        foreach(T v; data){
            *ptr = cast(void*)v;
            dg();
        }
    }
}

void main(){
    auto arr = new Array!(Foo)([new Foo(1), new Foo(2), new Foo(3)]);
    arr.map(&Foo.bar);
}

是的，delegate内部保存了2个指针，所以我们可以容易地hack它。

[注：上面的main函数中数组直接量赋给栈对象也是这个版本中新增的内容，显然只能用于static对象是很鸡肋的。这里简单带过不提。]

[注：上面这个map的模拟并不是ActiveSupport的map扩展的全部用途，那个map还是收集返回值，这里只演示调用语法。ActiveSupport中扩展的map调用语法是map(&:to_s)，就可以收集到数组中所有元素调用to_s后的返回值。]

2、给内嵌内的实例增加outer属性，指向外层对象。

import std.stdio;

class Outer{
    class Inner{}

    this(){
        Inner inner = new Inner;
        inner.outer.foo();
    }

    void foo(){
        writefln("foo");
    }
}

void main(){
    Outer outer = new Outer;
}

这个特性可能应用并不是很广吧。

3、mixin多个析构函数。

template A(){
    this(){
    }
    ~this(){
        writefln("A::~A()");
    }
}

template B(){
    ~this(){
        writefln("B::~B()");
    }
}

class C{
    mixin A;
    mixin B;
}

void main(){
    C c = new C;
    delete c;
}

这些析构函数会和mixin相反的顺序执行。我不明白的是，为什么不让mixin多个构造函数？为何不让这些构造函数晚于被mixin的类（上面的C类）的构造函数，并按mixin进来的顺序执行？

qiezi 2006-10-05 09:23 发表评论

[D语言] DMD 0.167发布

qiezi — Tue, 19 Sep 2006 12:16:00 GMT

这个版本实现了计划已久的数组直接量。

import std.stdio;

void main(){
  {
    static int[] arr = [1,2,3,4,5];
    writefln(typeid(typeof(arr[0])));
    writefln(arr);
  }
  {
    static float[] arr = [1f,1,3,4,5];
    writefln(typeid(typeof(arr[0])));
    writefln(arr);
  }
  {
    static char[][] arr = ["1","2","3","4","5"];
    writefln(typeid(typeof(arr[0])));
    writefln(arr);
  }
}

数组类型由第1个元素类型决定，类型不匹配将会产生编译错误。

接着是多维数组：

import std.stdio;

void main(){
  static int[][] arr = [[1,2,3,4], [4,5,6], [7,8]];
  foreach(int[] sub; arr){
    foreach(int i; sub){
      writefln(i);
    }
  }
}

另一个特性是更强的typedef。原有的typedef强类型在某些情况下会产生混乱。

下面的代码摘自 http://www.digitalmars.com/pnews/read.php?server=news.digitalmars.com&group=digitalmars.D.bugs&artnum=3843

import std.stdio;

typedef int Int1;
typedef int Int2;

void show(Int1 v) {
     writefln("Int1: %d", v);
}

void show(Int2 v) {
     writefln("Int2: %d", v);
}

void show(int i) {
     writefln("int: %d", i);
}

void show(long l) {
     writefln("long: %d", l);
}

void main() {
     Int1 value1 = 42;
     Int2 value2 = 69;

     show(value1 + value2);
     show(value2 + value1);
     show(2 * value1);
     show(value1 * 2);
     show(value1 + value1);
     show(value2 - value2);
     show(value1 + 2);
     show(3 + value2);

     long l = 23;
     show(value1 + l);
     show(l + value2);

     short s = 105;
     show(s + value1);
     show(value2 + s);
}

如上面代码所示。typedef定义出来的类型和原有类型的相同形式重载函数可以共存，这可以完成更强类型的重载，C＋＋的重载还不能实现这个。

这个强类型的typedef好像原本就支持，大概是运算结果类型比较模糊。

好处是显页易见的。比如有一个Time和TimeInterval类型，它用来表示绝对时间或相对时间间隔；另有一个输出函数用来显示结果。

import std.stdio;
import std.string;

typedef long Time;
typedef long TimeInterval;

void output(Time t){
  writefln("Time: " ~ toString(cast(long)t));
}
void output(TimeInterval t){
  writefln("Interval: " ~ toString(cast(long)t));
}
void main(){
  Time time = cast(Time)100;
  TimeInterval interval = cast(TimeInterval)100;
  output(time);
  output(interval);
}

是的，使用上麻烦了很多，因为我们试图用一个数值类型去表示多个矢量类型。

这里Time time = cast(Time)100不再只是100这个简单的数值，它还携带了Time这个类型。TimeInterval interval = cast(TimeInterval)100也不只是100这个数值，我们给它赋予了时间间隔的含义。

还可以想像得更开阔一些，用它定义时间、长度、面积、加速度、速度、温度等，重载一些计算函数（可惜D还不支持全局操作符重载），这样就方便完成一些物理量的运算了，而且类型得到检查，速度加一个整数值结果还是速度，速度乘时间得到的是长度，时间减时间得到的是时间间隔，速度加时间将产生编译错误。。。。。。神奇的是这些类型可能都是一些简单类型，我相信它至少可以保证运行效率不会太低。当然你用C＋＋类也可以完成这些，并且利用编译器优化让它的效率保持最高，甚至内联的结果就是简单类型的运算，我还是更愿意使用这简单的类型来typedef。当然这可能需要写大量重复的函数重载形式，没有关系，我想使用模板和mixin应该可以简化这一过程，而且会有相当多的家伙们愿意使用这种麻烦的形式来获得更“正确”的编译检查。

所以说，D语言的typedef的意义其实就是实现了矢量类型。

又多想了一点。

强类型要，语法糖也应该要。是不是可以借鉴一下ruby的语法，实现这种调用呢？

Length l = 1.cm;
l = 1.m;
Time t = Time.now;
TimeInterval i = 3.hours;

免去了一些初始化的麻烦。

qiezi 2006-09-19 20:16 发表评论

[D语言] DMD 0.166发布

qiezi — Fri, 01 Sep 2006 14:34:00 GMT

这一版本在强大的民意压力之下取消了上一版的“隐式转换表达式为委托”这一特性，取而代之的是一个lazy关键字。

取消的理由是这个转换太隐晦了，最好是显式地标示出这种转换，所以引入一个lazy关键字。D语言还在发展中，很多特性都在尝试，这种修改也不是第一次了。

首先看看这个lazy。

上一版实现了这样一个特性：

void log(char[] delegate() msg){
writefln(msg());
}

log("Hello, " ~ "Li Jie! \n" ~ "Welcome!");

log的参数被隐式转化为一个委托，这样只有用到这个值的时候才真正求值。

由于这种隐式转化很容易形成陷阱，所以这一版改为一个lazy关键字，看起来要简洁一些了：

void log(lazy char[] msg){
writefln(msg);
}

log("Hello, " ~ "Li Jie! \n" ~ "Welcome!");

log函数中使用msg这个变量就会调用那个隐式的委托，要注意的是每次取msg的值都会执行这个委托，所以我觉得这个陷阱更大了，当然它把陷阱丢给编写代码的人，而不是使用代码的人，所以好坏还无从分辨。

下面这点代码可以演示这个小陷阱：

void foo(lazy int a){
  int b = a+1;
  int c = a*3;
  int d = a/2;
}

int bar(){
  writefln("Call bar()");
  return 12;
}

foo(bar());

看起来bar好像会执行一次，实际上这段代码会打印出3行"Call bar()"，原来使用委托还可以看到一个显式的函数调用呢。

另一个member templates特性未见到文档，猜想大概是支持成员函数模板吧。

qiezi 2006-09-01 22:34 发表评论

[D语言] DMD 0.165发布

qiezi — Mon, 21 Aug 2006 05:24:00 GMT

前几个版本主要是修正BUG，并没有多少新特性，这个版本终于增加了一个“隐式转换表达式到委托”，这个特性也使“懒惰(或延迟)求值”成为可能。

详细信息可见：http://www.digitalmars.com/d/lazy-evaluation.html

它首先解决了一个存在于java中的日志问题，java里面一个写日志标准格式如下：

if (log.isLoggable(Level.INFO)) {
log.info("aaaa");
}

因为log.info的参数求值可能影响性能，所以使用这种繁琐的方式来降低关闭日志时的性能开销。

C/C++使用宏来解决这个问题，唯一的问题是修改日志级别会导致项目必须重编译。

[注：指的是用宏来定义日志级别的方式，使用其它动态修改日志级别的方式对性能要求很高的项目来说可能不可接受]

D语言使用另一种方式来解决，首先要用到“表达式到委托的隐式转换”，下面是委托作为参数时的使用方法：

void foo(char[] delegate() dg){
  writefln(dg());
}

foo( delegate char[] (){
    return "Hello, World";
  }
);

因为这个委托并不需要参数，而返回值可以推导，所以在早先的一个版本里，D允许我们简化这个过程：

void foo(char[] delegate() dg){
writefln(dg());
}

foo({return "Hello, World";});

DMD 0.165允许我们更进一步：

void foo(char[] delegate() dg){
writefln(dg());
}

foo("Hello, World");

这个字符串参数会被隐式转换成一个委托。

现在可以用一样的方法处理日志，在没有宏的系统中，日志函数一般格式如下：

void log(char[] message)
{
if (logging)
fwritefln(logfile, message);
}

为了让它使用懒惰求值这个特性，这里把这个函数的参数改为委托：

void log(char[] delegate() dg)
{
if (logging)
fwritefln(logfile, dg());
}

从上面提到的内容我们知道使用它也很简单：

log("My name is " ~ "Li Jie");

这个参数的求值就是在log函数里面完成的。

当然委托会增加一些开销，在上面这个例子中，这个开销是在日志打开时执行委托所带来的，它增加了一次委托调用的开销，不过好在打开日志功能时，其它方面的开销远大过委托调用。关闭日志时，它不会带来开销，它只是把字符串指针压栈改为委托指针压栈。

qiezi 2006-08-21 13:24 发表评论

[D语言] 用D语言编写Ruby扩展

qiezi — Fri, 18 Aug 2006 22:17:00 GMT

Ruby语言的官方解释程序是使用C语言开发的，一般用C语言来编写扩展。D语言和C语言是二进制兼容的，所以可以使用D语言编写Ruby扩展。

一、移植C库到D的一般过程

C使用头文件来处理符号依赖，在D里面链接外部库文件时，要使用extern (C)声明来引入符号，这是一个转换过程。

如何转换一个C头文件到D文件？D文档的htomodule.html有详尽说明。一般的转换过程如下：

1、运行预处理程序处理掉头文件里面的宏。

2、删除经过预处理以后的多余信息。由于C的头文件包含，每个头文件经过预处理以后都会包含一些重复内容，我们需要剔除这部分内容，通过查找行号即可完成。

3、转换相应声明到D声明，这一步可以使用一个c2h程序来完成。

注意预处理程序处理完毕以后，宏函数以及宏定义的常量会被去除，这可能不是你想要的，所以最好的办法可能是手工转换。

另一种调用是在D里面调用动态链接库，这需要你使用implib工具从动态链接库产生一个.lib导入库文件，然后生成D声明，再编译链接即可。如果是在linux下使用共享库，则只需要编写D声明文件，然后直接链接即可。

二、调用C库

转换完毕以后，就可以调用了。如果你只是要测试一下，就可以只声明使用过的外部函数、变量即可。

例如我们要编写Programming Ruby里面的一个Ruby Extension例子，相应的D代码如下：

// test.d
module test;

import ruby;

extern (C)
VALUE t_init(VALUE self)
{
  VALUE arr = rb_ary_new();
  rb_iv_set(self, " @arr " , arr);
   return self;
}

extern (C)
VALUE t_add(VALUE self, VALUE anObject)
{
  VALUE arr = rb_iv_get(self, " @arr " );
  rb_ary_push(arr, anObject);
   return arr;
}

extern (C){

VALUE cTest;

alias VALUE( * func_type)();

export void Init_Test()
{
  cTest = rb_define_class( " Test " , rb_cObject);
  rb_define_method(cTest, " initialize " , cast(func_type) & t_init, 0 );
  rb_define_method(cTest, " add " , cast(func_type) & t_add, 1 );
}

}   // extern(C)

和C代码很相似。由于我们只使用了几个外部函数、变量，所以只需要声明这几个符号即可：

// ruby.d
module ruby;

extern (C){
    alias ulong VALUE;
    VALUE rb_cObject;
    VALUE rb_ary_new ();
    VALUE rb_ary_push (VALUE, VALUE);
    VALUE rb_iv_set (VALUE,   char * , VALUE);
    VALUE rb_iv_get (VALUE,   char * );
    VALUE rb_define_class ( char * ,VALUE);
     void rb_define_method (VALUE, char * ,VALUE( * )(), int );
}

三、生成动态链接库(Windows DLL)或共享库(Linux so文件)

D语言在Windows上编写DLL，除了要有D源文件以外，还要有DLL定义文件：

// test.def
LIBRARY         Test
DESCRIPTION      ' Test written in D '

EXETYPE  NT
CODE            PRELOAD DISCARDABLE
DATA            PRELOAD SINGLE

这是一个通用的格式，只是一些描述信息，因为D中可以使用export关键字导出符号，所以不需要在这里声明导出函数，只有在编写COM DLL时才会增加其它一些信息。

另外由于D语言要初始化GC以及其它一些信息，所以还需要在DllMain里面调用初始化及终止代码。由于不同平台的初始化过程不完全相同，这里我简单封闭了一下不同平台的初始化代码：

// os/library.d
module os.library;

extern (C){
   void gc_init();
   void gc_term();
  version(Windows) void _minit();
   void _moduleCtor();
   void _moduleDtor();
   void _moduleUnitTests();
  version(linux) void _STI_monitor_staticctor();
  version(linux) void _STI_critical_init();
  version(linux) void _STD_monitor_staticdtor();
  version(linux) void _STD_critical_term();
}

extern (C)
void d_init()
{
   // writefln("Start init D runtime");
  version(linux) _STI_monitor_staticctor();
  version(linux) _STI_critical_init();
  gc_init();
  version(Windows) _minit();
  _moduleCtor();
  _moduleUnitTests();
   // writefln("init finished");
}

extern (C)
void d_fini()
{
   // writefln("Start term D runtime");
  _moduleDtor();
  gc_term();
  version(linux) _STD_critical_term();
  version(linux) _STD_monitor_staticdtor();
   // writefln("term finished");
}

现在可以为Windows编写初始化及终止代码：

// os/dll.d
module os.dll;

private import os.library;
private import std.c.windows.windows;

HINSTANCE g_hInst;

extern (Windows)
BOOL DllMain(HINSTANCE hInstance, ULONG ulReason, LPVOID pvReserved)
{
   switch (ulReason)
  {
     case DLL_PROCESS_ATTACH:
      d_init();
       break ;

     case DLL_PROCESS_DETACH:
      d_fini();
       break ;

     case DLL_THREAD_ATTACH:
     case DLL_THREAD_DETACH:
       // Multiple threads not supported yet
       return false ;
  }
  g_hInst = hInstance;
   return true ;
}

由于Linux共享库并没有标准的入口函数(或是我不知道它)，这里使用gcc扩展的初始、终止代码，不过是以C语言实现的：

// os/so.c
#include < ruby.h >
static void so_init( void ) __attribute__((constructor));
static void so_fini( void ) __attribute__((destructor));

extern void d_init( void );
extern void d_fini( void );

void so_init( void )
{
d_init();
}

void so_fini( void )
{
d_fini();
}

现在可以尝试编译链接，在Linux上编译命令如下：

gcc - o os / so.o - c os / so.c - I / usr / lib / ruby / 1.8 / i686 - linux
gdc - o Test.so test.d os / so.o ruby.d - shared - fPIC - lruby

你可以在irb下测试：

require ' Test '
test = Test. new
test.add( 1 )
test.add( 2 )
test.add( " a " )

可以看到add总是返回一个array，与期望结果一致。

使用gdc是因为dmd在linux上无法生成共享库。

在Windows上的编译命令如下：

dmd - oftest.dll test.d test.def ruby18.lib os / dll.d os / library.d

ruby18.lib是使用implib从msvcrt-ruby18.dll导出的，这个编译过程很顺利，不过不幸的是它运行有一些问题，大概是一些初始值错误，我暂时还没有找到原因。或许也应该尝试一下gdc，不过我不知道如何从.DLL文件导出一个gdc支持的ELF格式的导入库文件。

四、项目打算

打算建立一个rubyd项目，除了转换ruby头文件以外，还要作一些扩展，比如转换D类到ruby类，这方面已有借鉴，比如dsource.org上的pyd项目。

由于以前在建立项目方面有过失败经历(asgard项目由于兴趣转移和其它原因比如语法丑陋等而未能进行)，这次还是保守一些，先完成D声明的转换，我已经使用工具转换了所有头文件，不过正如前面所说，宏函数和宏常量都丢失了，所以需要重新手工转换。

五、其它问题

1、如何从.DLL文件导出一个gdc支持的ELF格式的导入库文件？如果你知道可以告诉我，先谢过了。

2、dmd生成可执行文件问题不大，生成动态链接库或共享库有很大缺陷，特别是不能生成共享库，我可不想再找一个只能再Windows上正常运行的编译器。如何让它改进这些方面？

3、gdc使用dmd前端和gcc后端，应该会成熟一些，不过一般会比dmd前端版本稍低，而且gdc发布版本不是很频繁，大概4-5个dmd版本才会有一个gdc版本(初略计算)，所以一些新特性不能够及时加入进来。

qiezi 2006-08-19 06:17 发表评论

COM接口IDL转换为D接口以及__uuidof实现。

qiezi — Tue, 11 Apr 2006 06:26:00 GMT

D语言里面，可以通过version(Windows)来兼容COM接口，不过对于__uuidof却没有相应实现。

原始COM接口定义类似这样（找个简单的）：

[
    local,
    object,
    uuid(594f31d0-7f19-11d0-b194-00a0c90dc8bf)
]
interface IRpcChannelBuffer2 : IRpcChannelBuffer
{

    HRESULT GetProtocolVersion
    (
        [in,out] DWORD *pdwVersion
    );
}

VC＋＋中可通过__uuidof操作符来获取COM接口中的uuid“元”信息。

转换为D接口后代码如下：

version(Windows) {

interface IRpcChannelBuffer2 : IRpcChannelBuffer
{
HRESULT GetProtocolVersion (DWORD* pdwVersion);
}

}

失去了uuid信息。只要稍作修改，在转换时保存uuid，即可以模板来模拟实现__uuidof操作符。

import std.c.windows.com;
import std.string;
import std.stdio;

private:

template HexStrToUbyte(char[] str)
{
    const ubyte HexStrToUbyte = cast(ubyte)HexStrToUlong!(str);
}

template HexStrToUshort(char[] str)
{
    const ushort HexStrToUshort = cast(ushort)HexStrToUlong!(str);
}

template HexStrToUint(char[] str)
{
    const uint HexStrToUint = cast(uint)HexStrToUlong!(str);
}

template HexStrToUlong(char[] str)
{
    static if (str.length == 1)
        const ulong HexStrToUlong = HexToUbyte!(str[0..1]);
    else
        const ulong HexStrToUlong
            = HexToUbyte!(str[length-1..length])
              + 16UL * HexStrToUlong!(str[0..length-1]);
}

private:

template HexToUbyte(char[] c)
{
    static if (c[0] >= '0' && c[0] <= '9')
        const ubyte HexToUbyte = c[0] - '0';
    else static if (c[0] == 'A' || c[0] == 'a')
        const ubyte HexToUbyte = 0xa;
    else static if (c[0] == 'B' || c[0] == 'b')
        const ubyte HexToUbyte = 0xb;
    else static if (c[0] == 'C' || c[0] == 'c')
        const ubyte HexToUbyte = 0xc;
    else static if (c[0] == 'D' || c[0] == 'd')
        const ubyte HexToUbyte = 0xd;
    else static if (c[0] == 'E' || c[0] == 'e')
        const ubyte HexToUbyte = 0xe;
    else static if (c[0] == 'F' || c[0] == 'f')
        const ubyte HexToUbyte = 0xf;
}

template HexToUbyte_bug(char c)
{
    static if (c >= '0' && c <= '9')
        const ubyte HexToUbyte1 = c - '0';
    else static if (c == 'A' || c == 'a')
        const ubyte HexToUbyte1 = 0xa;
    else static if (c == 'B' || c == 'b')
        const ubyte HexToUbyte1 = 0xb;
    else static if (c == 'C' || c == 'c')
        const ubyte HexToUbyte1 = 0xc;
    else static if (c == 'D' || c == 'd')
        const ubyte HexToUbyte1 = 0xd;
    else static if (c == 'E' || c == 'e')
        const ubyte HexToUbyte1 = 0xe;
    else static if (c == 'F' || c == 'f')
        const ubyte HexToUbyte1 = 0xf;
}

template IIDFromStr(char[] str)
{
    const IID IIDFromStr = {
        HexStrToUint!(str[0..8]),
        HexStrToUshort!(str[9..13]),
        HexStrToUshort!(str[14..18]),
        [
          HexStrToUbyte!(str[19..21]),
          HexStrToUbyte!(str[21..23]),
          HexStrToUbyte!(str[24..26]),
          HexStrToUbyte!(str[26..28]),
          HexStrToUbyte!(str[28..30]),
          HexStrToUbyte!(str[30..32]),
          HexStrToUbyte!(str[32..34]),
          HexStrToUbyte!(str[34..36])
        ]
    };
}

template __uuidof(T:IUnknown)
{
    IID __uuidof = IIDFromStr!("00000000-0000-0000-C000-000000000046");
}

template __uuidof(T:IClassFactory)
{
    IID __uuidof = IIDFromStr!("00000001-0000-0000-C000-000000000046");
}

void main()
{
    IID iu  = __uuidof!(IUnknown);
    IID icp = __uuidof!(IClassFactory);

    writefln(iu.Data1);
    writefln(iu.Data2);
    writefln(iu.Data3);
    writefln(iu.Data4);
}

如上面代码，接口在转换时，把：

[
    local,
    object,
    uuid(594f31d0-7f19-11d0-b194-00a0c90dc8bf)
]
interface IRpcChannelBuffer2 : IRpcChannelBuffer
{

    HRESULT GetProtocolVersion
    (
        [in,out] DWORD *pdwVersion
    );
}

转换为：

template __uuidof(T:IRpcChannelBuffer2)
{
IID __uuidof = IIDFromStr!("594f31d0-7f19-11d0-b194-00a0c90dc8bf");
}
version (Windows) {

interface IRpcChannelBuffer2 : IRpcChannelBuffer {
HRESULT GetProtocolVersion (DWORD* pdwVersion);
}

}

即可，这个可以交由自动化工具完成。

由于__uuidof模板值在编译期决议，没有实际的运行期开销。

qiezi 2006-04-11 14:26 发表评论

C++/D/python性能一比

qiezi — Fri, 31 Mar 2006 03:06:00 GMT

实际上不是全面测试性能。应该这么说：使用一个你熟悉的语言，用它写出一个高效的版本（做下面那件事）。

不小心读到一个帖子：http://blog.vckbase.com/jzhang/archive/2006/03/28/18807.html

看到C＋＋竟然被比下去了，自然不是很舒服，毕竟C＋＋对于C并没有太大的性能上的降低，而python是C写的（指Cpython实现），自然不会高过C。（废话，C基本上接近汇编效率了）

可惜C＋＋又很难找出这么高效的实现，STL效率还是低了些（为什么？一直以为它很高效，用得比较放心）。最近一直比较关注D语言，于是用D语言来测试一下。代码如下：

1 import std.stdio;
2 import std.string;
3 import std.perf;
4
5 int main(char[][] argv)
6 {
7   if (argv.length < 3) {
8     writefln("Wrong arguments");
9     return 1;
10   }
11
12   const int READ_SIZE = 1024;
13
14   FILE* fin = fopen(argv[1], "r");
15   FILE* fout = fopen(argv[2], "w");
16   char buffer[READ_SIZE];
17   int[char[]] emails;
18
19   PerformanceCounter counter = new PerformanceCounter();
20   counter.start();
21   while (!feof(fin)){
22     fgets(cast(char*)buffer, READ_SIZE, fin);
23     char[] email = toString(cast(char*)buffer);
24     if (!(email in emails)){
25       emails[toString(buffer)] = 0;
26       fputs(cast(char*)email, fout);
27     }
28   }
29
30   fclose(fout);
31   fclose(fin);
32   counter.stop();
33
34   writefln(counter.milliseconds());
35   return 0;
36 }
37

没加fopen失败处理。

测试结果在我的机器上耗时只有python版本的1/3，我看到其它网友的C＋＋实现最好成绩也不过1/2，由于是D是C语言所写，测试使用的又是C库，自然可以认为C语言还是比较高效的。

上面的D语言代码里调用了toString，把char*转为char[]，它的源代码如下：

char[] toString(char *s)
{
return s ? s[0 .. strlen(s)] : cast(char[])null;
}

如果s[0 .. strlen(s)]产生了复制的话，应该是会影响性能的。char[]对象是受GC管理的，应该会复制一份。这种情况下还能有如此高的效率，的确很不错。

不过python的性能让我感觉很吃惊，以前只测试过字符串连接，感觉比较高效。

写了一个完成一样功能的ruby程序，耗时接近python版本的2倍，当然由于对它不是很熟，可能写得不够高效。

1 emails = Hash.new
2
3 start = Time.now
4 fout = open('email-2-new1.txt', 'w')
5 open('email-2.txt').each do |line|
6   if !emails.has_key? line
7     emails[line] = 0
8     fout << line
9   end
10 end
11 puts Time.now - start
12

正如某网友所说，这个程序的瓶颈在于IO，拿来作性能上的比较或许是不合适的。从语言效率上来讲，自然是C++和D相当，可能会比D高，python应该会低很多。但在很多情况下，衡量效率不光是语言本身，还有库，没有库的语言是没什么吸引力的。python是一种很“慢”的语言，相对C/C＋＋来说，不过它是一门实用性的语言，所以它为一些特定用法做了优化，取得了不错的成绩。C＋＋是一门通用语言，或许太注重语言的性能了，忽略了库，导致库把性能给拉下来了。这种情况下，有人评测java和C＋＋的性能，结果是java要高，自然是不那么让人惊奇的了。可是如果标准库都这么慢，那还能指望什么呢？

当然也并没有证明STL就特别慢，也可能是使用不正确。

只是刚好看到这个比较，忍不住参与一下，切勿当真。

qiezi 2006-03-31 11:06 发表评论

[转] digitalmars.D上的一个建议。

qiezi — Tue, 28 Mar 2006 02:31:00 GMT

标题：Proposal: Operator overloading without temporaries
作者：Don Clugston

正文：
Background: Operator overloading, in the form it exists in C++ and
currently in D, inherently results in sub-optimal code, because it
always results in unnecessary temporary objects being created.

For example,
X = A - ((B*C) + D)* E;

becomes:
T1 = B * C;
T2 = T1 + D;
T3 = T2 * E;
T4 = A - T3;
X = T4;
Four objects were created, whereas only one was strictly required.
In C++, there are libraries like Blitz++ which use complicated
expression templates in order to avoid these creating these temporaries,
and provide performance comparable with FORTRAN. I think D can do much
better...
Note that temporaries are avoided when using the opXXXAssign() operators
like +=.

===========
   Proposal
===========
(1) Allow the compiler to assume that b = b + c can be replaced with b
+= c. (In C++, operator + and operator += are just symbols, the compiler
doesn't know that there is any relationship between them).
In the example above, this would allow the compiler to generate:
T1 = B * C;
T1 += D;
T1 *= E;

and we have eliminated two of the three temporaries.
(2). Fill in the gaps in the operator overloading table by introducing
opAddAssign_r, opSubAssign_r, etc.

Just as A.opSubAssign(B)
is the operation A -= B or equivalently A = A - B, similarly

A.opSubAssign_r(B)
would mean
A = B - A.
and would only occur when temporaries are generated in expressions. Like
-=, it's an operation which can frequently be performed very
efficiently, but at present the language has no way of expressing it.

Our original example then becomes:

T1 = B.opMul(C);
T1.opAddAssign(D);
T1.opMulAssign(E);
T1.opSubAssign_r(A);
X = T1;
... and all the useless temporaries are gone!

More formally, when the expression tree for an expression is generated:
With a binary operator XXX, operating on left & right nodes:

if (the left node is *not* an original leaf node) {
    // the left node is a temporary, does not need to be preserved.
    // we don't care if the right node is a temporary or not
    look for opXXXAssign().
} else if (the the right node is not an original leaf node) {
    // the right node is a temporary
    look for opXXXAssign_r()
} else {
   // both left and right nodes are leaf nodes, we have to
   // create a temporary
    look for opXXX(), just as it does now.
}

These rules also cope with the situation where temporaries are required:
eg
X = (A*B) + (C*D);
becomes
T1 = A*B;
T2 = C*D;
T1 += T2;
X = T1;

If this were implemented, it would permanently eradicate (for D) the
most significant advantage which Fortran has managed to retain over
object-oriented languages. And I really don't think it would be
difficult to implement, or have negative side-effects.

There are a couple of decisions to be made:
(I) should the compiler use opAdd() and generate a temporary, if
opAddAssign_r() doesn't exist, to preserve existing behaviour? I think
the answer to this is YES.
(II) should the compiler use opAdd() and generate a temporary, if
oppAddAssign() doesn't exist, to preserve existing behaviour? Again, I'm
inclined to answer YES.
(III) If the code includes +=, and there is an opAdd() but no
opAddAssign(), should the compiler accept this, and just generate an
opAdd() followed by an assignment?? This would mean that opAdd() would
generate the += operation as well as +, while opAddAssign() would be a
performance enhancement. (It would still be possible to have
opAddAssign() without opAdd(), to have += but not +, but it would not be
possible to have + without +=). This would mean that += would be
*purely* syntactic sugar.

Decision III would be a little more difficult to implement and is of
less obvious merit, I only mention it as a possibility.

Comments?

qiezi 2006-03-28 10:31 发表评论

D语言模板最近的一些改进

qiezi — Wed, 15 Mar 2006 09:03:00 GMT

不知道什么时候加入了“函数模板参数类型推导”和“类模板（改进型）”，文档中也是悄悄出现了。

函数模板参数类型推导：

template Square(T)
{
    T Square(T t)
    {
	return t * t;
    }
}

以前调用时必须显式实例化：

writefln("The square of %s is %s", 3, Square!(int)(3));

现在可以使用自动推导了：

writefln("The square of %s is %s", 3, Square(3));  // T is deduced to be int


类模板以前必须这样写：
template Bar(T)
{
    class Bar
    {
	T member;
    }
}

现在可以写为：
class Bar(T)
{
    T member;
}

含义相同。

qiezi 2006-03-15 17:03 发表评论

从C＋＋到D

qiezi — Tue, 14 Mar 2006 04:10:00 GMT

摘要: 从http://www.digitalmars.com/d/cpptod.html摘录 1、构造函数： c++: Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->1 class Foo2 {3 &nbs... 阅读全文

qiezi 2006-03-14 12:10 发表评论

DMD 0.149发布

qiezi — Wed, 08 Mar 2006 03:36:00 GMT

最近3个版本增加/移除了一些新特性。

0.147中加入了match表达式，不过感觉用处太小了点，果然0.148中又去掉了。
0.148中去掉了bit类型，增加了BitArray类和bool基本类型。on_scope语句算是个比较重要的更新，可用于在代码块结束、异常、成功执行时，完成特定功能。
0.149中on_scope语句改成了scope(...)。

qiezi 2006-03-08 11:36 发表评论

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 发表评论