c++奇异模板继承示例.

过滤基:

//相当于个函数,少写点代码,不要继承,
用 量=向量<串>;
元<型名 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;
}