过滤基:
//相当于个函数,少写点代码,不要继承,
用 量=向量<串>;
元<型名 T>构 过滤基{//静态分发,继续往下层
出向量 出;极 继续=0;
显 过滤基(常 符*b){串 a=b;初化(a);}
显 过滤基(串&a){初化(a);}
空 特初化(){}
空 初化(串&a){//c++继承
静转<T*>(本)->特初化();出.置出(a);
}//每次都要转一下.不能保存指针,要变.
//下面转成引用却不行,派生类可隐藏基类
极 要要(量&p){中 静转<T*>(本)->要要(p);}
串 形式(量&p){中 静转<T*>(本)->形式(p);}
空 动作(量&p){//p为每项,
静转<T*>(本)->出.加(形式(p));
//打印(静转<T*>(本)->出.出);
//打印(中类名<T>());//看起来没问题
}//要要时的动作
//静转,编译期就可确定.动态,运行时.
//让所有函数都这样,该如何?
};//继承它,并实现它的几个函数,使用时,加过滤(..).
//要用=0,来写.一层层过滤的
都要静转<T*>为指针.
元<型名 T>构 过基:公 过滤基<T>{//使用基类同名函数
用 过滤基::过滤基;
串 形式(量&p){中 直连串(p);}
};//默认形式,这样干//只能从直接基继承构造函数
构 过逗:公 过基<过逗>{//派生类<隐藏>基类实现
用 过基::过基;
空 特初化(){继续=1;}//特化一下;
极 要要(量&p){//要第二行有逗号的
串 b=p[1];如(!b.大小())中 假;
如(b.后()==',')中 真;中 假;
}
串 形式(量&p){//最后有个逗号
去尾(p[1]);中 直连串(p);
}//主要就是"译.txt",特殊形式这样干
};//加一个是否往下流(类似于程序的断),比如
//加个继续,类似(开关()省略断),
构 过英:公 过基<过英>{
用 过基::过基;
极 有中(串&a){
对(符 c:a)如(可中符(c))中 真;中 假;
}
极 要要(量&p){//要没有中文的
串 b=p[1];如(!b.大小())中 假;
如(有中(b))中 假;中 真;
}//过英,有问题,改这里了
};
构 剩余:公 过基<剩余>{
用 过基::过基;
极 要要(量&p){中 真;}
};
构 取逗去英{//有多个过滤类型.
向量<向量<串>>列;文分 a{"译.txt"};
过逗 m{"逗短语.txt"};过英 n{"译平凡.txt"};
剩余 o{"译译.txt"};
用 T=变量<过逗,过英,剩余>;向量<T>过{m,n,o};
静 常式 整 I=变量大小值<T>;
//向量<过滤基*>过{&m,&n,&o};
//静态分发,就是三个指针而已,就是指针
空 动作(向量<串>&p){//过的顺序也是有讲究的
整 i=0;极 要下=0;
对(动&t:过){//没有类型.
切为编<I>(i,[&](动 k){//f取上下文
常式 整 N=推导(k)::值;
静 动 g=取<N>(t);要下=0;
如(!g.要要(p)){要下=1;中;}
g.动作(p);如(g.继续)要下=1;
});//这里必须是静,不然又回收了
//打印("333",要下);
i++;如(要下)下;异 中;
}//这种f里面函数变化都要小心.要用静态变量.
}//如果有一个满足了,就中.如果不满足,则继续
//频繁析构的就要考虑可能是函数期有问题了.
取逗去英(){//满足多种过滤条件
数分向量<2>(a.们,列);//先去
对(动&p:列){//将两个条件
丢符(p[0],'+');动作(p);
}//各自压自自的地方//第一项
}
};//相当于各层过滤各层走
空 主(){//两个任务,
取逗去英 a;
}
关键的好处就是可以统一指挥各个类.用向量<变量>统一一下.
