一、解释器模式
1. 什么是解释器模式
interpreter Pattern，解释器模式，是一种行为型模式。解释器模式提供一种对自定义语句的解释机制，解释器模式包含以下几种角色：
- Context：解释器的上下文环境，包含了不属于解释器的其他信息；
- AbstractExpression：抽象解释器，定义了一个抽象的解释操作接口；
- ConcreteExpression：具体解释器，实现对相关操作的解释；
2. 解释器模式案例
定义上下文环境
1. class Context 2. { 3. private: 4. int data; 5. int ret; 6. public: 7. void set_data(int data) 8. { 9. this->data = data; 10. } 11. void set_ret(int ret) 12. { 13. this->ret = ret; 14. } 15. int get_data() 16. { 17. return this->data; 18. } 19. int get_ret() 20. { 21. return this->ret; 22. } 23. };
定义抽象解释器类，并实现一个加法解释器，加法解释器的操作是对传入的数据执行+1操作
1. class Expression 2. { 3. protected: 4. Context* context; 5. public: 6. virtual void interpret(Context* context) = 0; 7. }; 8. 9. class PlusExpression : public Expression 10. { 11. virtual void interpret(Context* context) 12. { 13. int temp = context->get_data(); 14. temp++; 15. context->set_ret(temp); 16. } 17. };
客户端操作，向加法解释器传入一个数据，打印处理结果
1. int main() 2. { 3. Expression* e = NULL; 4. Context* data = NULL; 5. 6. e = new PlusExpression; 7. data = new Context; 8. 9. data->set_data(1); 10. cout << "原始数据：" << data->get_data() << endl; 11. e->interpret(data); 12. data->get_ret(); 13. cout << "经加法解释器处理后：" << data->get_ret() << endl; 14. 15. delete data; 16. delete e; 17. 18. system("pause"); 19. return 0; 20. }
二、迭代器模式
1. 什么是迭代器模式
Iterator Pattern，迭代器模式，是行为型模式的一种。迭代器模式提供了一种从外部遍历访问一个容器的方法，并且在不需知道容器内部细节的前提下就可以完成对容器的顺序遍历。所以，创建迭代器的容器应该将自身的引用（this指针）传递给迭代器，迭代器通过持有的这个容器的引用来实现对容器的遍历。
- Iterator：迭代抽象类，用于提供实现迭代的最小方法集，一般包括获取开始对象、获取下一个对象、获取当前对象、判断是否结束这几个方法；
- ConcreteIterator：具体的迭代器，实现抽象迭代器定义的方法；
- Aggregate：聚集抽象类，可以理解为一个容器的接口；
- ConcreteAggregate：具体聚集类，容器的实现类；
2. 迭代器模式案例
定义一个抽象的迭代器类
1. class Iterator 2. { 3. public: 4. virtual void first() = 0; 5. virtual void next() = 0; 6. virtual bool is_done() = 0; 7. virtual int current_item() = 0; 8. };
定义抽象容器类
1. class Aggregate 2. { 3. public: 4. virtual Iterator* create_iterator() = 0; 5. virtual int get_item(int index) = 0; 6. virtual int get_size() = 0; 7. };
实现一个int类型的迭代器
1. class IntIterator : public Iterator 2. { 3. private: 4. Aggregate* age; 5. int index; 6. public: 7. IntIterator(Aggregate* age) //迭代器应该持有一个创建迭代器的容器的引用，这样才能通过迭代器访问容器 8. { //谁创建迭代器就把谁的引用传递给迭代器 9. this->age = age; 10. this->index = 0; 11. } 12. virtual void first() 13. { 14. index = 0; 15. } 16. virtual void next() 17. { 18. if (index < age->get_size()) 19. { 20. index++; 21. } 22. } 23. virtual bool is_done() 24. { 25. if (index == age->get_size()) 26. { 27. return true; 28. } 29. return false; 30. } 31. virtual int current_item() 32. { 33. return age->get_item(index); 34. } 35. };
定义一个int类型的容器
1. class IntArray : Aggregate 2. { 3. private: 4. int size; 5. int* array; 6. public: 7. IntArray(int size) 8. { 9. this->size = size; 10. array = new int[size]; 11. for (int i = 0; i < size; i++) 12. { 13. array[i] = i + 1; 14. } 15. } 16. ~IntArray() 17. { 18. if (array != NULL) 19. { 20. delete array; 21. array = NULL; 22. } 23. this->size = 0; 24. } 25. virtual Iterator* create_iterator() 26. { 27. return new IntIterator(this); //把自己的引用传给迭代器 28. } 29. virtual int get_item(int index) 30. { 31. return array[index]; 32. } 33. virtual int get_size() 34. { 35. return this->size; 36. } 37. };
客户端，通过迭代器来遍历数组
1. int main() 2. { 3. Iterator* it = NULL; 4. IntArray* array = NULL; 5. 6. array = new IntArray(10); 7. it = array->create_iterator(); 8. cout << "遍历数组："; 9. for (; !(it->is_done()); it->next()) 10. { 11. cout << it->current_item() << " "; 12. } 13. cout << endl; 14. 15. system("pause"); 16. return 0; 17. }
