访问者模式表示一个作用于某对象结构中的各元素的操作，可用于在不改变各元素的类的前提下定义作用于这些元素的新操作。 ```cpp #include <iostream> #include <memory> struct ConcreteElement1; struct ConcreteElement2; // 访问者基类 struct Visitor { virtual ~Visitor() {} virtual void Visit(ConcreteElement1* element) = 0; virtual void Visit(ConcreteElement2* element) = 0; }; // 被访问者基类 struct Element { virtual ~Element() {} virtual void Accept(Visitor& visitor) = 0; }; // 具体的访问者 struct ConcreteVisitor : public Visitor { virtual void Visit(ConcreteElement1* element) override { std::cout << "Visit ConcreteElement1" << std::endl; } virtual void Visit(ConcreteElement2* element) override { std::cout << "Visit ConcreteElement2" << std::endl; } }; // 具体被访问者 struct ConcreteElement1 : public Element { virtual void Accept(Visitor& visitor) override { visitor.Visit(this); } }; // 具体被访问者 struct ConcreteElement2 : public Element { virtual void Accept(Visitor& visitor) override { visitor.Visit(this); } }; void testVisitor() { ConcreteVisitor v; std::shared_ptr<Element> emt1(new ConcreteElement1()); std::shared_ptr<Element> emt2(new ConcreteElement2()); emt1->Accept(v); emt2->Accept(v); } int main(int argc, char** argv) { testVisitor(); return 0; } ``` 运行结果： ``` Visit ConcreteElement1 Visit ConcreteElement2 ``` ## C++11改进访问者模式 ```cpp #include <iostream> #include <memory> template <typename... Types> struct Visitor; template <typename T, typename... Types> struct Visitor<T, Types...> : Visitor<Types...> { using Visitor<Types...>::Visit; virtual void Visit(const T&) = 0; }; template <typename T> struct Visitor<T> { virtual void Visit(const T&) = 0; }; struct stA; struct stB; struct Base { /** * 定义通用的访问者类型，它可以访问stA和stB * typedef Visitor<stA, stB> myVisitor; 自动生成 * struct Visitor<stA, stB> { * virtual void Visit(const stA&) = 0; * virtual void Visit(const stB&) = 0; * } */ typedef Visitor<stA, stB> myVisitor; virtual void Accept(myVisitor&) = 0; }; struct stA : public Base { double val; virtual void Accept(myVisitor& v) override { v.Visit(*this); } }; struct stB : public Base { int val; virtual void Accept(myVisitor& v) override { v.Visit(*this); } }; struct PrintVisitor : Base::myVisitor { void Visit(const stA& a) override { std::cout << "from stA: " << a.val << std::endl; } void Visit(const stB& b) override { std::cout << "from stB: " << b.val << std::endl; } }; void testVisitor() { PrintVisitor vis; stA a; a.val = 8.97; stB b; b.val = 8; Base* base = &a; base->Accept(vis); base = &b; base->Accept(vis); } int main(int argc, char** argv) { testVisitor(); return 0; } ``` 运行结果： ``` from stA: 8.97 from stB: 8 ```