色青青草原桃花久久综合,久久国产精品99精品国产,99久久这里只有精品

[D语言] D语言数组

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

先看一�D�代码：

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,

可以看到�?行地址相同�Q�后面一行地址不同。�ؓ什么？

D语言的数�l�分配是内存紧凑的，当减��数�l�长度减��时�Q�只需要修改切片大��而不需要重新分配。当长度变大�Ӟ��也会��查原来的�~�冲区是否够大，以确定是否需要重新分配空间。注意第2�ơ操作时把长度恢复�ؓ原来大小�Ӟ��q��真的恢复了原来的状态，后面长出来的元素会被初始化�ؓ默认倹{�?br />
再来看一个：

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;以后�Q�d的确是和c�׃�n了存储区。不�q�在改变d的长度以后，它就和c分道扬镳了。所以int[] d = c不能理解为d是一个指向c的引用，它实际上创徏了一个新的数�l�对象，但�ƈ不拷贝数�l�元素，它和int[] d = c[0 .. length]是等��L��Q�都是数�l�切片操作�?br />
�q�个问题让我困惑不已。比如你用char[]表示一个单词，用char[][]表示一行，char[][][]表示多行。如何引用这个单词？你当然可以每�ơ��用lines[i][j]�Q�但如果处理步骤很多�Q�这会不会看��h��很头大？

看上��d��该这样��用：

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

可惜�Ҏ��前面的结论，�q�将无法影响到lines。如果找不到一个引用类型指向数�l�，有时候��用�v来还真是很麻烦。看��h��把Line/Word包装成类是个勉强凑合的主意。。�?img src ="http://m.shnenglu.com/cpunion/aggbug/13418.html" width = "1" height = "1" />

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

[D语言] Array slicing

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

数组slicing操作�q�不复制数据�?br />
指针的slicing操作和数�l�slicing语意是相同的�?br />
通过slicing生成D数组�Q�比原来直接使用指针的好处是可以有边界检查�?br />
最�q�刚好犯了这个错误，在��用freetype�Ӟ��render出来的位图数据直接��用slicing生成数组保存��h��。由于slicing�q�不复制数据�Q�这样后面的render操作会覆盖前面的数据�Q�所以我保存的数�l�其实都指向同一个缓冲区。当释放face对象�Ӟ��~�冲��Z��没了�Q�再讉K��恐怕要�D�错误了�?br />
�q�个是D文档中明��描�q�C��的，我却�׃��Ҏ��间才排除�q�个错误�Q�写下来记录之～

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

[D语言] DMD 0.168发布

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

新特性：
1、给委托增加ptr属性，指向委托所�l�定的对象�?br />�q�是一个语法糖�Q�dg.ptr被�{化�ؓcast(void*)dg�Q�它只能作右��|��所以除了能��d��它以外，在语法上��止对它赋倹{��要��x��委托�l�定��C��同的对象�Q�你只能自己实现�Q?br />

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();
    }
}

�q�种方式也不是我们所希望的，一般来说委托绑定到多个对象�Ӟ��因�ؓ是取到某成员函数指针�Q�再�q�行�l�定。比如模拟一个ActiveSupport所扩展的一个ruby.Array#map用法�Q?br />

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);
}

是的�Q�delegate内部保存�?个指针，所以我们可以容易地hack它�?br />
[注：上面的main函数中数�l�直接量赋给栈对象也是这个版本中新增的内容，昄��只能用于static对象是很鸡肋的。这里简单带�q�不提。]

[注：上面�q�个map的模拟�ƈ不是ActiveSupport的map扩展的全部用途，那个map�q�是攉��q�回��|��q�里只演�C��用语法。ActiveSupport中扩展的map调用语法是map(&:to_s)�Q�就可以攉��到数�l�中所有元素调用to_s后的�q�回倹{��]

2、给内嵌内的实例增加outer属性，指向外层对象�?br />

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;
}

�q�个�Ҏ��可能应用�ƈ不是很广吧�?br />
3、mixin多个析构函数�?br />

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;
}

�q�些析构函数会和mixin相反的顺序执行。我不明白的是，��Z��么不让mixin多个构造函敎ͼ��Z��不让�q�些构造函数晚于被mixin的类�Q�上面的C�c�）的构造函敎ͼ��q�按mixin�q�来的顺序执行？

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

