过滤器模式（Filter Pattern）或标准模式（Criteria Pattern）是一种设计模式，这种模式允许开发人员使用不同的标准来过滤一组对象，通过逻辑运算以解耦的方式把它们连接起来。这种类型的设计模式属于结构型模式，它结合多个标准来获得单一标准。

意图

对同一组对象能够以不同过滤条件筛选出来

主要解决

能够以不同条件或条件的组合筛选对象

何时使用

一组对象需要根据属性作筛选时

如何解决

使用过滤器类进行筛选

应用实例

  1. 对用户信息根据不同条件如性别、婚姻状况筛选
  2. 对车辆根据根据不同条件如颜色、款式筛选

优点

能使用不同过滤器的组合方便的筛选对象

缺点

过滤器依赖对象的结构，对象属性变化时过滤器也需要变化，如示例中的婚姻状况增加了一种”离异”，则需要增加或修改过滤器

注意事项

过滤器应该尽量简单，复杂的过滤器应使用多个简单过滤器组合得到，这样当对象属性变化时，过滤器的改动能尽量小

示例

整理用户信息时，使用过滤器方便的筛选不同条件的人，比如筛选男性、女性、单身女性等等
image.png

  1. #include "pch.h"
  2. #include <iostream>
  3. #include <sstream>
  4. #include <vector>
  5. #include <algorithm>
  7. // 人
  8. class Person
  9. {
  10. public:
  11.     Person(int ID, std::string name, std::string gender, std::string maritalStatus)
  12.     {
  13.         if ("Male" != gender && "Female" != gender) { throw "Invalid Parameter"; }
  14.         if ("Single" != maritalStatus && "Married" != maritalStatus) { throw "Invalid Parameter"; }
  16.         this->ID = ID;
  17.         this->name = name;
  18.         this->gender = gender;
  19.         this->maritalStatus = maritalStatus;
  20.     }
  22.     std::string GetName()
  23.     {
  24.         return this->name;
  25.     }
  27.     std::string GetGender()
  28.     {
  29.         return this->gender;
  30.     }
  32.     std::string GetMaritalStatus()
  33.     {
  34.         return this->maritalStatus;
  35.     }
  37.     std::string Info()
  38.     {
  39.         std::string info;
  40.         std::ostringstream ostr;
  41.         ostr << "Person : [Name : " << name << ", Gender : " << gender << ", Marital Status : " << maritalStatus << "]";
  42.         return ostr.str();
  43.     }
  45.     bool operator == (const Person & person) const
  46.     {
  47.         return this->ID == person.ID;
  48.     }
  50.     bool operator < (const Person & person) const
  51.     {
  52.         return this->ID < person.ID;
  53.     }
  55. private:
  56.     int ID;
  57.     std::string name;
  58.     std::string gender;
  59.     std::string maritalStatus;
  60. };
  62. class ICriteria
  63. {
  64. public:
  65.     virtual std::vector<Person> meetCriteria(const std::vector<Person>& persons) = 0;
  66. };
  68. // 过滤为男性
  69. class MaleCriteria : public ICriteria
  70. {
  71. public:
  72.     virtual std::vector<Person> meetCriteria(const std::vector<Person>& persons)
  73.     {
  74.         std::vector<Person> resPersons;
  75.         for (Person p : persons)
  76.         {
  77.             if (p.GetGender() == "Male")
  78.             {
  79.                 resPersons.push_back(p);
  80.             }
  81.         }
  82.         return resPersons;
  83.     }
  84. };
  86. // 过滤为女性
  87. class FemaleCriteria : public ICriteria
  88. {
  89. public:
  90.     virtual std::vector<Person> meetCriteria(const std::vector<Person>& persons)
  91.     {
  92.         std::vector<Person> resPersons;
  93.         for (Person p : persons)
  94.         {
  95.             if (p.GetGender() == "Female")
  96.             {
  97.                 resPersons.push_back(p);
  98.             }
  99.         }
  100.         return resPersons;
  101.     }
  102. };
  104. // 过滤为已婚
  105. class MaritalCriteria : public ICriteria
  106. {
  107. public:
  108.     virtual std::vector<Person> meetCriteria(const std::vector<Person>& persons)
  109.     {
  110.         std::vector<Person> resPersons;
  111.         for (Person p : persons)
  112.         {
  113.             if (p.GetMaritalStatus() == "Married")
  114.             {
  115.                 resPersons.push_back(p);
  116.             }
  117.         }
  118.         return resPersons;
  119.     }
  120. };
  122. // 过滤为单身
  123. class SingleCriteria : public ICriteria
  124. {
  125. public:
  126.     virtual std::vector<Person> meetCriteria(const std::vector<Person>& persons)
  127.     {
  128.         std::vector<Person> resPersons;
  129.         for (Person p : persons)
  130.         {
  131.             if (p.GetMaritalStatus() == "Single")
  132.             {
  133.                 resPersons.push_back(p);
  134.             }
  135.         }
  136.         return resPersons;
  137.     }
  138. };
  140. // 与过滤器
  141. class AndCriteria : public ICriteria
  142. {
  143. public:
  144.     AndCriteria(ICriteria* pCriteriaA, ICriteria* pCriteriaB)
  145.     {
  146.         this->pCriteriaA = pCriteriaA;
  147.         this->pCriteriaB = pCriteriaB;
  148.     }
  150.     ~AndCriteria()
  151.     {
  152.         delete pCriteriaA;
  153.         pCriteriaA = nullptr;
  155.         delete pCriteriaB;
  156.         pCriteriaB = nullptr;
  157.     }
  159.     virtual std::vector<Person> meetCriteria(const std::vector<Person>& persons)
  160.     {
  161.         std::vector<Person> resPersons = pCriteriaA->meetCriteria(pCriteriaB->meetCriteria(persons));
  162.         return resPersons;
  163.     }
  165. private:
  166.     ICriteria* pCriteriaA;
  167.     ICriteria* pCriteriaB;
  168. };
  170. // 或过滤器
  171. class OrCriteria : public ICriteria
  172. {
  173. public:
  174.     OrCriteria(ICriteria* pCriteriaA, ICriteria* pCriteriaB)
  175.     {
  176.         this->pCriteriaA = pCriteriaA;
  177.         this->pCriteriaB = pCriteriaB;
  178.     }
  180.     ~OrCriteria()
  181.     {
  182.         delete pCriteriaA;
  183.         pCriteriaA = nullptr;
  185.         delete pCriteriaB;
  186.         pCriteriaB = nullptr;
  187.     }
  189.     virtual std::vector<Person> meetCriteria(const std::vector<Person>& persons)
  190.     {
  191.         std::vector<Person> resPersonsA = pCriteriaA->meetCriteria(persons);
  192.         std::vector<Person> resPersonsB = pCriteriaB->meetCriteria(persons);
  193.         std::vector<Person> resPersons;
  194.         std::set_union(resPersonsA.begin(), resPersonsA.end(),
  195.                        resPersonsB.begin(), resPersonsB.end(), std::back_inserter(resPersons));
  196.         return resPersons;
  197.     }
  199. private:
  200.     ICriteria* pCriteriaA;
  201.     ICriteria* pCriteriaB;
  202. };
  204. // 调用示例
  205. int main()
  206. {
  207.     std::vector<Person> persons;
  208.     persons.push_back(Person(1, "Bob", "Male", "Single"));
  209.     persons.push_back(Person(2, "Amy", "Female", "Married"));
  210.     persons.push_back(Person(3, "Mike", "Male", "Single"));
  211.     persons.push_back(Person(4, "Jhon", "Male", "Single"));
  212.     persons.push_back(Person(5, "Jimy", "Male", "Married"));
  213.     persons.push_back(Person(6, "Anna", "Female", "Single"));
  214.     persons.push_back(Person(7, "Alice", "Female", "Married"));
  215.     persons.push_back(Person(8, "Sue", "Female", "Single"));
  216.     persons.push_back(Person(9, "Jane", "Female", "Married"));
  217.     persons.push_back(Person(10, "Nancy", "Female", "Single"));
  219.     // 筛选男性
  220.     ICriteria* maleCriteria = new MaleCriteria();
  221.     std::vector<Person> males = maleCriteria->meetCriteria(persons);
  222.     std::cout << "Males:" << std::endl;
  223.     for (Person p : males)
  224.     {
  225.         std::cout << p.Info() << std::endl;
  226.     }
  228.     // 筛选单身女性
  229.     ICriteria* singleFemaleCriteria = new AndCriteria(new FemaleCriteria(), new SingleCriteria());
  230.     std::vector<Person> singleFemales = singleFemaleCriteria->meetCriteria(persons);
  231.     std::cout << "Single FeMales:" << std::endl;
  232.     for (Person p : singleFemales)
  233.     {
  234.         std::cout << p.Info() << std::endl;
  235.     }
  236. }
>>>
Males:
Person : [Name : Bob, Gender : Male, Marital Status : Single]
Person : [Name : Mike, Gender : Male, Marital Status : Single]
Person : [Name : Jhon, Gender : Male, Marital Status : Single]
Person : [Name : Jimy, Gender : Male, Marital Status : Married]
Single FeMales:
Person : [Name : Anna, Gender : Female, Marital Status : Single]
Person : [Name : Sue, Gender : Female, Marital Status : Single]
Person : [Name : Nancy, Gender : Female, Marital Status : Single]