02 2022 档案
摘要：在此 上面的是2012年的,比较老了.可以下载2019.2版. 不过,可能要配置一下build method. 这里有wx组件与其他gui的比较
阅读全文
摘要：构 找中词{ 向量<小词>们;单 取中文 找; 空 找(串&a){ 清理(们);找.切换(a); 对(动&t:找.们){ 连中基<4>(加小词,t.小,们,t.位); } } }; C++没有用定属,这里,你不能区分串&a中a的意思,比如常见的串有两个意思,一个是文件名,一个是普通串.普通串没啥限制
阅读全文
摘要：原文 我要从大的二进制读取中解析小字段,用模板时无法组合有些操作. import std.bitmanip, std.system; ubyte[8192] data; ubyte[] temp = data[4..6]; ushort us = temp.read!(ushort, Endian.
阅读全文
摘要：测试用例: class Base { bool after(); mixin(handleMiddlewareAnnotation); } class C : Base { override bool after(); }//重载虚函数. string handleMiddlewareAnnotat
阅读全文
摘要：原文 void main () nothrow { int[int] map; foreach (pair; map.byKeyValue) // OK { } foreach (key, val; map) // 错误: `_aaApply2`不是`nothrow`. { } } 对有嵌套AA类型
阅读全文
摘要：原文 auto ret = (() @trusted { Unqual!U[n] theArray = void; return theArray; //.1 }()); 化简最小为: auto staticArray(size_t U, R)(R input) { import std.range
阅读全文
摘要：原文 我在处理输出区间,如果每次都调用.put(T),则效率太低. 自然,我可为该资源制作自定义OutputRange,但我想搞个通用的批次调用放的BufferedOutputRange. 在为缓冲输出区间设计模板时,我先在给定输出区间上用ElementType,希望检测允许.put(T)的类型.但
阅读全文
摘要：原文 我想用类型系统(客户端和服务器代码)来建立REST接口. struct Request { Method method; string url; int apiLevel; } @Request(Method.GET, "/my-resource/%s", 1) struct MyResour
阅读全文
摘要：原文 可以参考及这里,只看前半部分来更好理解协程,还有这一篇. C++20协程背后有个状态机. 有协中,协待,协产就是协程. 调用协程 分配栈帧->造承诺对象->拷参数->造(协程+通信对象)->(立即/暂停)->返回值(通信对象返回)->消灭协程 可任意调用协程函数体. 用协程模拟简单函数. sy
阅读全文
摘要：空 替换(串&a,串&b){::替换(冲,a,b);} 空 替换(双<常 串,串>&t){//太无聊了. 串 a=t.第一;替换(a,t.第二); } 又是无聊的常,烦人得很. 压(们,t); 把t写成a了,搞错了. 我们写程序,一般这样,一个大类,里面管2,3个小类就行了,然后各司其职,组装起来.
阅读全文
摘要：原文 int main() { void delegate()[] dgs; for (int i = 0; i < 10; i++) { dgs ~= () { import std.stdio; writeln(i); }; } dgs ~= () { import std.stdio; wri
阅读全文
摘要：module main; // main.d import std.traits; import model; void main () { enum Q = Parameters!read; //注释掉选择性导入后,用`别名`而非`枚举`. } // module model; // model.
阅读全文
摘要：原文 import std.sumtype: SumType; struct A { SumType!int b; } static foreach(sym; __traits(allMembers, A)) pragma(msg,sym); //生成 b opAssign 如何检查opAssign
阅读全文
摘要：原文 类型安全类型类的变参函数参数应是域 类型安全可变参数 可在栈上分配类对象,因此类型安全的可变类参数应自动为域. @safe: class C { int x; } ref int g(scope C c ...) { return c.x; } 正确发出错误:不能返回c域变量,而 ref in
阅读全文
摘要：用 add_rules("mode.debug", "mode.release") target("skinnedui_src") set_kind("binary") add_files("SkinnedUI.cpp") add_files("stdafx.cpp") add_files("Ski
阅读全文
摘要：文档: import std.algorithm.comparison : equal; import std.conv : to; alias stringize = map!(to!string); assert(equal(stringize([ 1, 2, 3, 4 ]), [ "1", "
阅读全文
摘要：原文 import std.sumtype; struct Unit {} alias Option(T) = SumType!(T, Unit); //不能推导别名. void foobar(T)(Option!T option) {} void main() { foobar(Option!in
阅读全文
摘要：原文 用StdioException抛为何不能不抛? nothrow void hello() { try { writeln("Hello, World!") } catch (StdioException) {} } 这却可以? nothrow void hello() { try { writ
阅读全文
摘要：原文 import std.stdio; // 最先,需要函数指针. T[] map_vals(T,S)(scope T function(S) f, S[] a){ auto b = new T[a.length]; foreach(i,x;a) b[i] = f(x); return b; }
阅读全文
摘要：概述 程序的内存安全性取决于程序员和语言实现维护程序数据运行时不变量的能力. D编译器知道内置类型(如数组和指针)的运行时不变量,并且可用编译时检查来确保正确.这些检查对用户定义类型并不总是足够的.为了可靠维护编译器硬编码知识之外的不变量,D程序员必须求助于手动验证@safe代码和防御性的运行时检查
阅读全文
摘要：析构器的目的是描述对象生命期结束时的清理工作.允许@safe代码在该点前手动调用析构器,然后继续用析构对象会破坏RAII内存管理: module app; import core.stdc.stdlib : malloc, free; struct UniqueInt { private int*
阅读全文
摘要：规范显示按域声明闭包,但编译器不强制. struct S { int opApply (/*scope*/ int delegate (int* ptr) @safe dg) @safe { return 0; }//无域. } void test(S s) @safe { foreach (int
阅读全文
摘要：原文 import std.conv; class Foo { int i; // v 推导类型 this(int)//(T i) { this.i = i;//.to!int; } string test() { return i.to!string; } } void main() { long
阅读全文
摘要：原文 基于opDispatch+__traits(getMember)的库解决方案. template FieldOfKeyword(string[2][] keywordFieldPairs) { template opDispatch(string member) { static foreac
阅读全文
摘要：原文下 取类型大小(字节) int.sizeof (char*).sizeof double.sizeof Foo.sizeof //Rust size_of::<i32>() size_of::<*const i8>() size_of::<f64>() size_of::<Foo>() let
阅读全文
摘要：d在简洁性和表达性方面,胜了很多.而rust的明确性更好.rust更学术,D更实用. module main; import std.stdio; void main() { writeln( "Hello, 世界" ); } fn main() { println!("Hello, 世界") }
阅读全文
摘要：原文 打开和关闭文件 import core.stdc.errno; import std.exception; import std.stdio; void main(string[] args) { try { auto file = File("test.txt", "r"); file.cl
阅读全文
摘要：原文 这样实现类似Qt中的信号和槽: class Foo : XObject { @signal void message( string str ); } class Bar : XObject { @slot void print( string str ) { writefln( "Bar.p
阅读全文
摘要：interface A { @property int data(); @property void data(int); } alias helper(alias T) = T; string implement(Interface)() { string code; import std.tra
阅读全文
摘要：原文 编译时反射使D元编程灵活而强大. 找出表达式的有效性: __traits( compiles, a + b ); is( typeof( a + b ) ); __traits(compiles,expr)和is(typeof(expr))都需要词法有效表达式.但后者不检查是否编译,而是检查是
阅读全文
摘要：原文 import std.range; static assert(isInputRange!(uint[])); // true static assert(isInputRange!string); // true static assert(!isInputRange!void); // f
阅读全文
摘要：原文 ref-return-scope易混淆. 现在规则改为: 除非return scope按源码出现的顺序(中域),否则ref-return-scope总是按ref-return scope理解. 可处理各种情况,为后向兼容,放在-preview=dip1000里面. 比如: ref int fo
阅读全文
摘要：下面应在dip1000下编译失败. ref int test(ref scope return int* p) { return *p; } p应为return ref与scope,但编译器按ref/return scope解释并通过. 问题是,返回了p的值,而return ref/scope应阻止
阅读全文
摘要：原文 我想在B定义中使用A而不是串 struct A { string s; this (string s) { this.s = s; } } struct B { A a; A b; } void main () { auto b0 = B (A ("A"), A ("B")); // 工作,但
阅读全文
摘要：原文 纯函数可通过异常逃逸参数 修复阻止了通过返回值逃逸,但还有限制:即使无法通过参数或返回值逃逸,仍可把纯函数参数放入异常并抛. void f_throw(string x) @safe pure { throw new Exception(x); }//异常. void escape_throw
阅读全文
摘要：当前的微软80位模拟器不支持80位到浮/双精的转换.自己写,工作量太大,细节多,网上没有boost许可模拟器. 可在std.conv中加narrow函数. 指令集改变不大. import std.conv, std.range, std.stdio; void main() { writeln(io
阅读全文
摘要：struct Module { CachedString data; } struct CachedString { private size_t len; this (string data) { this.len = data.length; } public string str () con
阅读全文
摘要：struct S { @disable this() immutable;//注解 } void main() { S s; } 当不能访问构造器时,加不加不变都一样,编译器在此,都没看限定符.
阅读全文
摘要：过去如下代码,第二条消息发送到标准输出之后抛ConvException.现在,第2条不显示.输出已刷新,但在输出异常后. import std.stdio; void main() { int a; write("请输入整:"); readf("%s", &a); int b; write("请输入
阅读全文
摘要：void main() @safe { char[4] message = "oops"; assert(0, message[]); } 单独编译,并出错,但用-preview=dip1000可以避免. dip1000将是默认,因而不算八哥. struct S { int i; int* ptr;
阅读全文
摘要：原文 void foo(){} struct A{ auto opDispatch(string op)() { writeln;//故意,不导入. } } void test(){ A.init.foo(); } //dmd -c -o- main.d 当opDispatch不编译时,发生.正确行
阅读全文
摘要：原文 module test; @safe: import std; void main() { //import std.uni : isWhite; //需要取消注释,才能编译. writeln("学D有趣".split!isWhite); } isWhite有歧义,有std.uni.isWhi
阅读全文
摘要：struct DontDoThis { immutable char[12] content; @safe this(char ch) { content[] = ch; throw new Exception(content[]); // assert(0, content[]);//也能触发 }
阅读全文
摘要：#include <常用> #include "碰碰2.cpp" #include "p.cpp" 元<类...T>构 启动{ //有T,有I,有J,基本上就简单了. 元<元<类...>类 G,整...I,整...J> 静 空 动作(序列<I...>a,序列<J...>b){ 常式 动 e=相转绝(
阅读全文
摘要：构 AA{ 空 f(){ 打印("AA"); } }; 构 AB{ 空 f(){ 打印("AB"); } }; 构 BA{ 空 h(){ 打印("BA"); } }; 构 BB{ 空 h(){ 打印("BB"); } }; 构 BC{ 空 h(){ 打印("BC"); } }; 构 CA{ 空 g(
阅读全文
摘要：原文 我想知道他们@安全和dip1000的目标.确保整个程序的内存安全? 多字变量更新中的数据竞争怎么样? @safe是的,但并不简单,因为main不是唯一可能的入口点,而且存在@trusted. D目前: 必须标记共享数据为"shared".@safe代码无法访问shared数据(仅用-previ
阅读全文
摘要：让球滚动的初始步骤: 1.从druntime和phobos中删除所有复和虚的单元测试. 2.删除/替换druntime编译器库助手. cdouble *_memset128(cdouble*p,cdouble v,size_t c) crreal *_memset160(creal*p,crreal
阅读全文
摘要：struct S { int x; } @safe interface I { int func(ref scope S s) @nogc; } @safe class C : I { int func(ref S s) { return 2*s.x; } } 编译器未检查域属性? 可编译,但问题是
阅读全文
摘要：原文 import std.stdio; @safe: struct ScopeBuffer(T, size_t Len) { this(T[Len] buf, size_t len = 0) { this.buf = buf; this.len = len; } // 用`return`正确发出编
阅读全文
摘要：原文 dip1000隐式去闭包属性失败. struct A { void method() pure @safe nothrow @nogc { } } void test(scope void delegate() del) @safe { } void main() @safe { A a; /
阅读全文
摘要：原文 你不这样, struct MyData { int x; void method() { x++; } } MyData data; data.method(); 而是这样写: struct MyData { int x; } void method(ref MyData mydata) {
阅读全文
摘要：static foreach(name; ["boo", "foo"]) { enum string file_name_info = "file_" ~ name ~ "_info"; string mixin("file_", name) = readText(name ~ ".txt"); s
阅读全文
摘要：代码如下: 元<元<整...>类 G,整...K> 空 碰碰(序列<K...>a,序列<>){G<K...>::动作();} //.4这里基础动作.//最后一步. 元<元<整...>类 G,整...A,整...B,整...I,类 F,类...J>要求(都是<整,F,J...>) 空 碰碰(序列<A.
阅读全文
摘要：#include <常用> 元<元<整...>类 G,整...J> 空 aa(整 i,序列<J...>){ (((i==J)&&(G<J>::动作(),0)),...); } //元<整 J>常式 整 aa(整 i){ // 如(i==J)中 J;异 中 0; //}//序列不能保存,要立即应用.
阅读全文
摘要：#include <常用> 元<整 J> 常式 整 aa(整 i){ 如 常式(J==i){中 J;} 异 中 0; }//序列不能保存,要立即应用. 空 主(){ 整 i=3; 打印(aa<4>(i)); }
阅读全文
摘要：#include <常用> 元<整 I=0>整 K=0; 元<整 I>整 K<I>(1); 空 主(){ 打印(K<0>); 打印(K<1>); 打印(K<2>); //K<浮>=3; }
阅读全文
摘要：元<整...I,整...J> 常式 动 相转绝(序列<I...>a,序列<J...>b){ 断定(型长等(I,J));常式 整 K=取头(b); 相转绝(序列<取头(a),K>(),去头(a),去头(b),序列<K>()); }//相对偏移转绝对,前面为多维,后面为相对偏移. 然后一直报变量不能具有
阅读全文
摘要：#include <常用> #include "多参包.cpp" 元<元<类...>类 G,类...T,整...J> 空 g(空包<T...>a,序列<J...>b){ 常式 动 t=选型<G>(a,b); 打印类型(t); } 空 主(){ 常式 动 t=空包<整,极,极,整,串,短,短,整,极>
阅读全文
摘要：元<元<类...>类 G,类...T,整...J,类...O> 常式 动 选型(空包<T...>a,序列<J...>b,空包<O...>c){ 如 常式(型长...(J)==0)中 G<O...>(); 异{ 常式 动 t=去头项<取头(b)>(a); 常式 动 e=取头个(t.第一);//第一!
阅读全文
摘要：#include <常用> 元<整 I,元<类...>类 C,类...T> 空 f(C<T...>a){ 常式 动 t=去头项<I>(a); 打印类型(t.第一,t.第二); 常式 动 e=分加尾(t.第一,t.第二); 打印类型(e); //打印类型(t); } 元<类...T,整...J> 空
阅读全文
摘要：元<类...T,整...I,类...O> 常式 动 分包(空包<T...>a,序列<I...>b,空包<O...>c){// 常式 整 N=型长...(I); 如 常式(N==0)中 分加尾(c,a);//最后一部分. 异{ 常式 动 t=去头项<取头(b)>(a); 中 分包(t.第一,去头(b)
阅读全文
摘要：元<整 E,元<类...>类 C,类...I,类...J> 常式 动 去头项(C<I...>a,C<J...>b){ 如 常式(E==0)中 双{a,b}; 异{ 常式 动 t=取头<C,I...>(); 中 去头项<E-1>(去头<C,I...>(),加尾(b,t)); }//这样是可以实现的,
阅读全文
摘要：元<整 M,整...K,整...I> 常式 动 造位置(序列<K...>a,序列<I...>b){ 静 常式 整 N=型长...(K); 如 常式(N==0)中 b; 异{ 静 常式 整 X=M+取头<K...>(); 中 造位置<X>(去头<K...>(),加尾<X>(b)); }//先要搞启动项
阅读全文
摘要：原文 比其他编译器快. 基本设计很简单.节点类型上每个表达式有个生成函数.用标准分析数据流数学来优化.分配寄存器和调度时,有个优化. 设计最初针对8086,然后扩展至32位,64位,再是simd.复杂来自x86指令集及表达式树形状的选指. 慢,来自于支持4种不同的目标格式. 我经常写: import
阅读全文
摘要：元<类 T,类 M> 构 过滤行:公 名行处理,公 T,公 M{ 过滤行(){处理();} 空 行处理(串&行){ 如(M::要要(行))T::要处理(行); 异 T::不要(行); } 空 后处理(串&名){T::后处理(名);清();} }; 这里,T,M为我们的策略类,他们类似函数的参数,而过
阅读全文
摘要：元<元<类,类>类 G,整 I,类...A,类...B,整...J> 空 启动(空包<A...>,空包<B...>,序列<J...>,整 j){ (((J==j)&&(G<几型(I,A),几型(J,B)>(),0)),...); }//I与J个数不一样. //这里不必用`选择<G<...>>`特化等
阅读全文
摘要：元<类 M,类 N>构 H:公 M,公 N{ 空 f(){//也更容易扩展.如何继承呢? M::f();N::g(); } }; 元<类...>构 G{}; 元<类...>构 U{}; 元<元<类,类>类 G,整 M,整 N,类...A,类...B> 构 U<G<一包<M,A...>,一包<N,B.
阅读全文
摘要：元<元<类,类>类 G,类...A,类...B,整...I,整...J> 空 启动(空包<A...>&a,空包<B...>&b,序列<I...>,序列<J...>,整 i,整 j){ ((I==i)&&(((J==j&&(选择<G,一包<I,A...>,一包<J,B...>>(),0)),...))
阅读全文
摘要：代码: 元<类 M,类 N>构 H:公 M,公 N{ 空 f(){//也更容易扩展.如何继承呢? M::f();N::g(); } }; //M,N,都可搞成策略. 元<类...>构 G{}; 元<整 I,类...T>构 空包{}; 元<整 M,整 N,类...A,类...B> 构 G<空包<M,A
阅读全文
摘要：元<类 M,类 N>构 H{}; 元<整 I,类...M>构 MM{}; 元<整 I,类...M>构 NN{}; 元<整 M,整 N,类...A,类...B> 构 H<NN<M,A...>,MM<N,B...>>{ 空 f(){ 用 S=取型<M,A...>::型; 用 T=取型<N,B...>::
阅读全文
摘要：元<类 T>概念 AA=要求(T&t){t.f();}; 元<类 T>概念 BB=要求(T&t){t.g();}; //元<类 M,类 N>构 H{}; 元<类...M>构 H:公 M...{ 元<类 M>空 b(){ 如 常式(AA<M>){M::f();} 异 如 常式(BB<M>){M::g(
阅读全文
摘要：#include <常用> //B,C,D,E同上略. 元<类 M,类 N> 构 H:公 M,公 N{ 空 f(){//非静态成员函数. M::f();N::g(); }//调用f()? };//要记得继承M与N. 元<类...M>构 空包{}; 元<类 M,类...N,整...J> 空 gg(序列
阅读全文
摘要：参考 元<类...>构 空列{}; 元<类 A,类 B>构 E{}; 元<类...A,类...B> 构 E<空列<A...>,空列<B...>>{ };//使用A...,B... 特化多参包.
阅读全文
摘要：原文 命令,X+3库: link X.obj A.lib B.lib C.lib 4个都定义了f,选X.f.无未解析符号. 如果,只有B,C定义了f,则选B,因为不在X,然后按库顺序找定义,在B处找到了.不用找C了. 仅仅是引用了f,然后按提供库顺序找f. 想不用库定义?在X中定义f,不必勾挂!只需
阅读全文
摘要：元<整 N>常式 真型 是第一(第一<N>常&){中{};} 元<整 N>常式 假型 是第一(第二<N>常&){中{};} //可以用构. 元<类 T> 常式 极 是第一值=推导(是第一(求值<T>()))::值; 元<类,类,类,整 I=0>构 分割; 元<整...A,整...B,整 N> 构 分
阅读全文
摘要：这是为什么dmd在,命令行上有多个源文件时会创建单个目标文件原因.也是dmd可直接创建库原因. 我玩了很多次直接生成可执行文件. 我解释不了的事情: 1.什么是"未定义符号"? 2.什么是"多重定义符号"? 3.链接器如何解析符号 我们的运行时库说明了这种困惑.在druntime中,有可以替换处理断
阅读全文
摘要：但,低估"in"了.很难决定参数类型: // 愚蠢的常: void foo(const(int)); //给用户信息太多 //用户不必知道我将改变参数: void foo(int); //复制很昂贵时,要`记得`排除右值: void foo(ref const(ExpensiveToCopy));
阅读全文
摘要：常,我不修改数据,不变,不能改. 要理解,常/不变/可变,可理解为常为不变/可变的基,而后两个(不变/可变)为常的子类.他们可隐式转为常(基类).他们相互间不能转换.常,则不变/可变都可安全传给它. 可变,则不变/常都不能传给它. 常不能传递给不变.因为常可能为可变数据.即使引用自身不修改,但可能外
阅读全文
摘要：#include <常用> 构 B{ 空 f(){ 打印("B"); } }; 构 C{ 空 f(){ 打印("C"); } }; 构 D{ 空 g(){ 打印("D"); } }; 构 E{ 空 g(){ 打印("E"); } }; 元<类 M,类 N> 构 A:公 M,公 N{ 空 g(){//
阅读全文
摘要：#include <常用> 构 B{ 空 f(){ 打印("B"); } }; 构 C{ 空 f(){ 打印("C"); } }; 构 D{ 空 g(){ 打印("D"); } }; 构 E{ 空 g(){ 打印("E"); } }; 元<类 M,类 N> 构 A:公 M,公 N{ 空 g(){//
阅读全文
摘要：元<AA...T>构 属性{}; 元<类...T>构 策略{}; //特化中可有多个参数包. 元<类...T>类 E; 元<AA...L,BB B,类...P> 类 E<属性<L...>,B,策略<P...>>:公 P... { ... };//特化. //可允许用户按不同的顺序指定参数(如果通过继
阅读全文
摘要：//矩阵与向量标签 构 矩阵标签{}; 构 向量标签{}; //提取矩阵及向量类型标准的特性类 元<类 MV>构 矩阵向量特征{用 TT=MV::TT;}; //求得矩阵*矩阵,矩阵*向量,向量*矩阵, //算式结果类型 //默认为第1个 元<类 MV1,类 MV2,类 TT1,类 TT2> 构 的
阅读全文
摘要：#include <常用> #define 动作(H) \ 空 H(串&行){ \ 静转<T*>(本)->h(行); \ } //没必要使用`宏每一`. 构 A{ 空 f(串&a){ 打印("fa",a); } 空 g(串&a){ 打印("ga",a); } }; 构 B{ 空 f(串&a){ 打印
阅读全文
摘要：元<类...T> 构 A{ 空 f(){ 打印("A"); } }; 元<类...T> 构 B:公 A<T...>{ }; 元<类...T> 构 C:公 A<T>...{ }; 元<类...T> 构 D:公 A<T,符>...{ }; //注意继承方式. 元<类...T> 构 E:公 A<T,T..
阅读全文
摘要：import std; alias Record = Tuple!(string, string, string); static immutable string[][] table = () { string[][] table; string csvText = import("file.cs
阅读全文
摘要：参考地址 策略类是为了实现多态,通过多态来完成任务. 主要是为了替代继承中的虚函数,虚函数太浪费了,因此,把虚函数提取出来,搞成策略类. 其实就是类似奇异模板了.总之把类放在模板里面就对了.
阅读全文
摘要：静 动 f=[&]<类 T>(T&t,串&a){ 如(p->要要(a))t.要处理(a); 异 t.不要(a); };//不能用静. 多.选一(f,n,行);//扩展一下参数. 看见这种λ满天飞,就知道了,该用策略类了. 这种f表示不好看,要改,看看改后样儿: 元<类 T>类 A:公 T{ 公: 空
阅读全文
摘要：元<元<类>类 G,类...T,整...I,类...O> 空 启动(整 n,序列<I...>,O&...o){ (((n==I)&&(G<T>(o...),0)),...); }//要求顺序要一致. 元<元<类>类 G,类...T,类...O> 空 启动(整 n,O&...o){ 启动<G,T...
阅读全文
摘要：#include <常用> 元<类 T>构 J{ 空 f(){静转<T*>(本)->f();} }; 构 A:J<A>{ 空 f(){ 打印("A"); } }; 构 B:J<B>{ 空 f(){ 打印("B"); } }; 构 C:J<C>{ 空 f(){ 打印("C"); } }; 元<类 T>
阅读全文
摘要：改正前: 空 行处理(串&行){//加一个列表. 静 动 f=[&]<类 T>(T&t){ 如(p->要要(行))t.要处理(行); 异 t.不要(行); };//不能用静. 多.选一(f,n); } 看见没有,如果这里f为静,则你每次处理的行,都是第1行,这是不变的. 改正后如下: 空 行处理(串
阅读全文
摘要：静 动 f=[&]<类 T>(T&t){ 如(p->要要(行))t.要处理(行); 异 t.不要(行); }; 多.选一(f,n); //对比 如(p->要要(行))t->要处理(行); 异 t->不要(行); 策略类,放在模板参数里面,就可以吊打虚函数了.
阅读全文
摘要：#include <常用> #include "多策略.cpp" 构 A{ 空 f(整 i){ 打印("A",i); } }; 构 B{ 空 f(整 i){ 打印("B",i); } }; 构 C{ 空 f(整 i){ 打印("C",i); } }; 元<类...T,类 F>空 选一(F&f,整 n
阅读全文
摘要：fn main() { let a = [1, 2, 3, 4, 5]; let index = 3; let element = a[index]; println!("值为:{}", element); }
阅读全文
摘要：#include <常用> #include "多策略.cpp" 构 A{ 空 f(){ 打印("A"); } }; 构 B{ 空 f(){ 打印("B"); } }; 构 C{ 空 f(){ 打印("C"); } }; 元<类 T>空 g(T&t){ t.f(); }//还可加限制 鸭动作(G,g
阅读全文
摘要：元<类 F,类...T> 空 执行(F&f,变量<T...>&t){ 静 常 整 I=型长...(T);整 j=t.索引(); 切为编<I>(j,[&](动 i){ 常式 整 N=推导(i)::值; 静 动 g=取<N>(t);f(g); }); }//是否继续.只一个,就不必了,选中它,就执行.
阅读全文
摘要：元<类 F,类...T> 空 向量选一(向量<变量<T...>>&们,F&f,整 n){ 整 j;极 要下=0;静 常 整 I=型长...(T); 对(动&t:们){//i与过的顺序要匹配 j=t.索引(); 切为编<I>(j,[&](动 i){ 常式 整 N=推导(i)::值; 如(N!=n){要
阅读全文
摘要：参考地址 #include <常用> #define ID(x) []()常式{中 x;} 元<动...>构 A{}; 元<类 T>用 TT=推导(求值<T>()()); //求值,加个右值引用后的类型. //这里就是(t())后返回值的类型 常式 整 长呀(常 符*s){ 中 s[0]==0?0:
阅读全文
摘要：declval 只声明,无实现,避免调用构造函数. 一般用于与decltype,sizeof等关键字配合来推导类型,计算占用空间等. declval的功能:不管该类型是否有默认构造函数或是否可创建对象,返回它的右值引用.是编译时工具. 取类中成员函数返回值类型. decltype(myaobj.my
阅读全文
摘要：#include <常用> 元<动...>构 A{}; 元<类 T> 常式 动 g(T t){ 中 A<t()>{}; } 元<整>串 m; 空 主(){ 动 e=[](){中 5;};//编译时. 打印(类名<推导(e)>()); 整 k=2; g(e); }
阅读全文
摘要：#define 飞船(S)\ 动 符号<=>(常 S&)常=默认;
阅读全文
摘要：template<std::size_t N> struct 双串 { char p[N*2-1]{}; constexpr 双串(char const(&pp)[N]) { std::ranges::copy(pp, p); std::ranges::copy(pp, p + N - 1); };
阅读全文
摘要：类 A:公 注地<动作基>,公 注地<模式基,整>{ 动作基*p;模式基*m;单 整 n=0; 空 初化(串&a){ 动[c,d]=多工<注地,动作基,模式基>(); p=(*c).取(a);m=(*d).取(n); }//地,为注册的地方.只能这样, 公: ...//略了. }; 如果有多个注地基
阅读全文
摘要：#include <常用> #include <ranges> namespace vs = ranges; int main() { vector v1 {"甲", "乙", "丙", "丁", "戊", "己", "庚", "辛", "壬", "癸"}; vector v2 {"子", "丑",
阅读全文
摘要：struct BitFields { int b : 4 {1}, d : 4 {2}, p : 4 {3}, q : 4 {4}; //C++20:`位域`的默认成员初始化器 }; const auto [b, d, p, q] = BitFields{}; //结构化解绑定. 上面是位域 #in
阅读全文
摘要：#include <常用> 元<常 符*T>构 B{ 串 f(){ 串 a=T; 中 a; } }; 空 主(){ 静 常 符 a[]="啊啊"; B<a>b; 打印(b.f()); }//类似串一样作为模板参数.
阅读全文
摘要：元<类...M,类...N,整...I> 空 g(向量<变量<M...>>&们,序列<I...>,N&...n){ ((n=取<N>(们[I])),...); } 元<类...M,类...N> 空 g(向量<变量<M...>>&们,N&...n){ g(们,转序<N...>(),n...); } 空
阅读全文
摘要：多策略类在此 拥有多策略类后,不必使用继承的虚函数机制.来实现多态.代码如下: #include "多策略.cpp" 构 B{ 空 f(){ 打印("啊"); } }; 构 C{ 空 f(){ 打印("哦"); } }; 构 D{ 空 f(){ 打印("D"); } }; 元<类 T>概念 有啊=要
阅读全文
摘要：元<类...T>类 多策略{//不用有基类. 元<类 T>空 加一(){T b;压(们,b);} 用 M=变量<T...>;//加上它.别搞忘了. 元<元<类>类 G,整...I>空 动作(序列<I...>){ (G<T>::动作(取<I>(们[I])),...); }// 公: 向量<M>们; 多
阅读全文
摘要：原文 引文 隐式转换易错 问题是如何说服沃尔特 我想要输出隐式转换的警告的编译时选项 我更希望,移植C到D时,可报错,而不是保留地雷代码.应该是这样的-vimplicit-conversions隐式开关. C系外系统编程语言倾向于用显式转换. 第1个示例,在D中修复了.乘法示例有意思,其他在速度相关
阅读全文
摘要：原文 可通过,这个轻松禁止跟踪栈. void main() { import core.runtime : Runtime; Runtime.traceHandler = null; throw new Exception("oops"); } 不仅避免输出,还使EH更快.重用这个,还可自定义函数,
阅读全文
摘要：无论@safe与否,从不变转为可变不好. 如果接受可变参数,但函数内不会修改它的,如C中函数,此时,丢弃常/不变不是未定义行为.仅当丢弃常/不变后又修改它们,才是未定义行为. 要尽量避免转换类型. 编译器允许不用.dup从不变转为可变, int i; i = "Hello"; 就像上面一样. ()
阅读全文
摘要：代码如下: 元<整 N,类 F,类...T>构 取型:取型<N-1,T...>{}; 元<类 F,类...T>构 取型<0,F,T...>{ 用 型=F; }; 空 主(){ 用 B=取型<2,整,短,长,整,串>::型; 打印(类名<B>()); } 注意,不要这样用: 元<整 N,类 F,类..
阅读全文
摘要：#include <常用> 空 主(){ 用 T=变量<整,串,整,长,浮>;T t; 用 B=推导(取<1>(t)); 打印(类名<B>()); }
阅读全文
摘要：#include <常用> #include "向量针.cpp" 元<类 T>构 A{ 整 i; 空 f(){ 静转<T>(本)->f(); } };//不能放一起.只能用变量. 构 B:公 A<B>{ 空 f(){ 打印("啊"); } }; 构 C:公 A<C>{ 空 f(){ 打印("哦");
阅读全文
摘要：类 无限量针{//无限制的加 元<类 T>空 加一(){ 空*b=新 T();压(们,b); }//如何保存类型. 公: 向量<空*>们; ~无限量针(){清理针(们);}//析构时清理 元<类...T>空 加(){(加一<T>(),...);} };//啥限制都没有. 无法保存类型,因而也就没啥用
阅读全文
摘要：#include <常用> 元<类 B>构 A{//使用类 用 BB=无序映<串,B>;单 BB 工; }; 元<元<类>类 G,类...T>动 多工(){//多个工 中 元组{(&G<T>::工)...}; }// 构 E:公 A<整>,公 A<串>{ E(){ 动[m,n]=多工<整,串>();
阅读全文
摘要：const palindrome = "able was I ere I saw elba"; writeln(palindrome); writeln(palindrome.retro);
阅读全文
摘要：#include <常用> 元<类 B>构 A{//使用类 用 BB=无序映<串,B>;单 BB 工; }; 元<元<类>类 G,类...T>动 多工(){//多个工 中 元组{(&G<T>::工)...}; }// 构 E:公 A<整>,公 A<串>{ E(){ 动[m,n]=多工<整,串>();
阅读全文
摘要：0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
阅读全文
摘要：上一篇文章是个简单版自动注册, 但有个限制, 用 BB=无映针<串,动作基>; 这里,BB只针对动作基,现在再来扩展一下: 元<类 B>构 注地{ 用 BB=无映针<串,B>;单 BB 工; }; 元<类 B,类 T>构 自注基:注地<B>{ 用 BB=注地<B>::BB;//不然找不到BB. 静
阅读全文
摘要：构 注册位置{ 用 BB=无映针<串,动作基>;单 BB 工; }; 元<类 T>构 自注:公 注册位置{ 静 极 注册(){中 BB::注一<T>();} 单 极 呀=注册(); }; 为啥用注册(),这是延迟实现,避免T还未构建.否则直接用BB::注一<T>();就行了. 上面是核心,至于注册实
阅读全文
摘要：int i; byte b = i & 0xFF; //d的值传播 ubyte a, b, c; a = b | c; 运行得很好 module test; import std; void main() { char[] palindrome = cast(char[])"able was I e
阅读全文
摘要：C:\Program Files\Microsoft Visual Studio\Installer\resources\app\ServiceHub\Services\Microsoft.VisualStudio.Setup.Service中的BackgroundDownload.exe.与前面的
阅读全文
摘要：原文 之前是这样: alias Thing = Test; 之后为: mixin("alias Thing = Test;"); 好处是,普通声明,编译器用伪并行处理声明,在求值顺序有意义的时候,这时可能出错. 用插件后,编译器按源码出现顺序处理插件.这样,来强制顺序. 在此,强制在创建Test之后
阅读全文
摘要：#include <常用> 构 A{ 单 串 b{"哈哈"};//这里的`单`. 虚 极 要要(串&行){中 1;} }; 构 B:公 A{ B(){b="啊啊";} 极 要要(串&行){ ... }//实现略. }; 空 主(){ A a;B b; 打印(a.b,b.b);//小心,单及静串 }/
阅读全文
摘要：元<元<类 B>类 G,类...T,类 A,整...I> 空 展开(序列<I...>,向量<A>&b){ ((G<T>::动作(b[I])),...); }//要用两个括号 元<元<类 B>类 F,类...T,类 A> 空 展开(向量<A>&b){ 断大小<T...>(b); 展开<F,T...>(
阅读全文
摘要：元<类...T,类 F,类 A,整...I> 空 展开(F&f,序列<I...>,向量<A>&b){ ((f<T>(b[I])),...); }//C++战力不够!//要用两个括号 元<类...T,类 F,类 A>空 展开(F&f,向量<A>&b){ 断大小<T...>(b); 展开<T...>(f
阅读全文
摘要：什么意思呢,vctip到处扫描,把自己的空程序,替换掉这个更新VS后更新的垃圾程序.
阅读全文
摘要：空 f(串&...a){ 打印(a...); } 空 主(){ 串 a{"啊"};f(a); }
阅读全文
摘要：module test; import std.stdio : writeln; import std.process : environment; /+ "druntime\win64.mak"和"phobos\win64.mak"要求根据`VS`版本得到(VCDIR和SDKDIR)变量 为得到这
阅读全文
