过滤器模式

过滤器模式(Filter Pattern)，又叫标准模式(Criteria Pattern)，是一种结构型模式，通过结合多个标准来获得单一标准。

这种设计模式允许开发人员使用不同的标准来过滤一组对象，通过逻辑运算以解耦的方式把它们连接起来。

优缺点

优点：

1、体现了各功能模块的“黑盘”特性及高内聚、低耦合的特点。

2、可以将整个系统的输入，输出行为看成是多个过滤器行为的简单合成。

3、支持软件功能模块的重用。

4、便于系统维护：新的过滤器可以添加到现有系统中来，旧的可以由改进的过滤器替换。

5、支持某些特定的分析，如吞吐量计算、死锁检测等。

6、支持并行操作，每个过滤器可以作为一个单独的任务完成。

缺点：

1、通常导致系统处理过程的成批操作。

2、需要设计者协调两个相对独立但又存在关系的数据流。

3、可能需要每个过滤器自己完成数据解析和合成工作（如加密和解密），从而导致系统性能下降，并增加了过滤器具体实现的复杂性。
注意事项

1、构建过滤规则时不要太繁琐。

2、注意区分过滤和拦截的功能差异。

代码实现

person.h
构建类 Person，可输出自己的属性，判断是否在一个数组中

#include <string>
#include <vector>
#include <iostream>
using namespace std;
 
class Person
{
public:
    Person(string name, string gender, int age) : name(name), gender(gender), age(age) {}
 
    void printf()
    {
        cout << "student name: " + name +
                ", gender: " + gender +
                ", age: " + std::to_string(age) << endl;
    }
 
    bool judVec(std::vector<Person*> vec)
    {
        auto iter = std::find(std::begin(vec), std::end(vec), this);
        return (iter == std::end(vec));
    }
 
    string getName() { return this->name; }
 
    string getGender() { return this->gender; }
 
    int getAge() { return this->age; }
 
private:
    string name;
    string gender;
    int age;
};

interface.h
创建抽象类 - 过滤器；创建实体类 - 过滤器、男性过滤器、女性过滤器、年龄过滤器
男性和年龄过滤器、女性或年龄过滤器

#include "person.h"
#include <algorithm>
 
class Criteria  //基类-过滤器
{
public:
    Criteria() {}
    virtual ~Criteria() {}
 
    virtual std::vector<Person *> filter(std::vector<Person *> vector) = 0;
};
 
class MaleCriteria: public Criteria //子类-男性过滤器
{
public:
    std::vector<Person *> filter(std::vector<Person *> vector)
    {
        std::vector<Person *> result;
 
        for(size_t i = 0; i < vector.size(); i++)
        {
            if(vector.at(i)->getGender() == "male")
            {
                result.push_back(vector.at(i));
            }
        }
 
        return result;
    }
};
 
class FemaleCriteria: public Criteria   //子类-女性过滤器
{
public:
    std::vector<Person *> filter(std::vector<Person *> vector)
    {
        std::vector<Person *> result;
 
        for(size_t i = 0; i < vector.size(); i++)
        {
            if(vector.at(i)->getGender() == "female")
            {
                result.push_back(vector.at(i));
            }
        }
 
        return result;
    }
};
 
class AgeCriteria: public Criteria  //子类-年龄过滤器
{
public:
    std::vector<Person *> filter(std::vector<Person *> vector)
    {
        std::vector<Person *> result;
 
        for(size_t i = 0; i < vector.size(); i++)
        {
            if(vector.at(i)->getAge() > 18) {
                result.push_back(vector.at(i));
            }
        }
 
        return result;
    }
};
 
class AndCriteria: public Criteria  //子类-与 && 过滤器
{
public:
    AndCriteria(Criteria *firstCriteria, Criteria *secondCriteria): firstCriteria(firstCriteria), secondCriteria(secondCriteria) {}
 
    std::vector<Person *> filter(std::vector<Person *> vector)
    {
        std::vector<Person *> firstvector = firstCriteria->filter(vector);
        return secondCriteria->filter(firstvector);
    }
 
private:
    Criteria *firstCriteria;
    Criteria *secondCriteria;
};
 
class OrCriteria: public Criteria   //子类- 或 || 过滤器
{
public:
    OrCriteria(Criteria *firstCriteria, Criteria *secondCriteria) : firstCriteria(firstCriteria), secondCriteria(secondCriteria) {}
 
    std::vector<Person *> filter(std::vector<Person *> vector)
    {
        std::vector<Person *> firstvector = firstCriteria->filter(vector);
        std::vector<Person *> secondvector = secondCriteria->filter(vector);
 
        for(auto it: firstvector)
        {
            if (it->judVec(secondvector))
            {
                secondvector.push_back(it);
            }
        }
 
        return secondvector;
    }
 
private:
    Criteria *firstCriteria;
    Criteria *secondCriteria;
};