个人进步之路

总是显示后缀

module ana;class Foo { string isim() { return "Foo Class"; } override string toString() { return .isim;//这里不是本地,而是外部}import std.stdio, adi.d;void main() { auto foo = new Foo(); foo.writeln;}module adi;struct Bar { string ad

import std.stdio;void main(){ alias DelegateT = string delegate(); // 每个有自己域的闭包数组. DelegateT[] funcs; foreach (i; ["ham", "cheese"]) { // 在闭包域中复制 string myStr = i.dup; // 闭包应有自己的域 funcs ~= (() => myStr ~ " sandwich"); }

void f(){ version (foo) fVersionFoo(); else fDefault();}void fVersionFoo(){ /* ... */}void fDefault(){ /* ... */}然后,对每个函数测试.

#协程线程池如何等待协程完成协程表示懒任务,完成任务时恢复协程,从而获取任务返回值.以线程中执行任务为例,来看如何定制协程机器的"零件"来实现等待并获取任务返回值:任务<大小型>读文件(){ 常 动 结果=协待 异步读文件{"../主.c++"}; 协中 结果.大小();}整个流程大概这样:创建协程后,执行协待承诺.初始挂起,由于返回从不挂起,不会挂起协程,执行协程函数体(函数体),然后执行协待异步读文件{"../主.c++"},协待式会产生3个结果:1,挂起当前协程

等待--恢复,等等是挂起,协程执行完,再恢复.类似烧开水.c++20协程几个基本概念:可恢复类型用于恢复协程类型,对应协程就是协程返回类型,调用者可通过它恢复协程,也可通过内部承诺型拿到协程返回值.承诺类型主要用来保存协程值,如果需要恢复协程时,需要通过承诺类型拿到协程句柄调用它的恢复方法.协程句柄主要用于访问底层协程帧,恢复和释放协程帧.依赖顺序是可恢复类型-->承诺类型-->协程句柄,调用者通过可恢复类型来恢复协程并拿到协程值.协待,等待器,可等待通过协待式来实现"等待"

元<型名 T>构 承诺;元<型名 T>构[[未丢弃]]任务{ 用 承诺类型=承诺<T>; 任务()=默认; ~任务()=默认; T&&取结果(){ 中 承诺->取结果(); } 任务(承诺<T>*承诺):承诺{承诺}{}私: 承诺<T>*承诺=空针;};元<型名 T>构 承诺{ ~承诺(){输出<<"d构造器承诺";} 任务<T&gt

.uukjsi6a_zpZccrqYiI3k上面这个为百家号的类名.搞笑不?禁用F12,怎么办?点F5,再快速按F12,多试几次,调用出来.

原文模板允许程序员在编译时生成高效且正确的代码.D使模板更简洁,更具表现力,还支持"内省设计"等模式.下面示例,C++等要用预处理才能完成.template sizeOfTypeByName(string name){ enum sizeOfTypeByName = mixin(name, ".sizeof");}unittest{ assert(sizeOfTypeByName!"int" == 4);}我介绍了可帮助编写尽量减少资源使用的模板的一些简单概念.注意D编译器

auto p=(LPCWSTR)pStr;要求,你转换一下. AeroDrawText(dc, "哈哈", &rClient,...)原来的哈哈前面有个L,去掉它.LOGFONT*转LOGFONTW*,加个(LOGFONTW*)就行了.不折腾.

class Serializable(Derived, Base = Object) : Base { static if (is(Base : Serializable!(Base, C), C)) { override void serialize(...) { serializeImpl(); } } else { void serialize(...) { serializeImpl(); } } private void serializeI

struct Options { @Alt("n") // `-n`来替代`--name` @Help("名的帮助") string name;}用独立正交uda,使更可读. struct T { @(NamedArgument .PreValidation!((string s) { return s.length > 1 && s[0] == '!'; }) .Parse !((string s) { return s

import std.stdio;import dmd.backend.aarray;//使用后端的AA,只需要aarray.d一个就够了.import zencoding.windows949;struct Make_CP949Table(T){ private AArray!(Tinfo!T, T) aa; this(T[] keys, T[] values) { foreach (i, T value; values) { T * set = aa.

struct Test { int32_t a;}struct Test2 { int32_t a; Test arr[];}我想静态初化测试2,然后传递给外部c库.extern(C) struct Test { int a;}extern(C) struct Test2 { int a; Test* arr;}static const Test2 t2 = Test2(2, null);void main(){ to_c

#define NTDDI_VERSION 0x06030000#define _WIN32_WINNT 0x0A00#define WINVER 0x0A00

当然是自己的.出现了,很多问题.主要问题就是串不能转成串&.也就是说生成的串要单独写个串 a=F(...),再调用f(..,a,..).折腾!编译过了.然后就是运行.一下就出来一个大小不匹配.这真是,一直找.C++的提示太少,你根本不知道,是哪个函数调用了这个断定,然后抛异常.还有就是,串规则,不知道怎么搞错了.要改掉.然后就是找是哪个函数调用的的断定.这才是最难的.一堆文件.你不知道哪个调用的,而且这个函数还是较新写的.但重新编译后,又调用了它.也就是,某个依赖的文件,在最近修改了它.

无法将参数 1 从“std::string”转换为“std::string &”

协待可帮助完成.构 任务{ 构 承诺类型{ 任务 取中对象(){中{协程句柄<任务::承诺类型>::从承诺(*本)};} 从不挂起 初始挂起(){中{};} 从不挂起 止挂起()无异{中{};} 空 中空(){} 空 未处理异常(){} }; 协程句柄<任务::承诺类型>句柄_; }; 构 等待器 { 极 准备好协(){中 假;} 空 挂起协(协程

co_await exprco_await(协待)是C++20新关键字.上面表示等待懒求值任务.不希望该任务阻塞调用者,用协待挂起任务.调用者继续.任务完成后,协待返回协程的结果.有两个作用:挂起协程及取协程返回值.协待等待任务时,不阻塞调用者,就是协程化异步为同步的关键.协待类似调用函数.对象有()时是可调用的.对象支持协待()时,就是可等待的.协待后的式为可等待式.总是挂起协待 从不挂起;空 测试(){ 协待 总是挂起{};}//错误,缺少承诺类型.协待必须在协程中,协程必须要有

原文协程化异步网络库是大势所趋.c++20协程是无栈协程,提供了:1,三个(协待(co_await),co_yield和co_return)新关键字2,几个新类型:coroutine_handle,coroutine_traits<T...>,suspend_always,suspend_never3,和协程通信机制(通过协程函数的返回对象通信)编译器根据c++协程关键字(协待,co_yield和co_return)生成协程模板框架.需要定制框架中的各个可定制点,来实现协程的绝大部

位置主要有:懒/执行器/生成器/批操作/协程锁/协程条件变量/有栈协程等组件.简单回声示例简单异步::协程::懒<空>会话(传控::套接字 套接字){ 对(;;){ 常 大小型 最大长度=1024; 符 数据[最大长度]; 动[错误,长度]=协待 异步读些(套接字,异网::缓冲(数据,最大长度)); 如(错误){ 抛 异网::系统错误(错误); } 协待 异步写

import std.stdio, std.range;string[] data = [ "Pazartesi", "Pazar"];//...auto toWchar(string str) { ...略//没啥用.}void main(){ foreach(date; data) { wchar[] temp; foreach(d; date) { temp ~= d; } temp.write(" -> ");

L1: foreach (...) { ... switch (auto ret = 重构代码(...)) { case 1: break L1; case -1: continue; }//这样来实现`断/下`. ...}我写了个CP949转换表,别人建议用shared static this()来初化不变关联数组.成功.但dmd在有优化的发布版编译失败.dmd -release -O失败.有个ICE的编译器漏洞.可不用phob

int printf(char *, ...);int main(){ printf("%d\n", (int)sizeof("a"));}//串字面大小.接着// test1.cint printf(char *, ...);int main(){ int a = 0; // dmd为1,其他编译器为-1 // 删掉括号,漏洞消失 int b = - (a) - 1; printf("%d\n", b);}// test2.cint example2(){ int

template T(int i=3){ mixin template M(int m) { enum t = i; }}{ mixin T!1.M!1; pragma(msg, t); // 1}{ mixin T!().M!1; pragma(msg, t); // 3}{ mixin T.M!1; pragma(msg, t);//我想省略`!()`.}用别名,如alias t = T!();目前,没好办法.我想保留t

//raylib.c:#include "raylib.h"//main.d:void main() { import raylib; InitWindow(640,640,"ImportC的raylib测试"); // 循环 CloseWindow();}编译:gcc -E raylib.c > raylib.idmd main.d raylib.i -L=-lraylib./main就搞定了.不用担心绑定/过时了....

import core.stdc.stdio;class A{ void visit(int a){ printf("A - int\n");} void visit(float b) { printf("A - float\n");}}mixin template Bmix(AST){ // 移动进B override void visit(int a) {printf("B - int\n");} override void visit(float

参考这里先从gitee拉取soui2.点击soui.08.sln文件.在mhook项目属性中加上WINDOWS_IGNORE_PACKING_MISMATCH宏.不然有负下标错误.然后F7编译,就成功了.

原文import std;void main() { ubyte[65536] buf; char[] usable_buf = cast(char[]) buf[]; usable_buf.formattedWrite!"Blah %d blah %s"(123, "Это UTF-8 строка."); auto used = buf.length - usable_buf.length; writefln("%(%02X %)", buf[0 .. used]);}...

fun! Hbf0(a,r=1,h=1)"合并分开的,如`ui命令`的`界面命令`分开了.要合并回来.r为右边为`界面0命令`=>`0界面命令`"两个极判断.let[a,b,c]=Tmr(a:a,3,'^')let e=b.clet e=Qhj(a:r,e,'\1')let ml='g/'.a.'/+'.a:h.'s/'.b.'\(.*\)'.c.'/'.e.'/g'"默认h为1.exe mlendf...

import core.stdc.stdio;extern(C)://import std.stdio;mixin template A(int I){ void f(){ printf("%i",I*2); }}mixin template C(int I){ void b(){ printf("%i",I*5); }}struct B(int I){ mixin A!I; mixin C!I; void

import core.stdc.stdio;extern(C++)://import std.stdio;class A(int I){ void f(){ printf("%i",I*2); }}interface C(int I){ final void b(){//要有个终.不然不行. printf("%i",I*5); }}class B(int I):A!I,C!I{ void g(){ f()

1,少写了编译时参数,元<类 T,类 F>构 AA{//少写了个F2,F,T,O参数写错了.3,O&...t写错了3次.4,串应为极,写错了.5,用函数<>时,单独的函数名,不能有重载,否则无法推导.6,未实现相关函数.7,继承类看不见父类的多个函数,真是有病.C++的简洁,就被这些人给毁灭了.8,函数名写错了.9,人家是推导不出来,你都少写一个参数,简直了.10,几个限制条件根本不行,有它就编译不了.11,C++恶心的地方,有时你必须继承基类的模板,

元<常符*c>构 串字典:公 小字典{ 串字典(){串 b=基路径(c);初化(b);}};//基路径.用 AA=串字典<"aa.txt"y>;现在,可基于文件,作为参数,来使用字典.

元<整 I>构 AA{// AA(){ 打印(I); }};元<整 I,整 J>构 AA{// AA(){ 打印(J,I); }}; 空 主(){ AA<3>a;AA<4,5>b;}编译不过,不能当作AA的相同分支,第2个AA要改成其他如BB,才能编译过.而D不存在:import core.stdc.stdio;extern(C):struct A(int I)

元<整 N>构 元串{ 符 p[N]{}; 常式 元串(常 符(&pp)[N]){ 区间们::复制(pp, p); };};元<元串 A>常式 动 符号""y(){中 A.p;}//作为模板串的串,为元串.空 主(){ 用 T=TT<"aa.txt"y>; T t;}...

太强大了!可以用串作参数.元<常 符*m>构 B{ B(){//只能放基路径. 串 b=m;...; }};空 f(){ 静 常 符 c[]="aa.txt";用 T=B<c>; BB<T>e;...}空 主(){ f();}

function ff(){ var a=q('article.article-main'); jl0(a,'fold'); jl(a,'unfold');}//body > div > articlesetTimeout("ff()",1000);

原文前面的同步,用的是共针来共享同步/承诺,中值是置该值就拿到协程返回值了.用T,而承诺用其引用,也可以.还可让,同步持有协程句柄,取时从句柄的承诺中返回值.止挂起返回永不挂起,则立即释放协程,此时,要返回总是挂起.元<型名 T>构 同步1{公: 构 承诺类型; 同步1(协程句柄<承诺类型>句柄) :m句柄(句柄){ 输出<<"构造同步对象"<<行尾; }//用句柄构造同步1. ~同步1(){ 输出<&

空 gg(h,k){ 动 f=[&](整 m){ ... };// 动 g=[&](整 m,整 n){ ... };//短语,原,这里函数不能用静 动. λ函数(f,g,h,k); }看见没有,这是祸害.有λ引用问题,怎么样搞定呢?搞个类,用两个虚函数作接口,填充它.保护://继承者要实现 虚 空 f(整 j){} 虚 空 g...