[D语言] DMD 0.167发布

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

�q�个版本实现了计划已久的数组直接量�?br />

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);
  }
}

数组�c�d��q��1个元素类型决定，�c�d��不匹配将会��生编译错误�?br />
接着是多�l�数�l�：

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强类型在某些情况下会产生混�ؕ�?br />
下面的代码摘�?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);
}

如上面代码所�C�。typedef定义出来的类型和原有�c�d��的相同�Ş式重载函数可以共存，�q�可以完成更强类型的重蝲�Q�C�Q�＋的重载还不能实现�q�个�?br />
�q�个强类型的typedef好像原本��支持，大概是运��结果类型比较模�p��?br />
好处是显��|��见的。比如有一个Time和TimeInterval�c�d��Q�它用来表示�l�对旉��或相�Ҏ��间间隔；另有一个输出函数用来显�C�结果�?br />

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);
}

是的�Q��用上�ȝ��了很多，因�ؓ我们试图用一个数值类型去表示多个矢量�c�d��?br />
�q�里Time time = cast(Time)100不再只是100�q�个��单的数��|��它还携带了Time�q�个�c�d��。TimeInterval interval = cast(TimeInterval)100也不只是100�q�个数��|��我们�l�它赋予了时间间隔的含义�?br />
�q�可以想像得更开阔一些，用它定义旉��、长度、面�U�、加速度、速度、温度等�Q�重载一些计��函敎ͼ�可惜D�q�不支持全局操作�W�重载）�Q�这样就方便完成一些物理量的运��了�Q�而且�c�d��得到��查，速度加一个整数值结果还是速度�Q�速度乘时间得到的是长度，旉��减时间得到的是时间间隔，速度加时间将产生�~�译错误。。。。。。神奇的是这些类型可能都是一些简单类型，我相信它臛_��可以保证�q�行效率不会太低。当然你用C�Q�＋�c�M��可以完成�q�些�Q��ƈ且利用编译器优化让它的效率保持最高，甚至内联的结果就是简单类型的�q�算�Q�我�q�是更愿意��用这��单的�c�d��来typedef。当然这可能需要写大量重复的函数重载�Ş式，没有关系�Q�我想��用模板和mixin应该可以��化这一�q�程�Q�而且会有相当多的家伙们愿意��用这�U�麻烦的形式来获得更“正��”的�~�译��查�?br />

所以说�Q�D语言的typedef的意义其实就是实��C��矢量�c�d��?br />

又多想了一炏V�?br />
强类型要�Q�语法糖也应该要。是不是可以借鉴一下ruby的语法，实现�q�种调用呢？

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

免去了一些初始化的麻烦�?br />

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

[D语言] DMD 0.166发布

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

