阿里d模板插件

小灰灰 2022-09-13 05:25 199阅读 0赞

[帖子地址][Link 1]  
作者:阿里.

string GenStruct(string Name, string M1) { 
      return "struct " ~ Name ~ "{ int " ~ M1 ~ "; }";
    }
    unittest { 
      mixin(GenStruct("Foo", "bar"));
      auto foo = Foo(42);
      assert(foo.bar == 42);
    }
    
    void main() { 
    }

你例子让人困惑,是由于包含与`串插件`无关元素.上面代码就没问题.

template GenStruct(string Name, string M1)
    { 
        const char[] GenStruct = "struct " ~ Name ~ "{ int " ~ M1 ~ "; }";
    }
    
    mixin(GenStruct!("Foo", "bar"));

上面的`原始`代码包含`同名模板(a)`,`a`的意思是:模板定义中有与`模板同名`的符号定义,则该符号与`模板实例`意思一样.`GenStruct!("Foo", "bar")`与模板的`GenStruct`成员一样.  
`可`在模板`域`中创建多个`常 符[]`.模板可利用`其实现中`的其他符号.

template GenStruct(string Name, string M1)
    { 
      //注意,下面两个都可定义为`枚`
      //只是为了保持风格一致
      const char[] memberDef = "int " ~ M1 ~ ";";
      const char[] GenStruct = "struct " ~ Name ~ "{ " ~ memberDef ~ " }";
    }

这样用:

//定义两符号
    template Foo(string s) { 
      import std.format : format;
    
      enum integerVarDef=format!"int %s_i;"(s);
      enum doubleVarDef=format!"double %s_d;"(s);
    }
    
    // 插入一个符号
    void main() { 
      mixin(Foo!"hello".integerVarDef);
      hello_i = 42;
    
      mixin(Foo!"world".doubleVarDef);
      world_d = 1.5;
    }

可`一起插件`,注意,这是`模板插件`不是`串插件`.

template MemberListFeature(T)  { 
      T[] theList;
    
      void addMember(T value) { 
        theList ~= value;
      }
    
      T getMember(size_t index) { 
        return theList[index];
      }
    }
    
    struct S { 
      mixin MemberListFeature!string;
      //现在该结构有一个成员数组及两个成员函数
    }
    
    unittest { 
      auto s = S();
      s.addMember("hello");
      s.getMember(0) == "hello";
    }
    
    void main() { 
    }

可在编译时用`foreach`,但不能在`模板域`中用.但可编译时在`模板域/模块域`中用`static foreach`.  
可这样实现你的意思:

template Vector(int dimension) { 
      import std.conv : to;
    
      string makeMembers() { 
        string cps;
        foreach(d; 0..dimension) { 
          // D中不必用初值,因为已初化了.
          cps ~= "int x" ~ d.to!string ~ ";\n";
        }
        return cps;
      }
    
      //向量困惑,改为`向量构`
      const char[] Vector = "struct VectorStruct {\n"
                            ~ makeMembers()
                            ~ "}";
    }
    
    //可视化结果
    pragma(msg, Vector!5);
    //或用编译器开关`-mixin`来可视化.
    
    mixin(Vector!3);
    
    void main() { 
      auto v = VectorStruct();
      v.x0 = 0;
      v.x1 = 1;
      v.x2 = 2;
    }

用`静每一`来实现:

struct Vector(size_t dimension) { 
      static foreach (d; 0..dimension) { 
        import std.format : format;
        mixin (format!" int x%s;"(d));
      }
    }
    
    void main() { 
      auto v = Vector!3();
      v.x0 = 0;
      v.x1 = 1;
      v.x2 = 2;
    }

最后问题,你可这样:

struct Vector(size_t dimension) { 
      static foreach (d; 0..dimension) { 
        import std.format : format;
        mixin (format!" int x%s;"(d));
      }
    }
    
    import std.stdio;
    
    void main() { 
      auto a = Vector!2(1, 2);
      auto b = Vector!2(3, 4);
      auto c = add(a, b);
    
      writeln(c);
    }
    
    Vector!dim add(size_t dim)(Vector!dim lhs, Vector!dim rhs) { 
      return Vector!dim(lhs.x0 + rhs.x0);
        //假定只有x0成员的实现
    }

如何迭代?  
可用`.tupleof`,也可用`int[dimension]`静态数组.类似这样:

foreach (i, member; c.tupleof) { 
        writefln!"Member %s is %s"(i, member);
    }

[Link 1]: https://forum.dlang.org/post/sisu54$245e$1@digitalmars.com