�q�一版本在强大的民意压力之下取消了上一版的“隐式�{换表辑ּ�为委托”这一�Ҏ��，取而代之的是一个lazy关键字�?br />
取消的理由是�q�个转换太隐晦了�Q�最好是昑ּ�地标�C�出�q�种转换�Q�所以引入一个lazy关键字。D语言�q�在发展中，很多�Ҏ��都在尝试，�q�种修改也不是第一�ơ了�?br />
首先看看�q�个lazy�?br />
上一版实��C��q�样一个特性：

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

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

log的参数被隐式转化��Z��个委托，�q�样只有用到�q�个值的时候才真正求倹{�?br />
�׃��q�种隐式转化很容易�Ş成陷阱，所以这一版改��Z��个lazy关键字，看�v来要��z�一些了�Q?br />

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

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

log函数中��用msg�q�个变量��׃��调用那个隐式的委托，要注意的是每�ơ取msg的值都会执行这个委托，所以我觉得�q�个陷阱更大了，当然它把陷阱丢给�~�写代码的�h�Q�而不是��用代码的人，所以好坏还无从分��L�?br />
下面�q�点代码可以演示�q�个��陷阱：

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());

看�v来bar好像会执行一�ơ，实际上这�D�代码会打印�?�?Call bar()"�Q�原来��用委托还可以看到一个显式的函数调用呢�?br />
另一个member templates�Ҏ��未见到文��Q�猜惛_��概是支持成员函数模板吧�?br />

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

[D语言] DMD 0.165发布

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

前几个版本主要是修正BUG�Q��ƈ没有多少新特性，�q�个版本�l�于增加了一个“隐式�{换表辑ּ�到委托”，�q�个�Ҏ��也低쀜懒�?或�g�q?求值”成为可能�?br />
详细信息可见�Q?a >http://www.digitalmars.com/d/lazy-evaluation.html

它首先解决了一个存在于java中的日志问题�Q�java里面一个写日志标准格式如下�Q?br />

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

因�ؓlog.info的参数求值可能媄响性能�Q�所以��用这�U�繁琐的方式来降低关闭日志时的性能开销�?br />
C/C++使用宏来解决�q�个问题�Q�唯一的问题是修改日志�U�别会导致项目必��重�~�译�?br />
[注：指的是用宏来定义日志�U�别的方式，使用其它动态修�Ҏ��志��别的方式�Ҏ��能要求很高的项目来说可能不可接受]

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

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

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

因�ؓ�q�个委托�q�不需要参敎ͼ�而返回值可以推��|��所以在早先的一个版本里�Q�D允许我们��化这个过�E�：

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

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

DMD 0.165允许我们更进一步：

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

foo("Hello, World");

�q�个字符串参��C��被隐式�{换成一个委托�?br />
现在可以用一��L��Ҏ��处理日志�Q�在没有宏的�pȝ��中，日志函数一般格式如下：

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

��Z��让它使用懒惰求��D��个特性，�q�里把这个函数的参数改�ؓ委托�Q?br />

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

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

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

�q�个参数的求值就是在log函数里面完成的�?br />
当然委托会增加一些开销�Q�在上面�q�个例子中，�q�个开销是在日志打开时执行委托所带来的，它增加了一�ơ委托调用的开销�Q�不�q�好在打开日志功能�Ӟ��其它斚w��的开销�q�大�q�委托调用。关闭日志时�Q�它不会带来开销�Q�它只是把字�W�串指针压栈改�ؓ委托指针压栈�?img src ="http://m.shnenglu.com/cpunion/aggbug/11517.html" width = "1" height = "1" />

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

[D语言] 用D语言�~�写Ruby扩展

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

Ruby语言的官方解释程序是使用C语言开发的�Q�一般用C语言来编写扩展。D语言和C语言是二�q�制兼容的，所以可以��用D语言�~�写Ruby扩展�?br />

一、移植C库到D的一般过�E?/strong>

C使用头文件来处理�W�号依赖�Q�在D里面链接外部库文件时�Q�要使用extern (C)声明来引入符��P��q�是一个�{换过�E��?/p>
如何转换一个C头文件到D文�g�Q�D文档的htomodule.html有详��说明。一般的转换�q�程如下�Q?

1、运行预处理�E�序处理掉头文�g里面的宏�?/p>
2、删除经�q�预处理以后的多余信息。由于C的头文�g包含�Q�每个头文�g�l�过预处理以后都会包含一些重复内容，我们需要剔除这部分内容�Q�通过查找行号卛_��完成�?/p>
3、�{换相应声明到D声明�Q�这一步可以��用一个c2h�E�序来完成�?/p>
注意预处理程序处理完毕以后，宏函��C��及宏定义的常量会被去除，�q�可能不是你惌��的，所以最好的办法可能是手工�{换�?/p>
另一�U�调用是在D里面调用动态链接库�Q�这需要你使用implib工具从动态链接库产生一�?lib导入库文�Ӟ��然后生成D声明�Q�再�~�译链接卛_��。如果是在linux下��用共享库�Q�则只需要编写D声明文�g�Q�然后直接链接即可�?br />

二、调用C�?/strong>

转换完毕以后�Q�就可以调用了。如果你只是要测试一下，��可以只声明使用�q�的外部函数、变量即可�?/p>
例如我们要编写Programming Ruby里面的一个Ruby Extension例子�Q�相应的D代码如下�Q?/p>
// 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代码很相伹{��由于我们只使用了几个外部函数、变量，所以只需要声明这几个�W�号卛_��Q?/p>
// 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文�g)

D语言在Windows上编写DLL�Q�除了要有D源文件以外，�q�要有DLL定义文�g�Q?/p>
// test.def
LIBRARY         Test
DESCRIPTION      ' Test written in D '

EXETYPE  NT
CODE            PRELOAD DISCARDABLE
DATA            PRELOAD SINGLE

�q�是一个通用的格式，只是一些描�q�C��息，因�ؓD中可以��用export关键字导出符��P��所以不需要在�q�里声明导出函数�Q�只有在�~�写COM DLL时才会增加其它一些信息�?/p>
另外�׃��D语言要初始化GC以及其它一些信息，所以还需要在DllMain里面调用初始化及�l�止代码。由于不同��^台的初始化过�E�不完全相同�Q�这里我��单封闭了一下不同��^台的初始化代码：

// 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�~�写初始化及�l�止代码�Q?/p>
// 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�׃�n库�ƈ没有标准的入口函�?或是我不知道�?�Q�这里��用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();
}

现在可以��试�~�译链接�Q�在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��L��q�回一个array�Q�与期望�l�果一致�?/p>
使用gdc是因为dmd在linux上无法生成共享库�?/p>
在Windows上的�~�译命��o如下�Q?/p>
dmd - oftest.dll test.d test.def ruby18.lib os / dll.d os / library.d

ruby18.lib是��用implib从msvcrt-ruby18.dll导出的，�q�个�~�译�q�程很顺利，不过不幸的是它运行有一些问题，大概是一些初始值错误，我暂时还没有扑ֈ�原因。或�怹�应该��试一下gdc�Q�不�q�我不知道如何从.DLL文�g导出一个gdc支持的ELF格式的导入库文�g�?br />

四、项目打��?/strong>

打算建立一个rubyd��目�Q�除了�{换ruby头文件以外，�q�要作一些扩展，比如转换D�c�d��ruby�c�，�q�方面已有借鉴�Q�比如dsource.org上的pyd��目�?/p>
�׃��以前在徏立项目方面有�q�失败经�?asgard��目�׃��兴趣转移和其它原因比如语法丑陋等而未能进�?�Q�这�ơ还是保守一些，先完成D声明的�{换，我已�l��用工兯��{换了所有头文�g�Q�不�q�正如前面所��_��宏函数和宏常量都丢失了，所以需要重新手工�{换�?br />

五、其它问�?/strong>

1、如何从.DLL文�g导出一个gdc支持的ELF格式的导入库文�g�Q?strong>如果你知道可以告诉我�Q�先谢过了�?/p>
2、dmd生成可执行文仉��题不大，生成动态链接库或共享库有很大缺��P��特别是不能生成共享库�Q�我可不惛_��找一个只能再Windows上正常运行的�~�译器。如何让它改�q�这些方面？

3、gdc使用dmd前端和gcc后端�Q�应该会成熟一些，不过一般会比dmd前端版本�E�低�Q�而且gdc发布版本不是很频�J�，大概4-5个dmd版本才会有一个gdc版本(初略计算)�Q�所以一些新�Ҏ��不能够及时加入�q�来�?/p>

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

qiezi — Tue, 11 Apr 2006 06:26:00 GMT
D语言里面�Q�可以通过version(Windows)来兼容COM接口�Q�不�q�对于__uuidof却没有相应实现�?br />
原始COM接口定义�c�M��q�样�Q�找个简单的�Q�：

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

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

VC�Q�＋中可通过__uuidof操作�W�来获取COM接口中的uuid“元”信息�?br />
转换为D接口后代码如下：

version(Windows) {

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

}

失去了uuid信息。只要稍作修改，在�{换时保存uuid�Q�即可以模板来模拟实现__uuidof操作�W��?br />
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);
}

如上面代码，接口在�{换时�Q�把�Q?br />
[
    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);
}

}

卛_��Q�这个可以交��p��动化工具完成�?br />
�׃��__uuidof模板值在�~�译期决议，没有实际的运行期开销�?img src ="http://m.shnenglu.com/cpunion/aggbug/5283.html" width = "1" height = "1" />

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

qiezi — Fri, 31 Mar 2006 03:06:00 GMT
实际上不是全面测试性能。应该这么说�Q��用一个你熟悉的语�a��Q�用它写��Z��个高效的版本�Q�做下面那�g事）�?br />
不小心读��C��个帖子：http://blog.vckbase.com/jzhang/archive/2006/03/28/18807.html

看到C�Q�＋竟然被比下去了，自然不是很舒服，毕竟C�Q�＋对于C�q�没有太大的性能上的降低�Q�而python是C写的�Q�指Cpython实现�Q�，自然不会高过C。（废话�Q�C基本上接�q�汇�~�效率了�Q?br />
可惜C�Q�＋又很难找��么高效的实现�Q�STL效率�q�是低了些（��Z��么？一直以为它很高效，用得比较攑ֿ��Q�。最�q�一直比较关注D语言�Q�于是用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��p�|处理�?br />
��试�l�果在我的机器上耗时只有python版本�?/3�Q�我看到其它�|�友的C�Q�＋实现最好成�l�也不过1/2�Q�由于是D是C语言所写，��试使用的又是C库，自然可以认�ؓC语言�q�是比较高效的�?br />
上面的D语言代码里调用了toString�Q�把char*转�ؓchar[]�Q�它的源代码如下�Q?br />
char[] toString(char *s)
{
    return s ? s[0 .. strlen(s)] : cast(char[])null;
}

如果s[0 .. strlen(s)]产生了复制的话，应该是会影响性能的。char[]对象是受GC��理的，应该会复制一份。这�U�情况下�q�能有如此高的效率，的确很不错�?br />
不过python的性能让我感觉很吃惊，以前只测试过字符串连接，感觉比较高效�?br />
写了一个完成一样功能的ruby�E�序�Q�耗时接近python版本�?倍，当然�׃��对它不是很熟�Q�可能写得不够高效�?br />
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

正如某网友所��_��q�个�E�序的瓶颈在于IO�Q�拿来作性能上的比较或许是不合适的。从语言效率上来�Ԍ��自然是C++和D相当�Q�可能会比D高，python应该会低很多。但在很多情况下�Q�衡量效率不光是语言本��n�Q�还有库�Q�没有库的语�a�是没什么吸引力的。python是一�U�很“慢”的语言�Q�相对C/C�Q�＋来说�Q�不�q�它是一门实用性的语言�Q�所以它��Z��些特定用法做了优化，取得了不错的成�W。C�Q�＋是一门通用语言�Q�或许太注重语言的性能了，忽略了库�Q�导致库把性能�l�拉下来了。这�U�情况下�Q�有��java和C�Q�＋的性能�Q�结果是java要高�Q�自然是不那么让人惊奇的了。可是如果标准库都这么慢�Q�那�q�能指望什么呢�Q?br />
当然也�ƈ没有证明STL��q��别慢�Q�也可能是��用不正确�?br />

只是刚好看到�q�个比较�Q�忍不住参与一下，切勿当真�?br />

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

qiezi — Tue, 28 Mar 2006 02:31:00 GMT
标题�Q?font face="Arial" size="-1">Proposal: Operator overloading without temporaries
作者：Don Clugston

正文�Q?br />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 发表评论

qiezi — Wed, 15 Mar 2006 09:03:00 GMT
不知道什么时候加入了“函数模板参数类型推导”和“类模板�Q�改�q�型�Q�”，文��中也是悄悄出��C��?br>
函数模板参数�c�d��推导�Q?br>
template Square(T)
{
T Square(T t)
{
return t * t;
}
}
以前调用时必��L��式实例化�Q?br>
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

�c�L��板以前必��这样写�Q?br>template Bar(T)
{
class Bar
{
T member;
}
}

现在可以写�ؓ�Q?br>class Bar(T)
{
T member;
}

含义相同�?br>

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

从C�Q�＋到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
最�q?个版本增�?�U�除了一些新�Ҏ��?BR>
0.147中加入了match表达式，不过感觉用处太小了点�Q�果�?.148中又��L��了�?BR>0.148中去掉了bit�c�d��Q�增加了BitArray�c�d��bool基本�c�d��。on_scope语句��是个比较重要的更新�Q�可用于在代码块�l�束、异常、成功执行时�Q�完成特定功能�?BR>0.149中on_scope语句�Ҏ��了scope(...)�?img src ="http://m.shnenglu.com/cpunion/aggbug/3888.html" width = "1" height = "1" />

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代码覆盖分析器”应该是很多人感兴趣的东西了�Q�下面是一个例�?摘自http://digitalmars.com/d/code_coverage.html)�Q?/P>
/* 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
�l�果如下�Q?BR>
       |/* 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);
}
�~�译执行�l�果如下�Q?BR>
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.

比较感兴��的是��Q�Ҏ��和字�W�串帔R��作�ؓ模板值参敎ͼ��单测试了一下：

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);
}

�~�译通过�Q�运行结果如下：

3.14
hello

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

DMDScript脚本工具�Q�DDL��目

qiezi — Sat, 19 Nov 2005 16:20:00 GMT
DMDScript是Digital Mars提供的一个符合ECMA 262规范的脚本语�a��Q�采用D语言�~�写�Q�开放源代码�Q�可以从http://www.digitalmars.com/dscript看到详细信息�Q�另外有一个C++的实现版本�?BR>
另外2个符合ECMA 262规范的脚本语�a�分别是Netscape的javascript和Microsoft的JScript�Q�目前DMDScript和其�?个不完全兼容�Q�不�q�效率要高一些。DMDScript提供了一个简单的��试�Q�生�?190以内的质敎ͼ��q�代10�ơ，在我的机器上�Q�javascript执行耗时566毫秒�Q�DMDScript执行耗时188毫秒�Q�整整快�?倍�?BR>
如果你想实现一个符合ECMA 262标准的脚本语�a��Q�徏议看�q�䆾代码的实现吧�Q�比较简�z�，只有400多K。微软那份估计是很难看到了，Netscape那䆾用C写的�Q�代码大��就有近3M�Q�宏也比较多�Q�看��h��要吃力一些�?BR>

DDL是dsource.org上的一个有��的��目�Q�它可以�?obj�?lib文�g中加载代码�ƈ执行�Q�目前支持COFF、OMF、ELF格式�?img src ="http://m.shnenglu.com/cpunion/aggbug/1200.html" width = "1" height = "1" />

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

qiezi — Fri, 11 Nov 2005 09:13:00 GMT
D语言的模板��用非常方便灵�z�，受够了C�Q�＋模板�~�写之苦的同学们可以感受一下D语言的模板，下面先展�C�Z��个D语言�~�写的多分派委托�c�，在我的旧BLOG上曾�l�写�q�一个C�Q�＋版本的，整个�q�程感觉非常痛苦。。�?BR>
闲话��说�Q�请看代码：

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);
}

非常�q�净�Q�非常简�z�，不是吗？�q�个只花了我10分钟旉��来写。。�?BR>
D语言的委托非帔R��效，有兴��的可以��试一下通过委托和直接调用之间的性能差别。上面这个自己实现的多分�z�֧�托类�Q�效率也非常高，我的��试�l�果是对于性能的媄响几乎可以忽略。想起那个历��千辛万苦实现的C�Q�＋多分�z�֧�托类�Q�实现复杂、调试费时、运行效率还很低�Q�每每一惛_��q�心里那个难受啊。。。�?BR>
再来看一下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; // �~�译错误
}

同样很漂亮�?BR>
如果你觉得提�C�Z��息不够友好，可以修改为：

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

�q�是�~�译时的错误提示�Q?BR>
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�Q�支持错误输出，�q�样��׃��用写重复的语句了�Q�可以简化成�q�样�Q?BR>
template XXX (int v)
{
    int n = v;
    static if (v <= 3)
        pragma (error, "template value must > 3");
}

�q�样看�v来更好。不�q�目前有很多重要�Ҏ��要实现�Q�这�U�玩意可能要很久以后才会加入了�?img src ="http://m.shnenglu.com/cpunion/aggbug/1083.html" width = "1" height = "1" />

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

qiezi — Fri, 11 Nov 2005 04:16:00 GMT
     摘要: �q�是一个从C�U�L��到D的代码，原文误��“Embed an HTML control in your own window using plain C”，它用C�l�构模拟了虚表，�q�且实现了多个接口以完成对Web Browser控�g的调用。在看完他的代码之后�Q�我对于COM/OLE的了解加�׃��一些，以前使用VC做过COM斚w��的应用，也看�q�不��COM斚w��的书�Q�不�q�没有涉及到界面�Q�所以一直不知道如何把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");
}

在上面的例子里，�E�序在test函数中的输出语句��输出：
0
1
0
也就是说�Q�out参数取值是无意义的�Q�它只用于赋倹{�?BR>
�q�里有一个很大的问题�Q�调用test(a,b,c)�Ӟ��调用者对于c的��D��改变可能毫无知觉�Q�甚��x��为隐藏很��q��BUG。对此，许多人徏议加强检查，比如在调用时�Q�必��L��明inout/out�Q?BR>
test(a, inout b, out c);

��g��能够起到一些警�C�Z��用，不过�q�样一来，语法上倒不怎么��l�了�?img src ="http://m.shnenglu.com/cpunion/aggbug/1044.html" width = "1" height = "1" />

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

qiezi — Thu, 10 Nov 2005 04:12:00 GMT
v0.138 实现了字�W�串直接切片调用�Q?BR>
    char[] a = "abcde"[2..3];
    writefln(a);
    char b = "abcde"[3];
    writefln(b);

另外修复了一些编译器和文��生成的BUG�?BR>
v0.137的重要更新有�Q?BR>隐式�c�d��引用�Q?BR>
auto c = "abcde";  // c变量自动获得�c�d��char[]
extern(linkage)在内嵌函��C��使用

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

其它更新则主要集中于�~�译器工作、文��工兗��库�{�，暂时�q�没有特别��o人兴奋的�Ҏ��加入进来，比如�Q�stack tracing, relation api�{��?img src ="http://m.shnenglu.com/cpunion/aggbug/1039.html" width = "1" height = "1" />

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

qiezi — Wed, 02 Nov 2005 08:35:00 GMT
1、去掉了丑陋的宏�?BR>C/C++中的宏是很��o人厌烦的�Q�D不允许再使用它�?BR>
2、好用的字符串常量表辑ּ��?BR>除了�c�C的��用双引号的字�W�串帔R��表达式以外，�q�可以��用`字符。可以��用x"68 65 6C6C 6F"来表�C?hello"�Q�r"ab\na"则忽略字�W�串帔R��中�{义字�W�的转义作用�Q�还可以在字�W�串帔R��后加上c, w或d来指�C�字�W�串帔R��是char[]�c�d��、wchar[]�c�d��q�是dchar[]�c�d��。可以��用~�q�算�W�连�?个字�W�串�?BR>
3、数字�?BR>数字可以直接使用�Q�还可以�q�样来定义：int a = 3_029_301_000; 数字直接�?包括整数、��Q�Ҏ��、复�?表达式中�Q�“_”字�W�是被忽略的。另外还直接提供了复数类型�?BR>
4、提供定长数�l�、变长数�l�、关联数�l��?BR>int[3] a定义一个定长数�l�；int [] a定义一个变长数�l�；int[int]定义一个关联数�l�，键类型是int�Q�值类型是int�Q�int[char[]] a定义一个关联数�l�，键类型是char[]�Q�值类型是int�Q��用非常方�ѝ�?BR>可以使用foreach来遍历数�l�：

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操作�W�来判断某个值是否是兌��数组的一个键�Q?BR>
int[char[]] a;
if ("hello" in a)
  writefln ("hello");

数组可以切片(slice)�Q?BR>
int[] a;
int[] b = a[1..3];
int[] c = a[1..length];

�{�等。。。�?BR>
5、其它还支持委托、函数指针、模�ѝ��异常、RAII、契�U�式�~�程、单元测试、with语句、auto/typeof、垃圑֛�收、操作符重蝲、内联汇�~�、条件编译、嵌入到HTML�{�，它还标准化了ABI(�q�是C/C++最让�h头痛的地方之一)。这些特性大部分都比较熟悉和实用�Q�下面简单介�l�一下条件编译和嵌入到HTML�?BR>
6、条件编译�?BR>在D中，可以使用version(VersionID)来进行条件编译：

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

�q�可以��用debug条�g�Q?BR>
debug
{
  //
}
else
{
  //
}

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

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

�c�d��查：

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

7、嵌入HTML�?BR>在一个HTML文�g中，�?lt;/code>之间的部分可以当作D代码来编译。比如下面这�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文�g�Q�可以直接��用dmd�~�译器编译�?img src ="http://m.shnenglu.com/cpunion/aggbug/902.html" width = "1" height = "1" /> qiezi 2005-11-02 16:35 发表评论
配置D语言�~�程环境 qiezi — Wed, 02 Nov 2005 03:17:00 GMT D语言是由Walter Bright开发的�Q�他也是Symantec C++�~�译器的作者，仅凭�q�一点就知道D语言一定不错�?BR> D语言的介�l�最好是�?A >uframer的blog�Q�他��译了D语言的大部分文档。当然由于D语言目前一直处于测试版�Q�文档和最新的�~�译器之间可能有很多不一致�?BR> D语言的编译器目前�?个，DMD和GDC�Q�DMD比较�Ҏ��配置�Q�可以从http://www.digitalmars.com/d/dcompiler.html下蝲最新版。下载的压羃包直接解压到��L��一个分区的根目录，�q�把\dm\bin和\dmd\bin加到PATH环境变量里即可��用�?BR> 写一个简单的D语言�E�序�Q�当然还是经典的HelloWorld�E�序�Q?BR> void main () {     printf ("Hello world!\n"); } 和C�E�序基本上一栗��把它保存�ؓhello_world.d�?BR> 下面直接在这个源文�g所在的目录下，执行dmd hello_world.d�Q�即可编译出hello_world.exe�Q�执行它��p��在控制台打印出Hello world!�?BR> 接下来到http://www.dsource.org/projects/build/下蝲build�E�序�Q�这是在D�C�֌�使用比较�q�泛的一个程序。由于最新的v2.09版已�l�发��C��一些严重的BUG�Q�所以最好到http://svn.dsource.org/projects/build/downloads/下蝲v2.08版。把下蝲�?exe文�g改名为build.exe�q�放�|�合适的文�g夹下�Q��ƈ讄��PATH环境变量�?为简单�v见我是直接把它放在\dm\bin文�g夹下) 下面��试一下build�E�序�Q�编写一个hello_world.brf文�g�Q�保存在hello_world.d同一路径下，文�g内容如下�Q?BR> -cleanup hello_world.d 然后执行build @hello_world卛_��~�译出hello_world.exe�?/P> akIDE是一个D语言的IDE�Q�可以到http://www.lessequal.com/akide下蝲�Q�它只需要DMD支持�?BR> D语言�~�译速度非常�?�q�也是Walter Bright对C++不满的一个重要原�?。dsource.org中的mango��目包含755个D源文�Ӟ��但在我的机器上编译成.lib文�g只需�?�U�时间�?BR> D语言性能也很不错�Q�有2��D语言和C/C++、Java、C#的性能比较文章�Q?A > http://mag.vchelp.net/200312/fanyi.htm http://mag.vchelp.net/200312/fanyi_2.htm 相关��目介绍�Q?BR>mango: �q�是一个专注于服务端编�E�的��目�Q�目前主要由Kris开发、维护，实现了servlet�Q�暂时还没有太复杂的功能�Q�不�q�很值得期待�?BR>dwt: D语言的swt开发包�Q�界面开发首选。看�q�eclipse界面的应该有比较��q��印象。由于大部分代码是从java代码转换�q�来的，所以类名、接口等都没有改变�?BR>dui: D语言的别一个界面开发包�Q�基于GTK�?BR>build: 上面介绍�q�的build工具�?BR>dcoder: ��Z��vs.net的D语言语法高亮插�g�?BR>dsp: 全称是Dynamic Servlet Pages�?BR> 以上��目都可以在http://www.dsource.org/projects/扑ֈ�详细资料�?BR> DMDScript是一个类��g��JavaScript的脚本系�l�，可以�?A >http://www.digitalmars.com/dscript/扑ֈ�详细资料�Q�这个我�q�没有��用过�?BR> 最后附�?个��用dwt开发的界面(注：�׃��本�h不习惯安装杀毒��Y�Ӟ��下蝲请先杀�?�Q?/FONT> 1、仿eclipse界面�Q?BR>http://m.shnenglu.com/Files/cpunion/dummyeclipse.rar 2、dwt控�g演示�Q?BR>http://m.shnenglu.com/Files/cpunion/controlexample.rar 在windows xp主题下效果比较好。这2个程序在我的机器上分别只�?.4M�?.2M内存�Q�启动时间也不��1�U�，不要被eclipse的启动时间吓坏了�?BR> 扑ֈ�了这2张图�Q?BR> qiezi 2005-11-02 11:17 发表评论