Node与NodeVisitor
osg::ref_ptr< osg::Node> model;
NodeVisitor vv( TRAVERSE_ALL_CHILDREN);
model->accept( vv);
假设model的模型结构如图：
则model->accept( vv);多态，相当于调用Group::accept(NodeVisitor)。
注意，我开始误认为Group没有对accept()进行重写，
但后来在遍历Geode结点时，发现Geode类的定义中有一个META_Node(osg, Geode)，才发现这些节点都调用了META_Node宏，而
META_Node宏里有个virtual void accept(osg::NodeVisitor& nv)
{ if (nv.validNodeMask(*this)) { nv.pushOntoNodePath(this); nv.apply(*this); nv.popFromNodePath(); }
原来这些节点都重写accept虚函数。这样才是正确的。这个宏定义代码和voidNode::accept(NodeVisitor& nv)的实现完全相同。
将Group的META_Node宏中的accept展开，为：
void Group::accept(NodeVisitor& nv)
{
if (nv.validNodeMask(*this))
{
nv.pushOntoNodePath(this);
nv.apply(*this);
nv.popFromNodePath();
}
}
其中nv.apply(*this);因为this指针是Group*型，所以实际调用的是NodeVisitor::apply( Group& node)，其中node指向Group对象
（注：如果是void Node::accept(NodeVisitor& nv){nv.apply(*this);} 则调用的不是NodeVisitor::apply( Group& node)，因为nv.apply(*this)中的this参数是Node*型，
应与apply( Node*)匹配，而apply( Group*)则无法匹配，因为Node*不能隐式转换为Group*。示例程序如文章最后）：
void NodeVisitor::apply(Group & node)
{
traverse(node);
}
NodeVisitor类中
inline void traverse(Node& node)
{
if (_traversalMode==TRAVERSE_PARENTS) node.ascend(*this);
else if (_traversalMode!=TRAVERSE_NONE) node.traverse(*this);
}
由于此程序代码中NodeVisitor设置的遍历模式为TRAVERSE_ALL_CHILDREN（而不是默认的TRAVERSE_NONE），故调用Group::traverse(NodeVisitor):
void Group::traverse(NodeVisitor& nv)
{
for(NodeList::iterator itr=_children.begin();
itr!=_children.end();
++itr)
{
(*itr)->accept(nv);
}
}
表示对其每一个孩子进行遍历，递归调用。相当于深搜。
附：
Node类的traverse()函数为空：
virtual void traverse(NodeVisitor& /*nv*/) {}
递归调用过程如下图：
对以下代码：
#include "stdafx.h"
#include <iostream>
#include <string>
using namespace std;
class A;
class B;
class NodeVisitor
{
public:
void apply( A& a)
{
cout<< "apply( A& a)"<< endl;
}
void apply( B& b)
{
cout<< "apply( B& b)"<< endl;
}
};
class A
{
public:
void accept( NodeVisitor& nv)
{
nv.apply( *this);//this是A*型，故调用apply( A*)，即apply( A& a)
}
};
class B: public A
{};
int _tmain(int argc, _TCHAR* argv[])
{
B b;
NodeVisitor nv;
b.accept( nv);//最终调用apply( A& a)。
system("pause");
return 0;
}
如果上述代码中实现了B的accept()，则：
#include "stdafx.h"
#include <iostream>
#include <string>
using namespace std;
class A;
class B;
class NodeVisitor
{
public:
void apply( A& a)
{
cout<< "apply( A& a)"<< endl;
}
void apply( B& b)
{
cout<< "apply( B& b)"<< endl;
}
};
class A
{
public:
void accept( NodeVisitor& nv)
{
nv.apply( *this);//this是A*型，故调用apply( A*)，即apply( A& a)
}
};
class B: public A
{
public:
void accept( NodeVisitor& nv)
{
nv.apply( *this);//this是B*型，故调用apply( B*)，即apply( B& b)
}
};
int _tmain(int argc, _TCHAR* argv[])
{
B b;
NodeVisitor nv;
b.accept( nv);//调用B::accept()，最终调用apply( B& b)。
system("pause");
return 0;
}
―――――――
Visitor模型示例如下：
class Node;
class Node_derived1;
class NodeVisitor
{
public:
virtual void apply( Node& n)
{
cout<< "NodeVisitor::apply( Node& n)"<< endl;
}
virtual void apply( Node_derived1& n)
{
cout<< "NodeVisitor::apply( Node_derived1& n)"<< endl;
}
};
class NodeVisitor_Derived1: public NodeVisitor
{
public:
virtual void apply( Node& n)//重写有关Node基类的函数
{
cout<< "NodeVisitor_Derived1::apply( Node& n)"<< endl;
}
virtual void apply( Node_derived1& n)//写自定义的函数
{
cout<< "NodeVisitor_Derived1::apply( Node_derived1& n)"<< endl;
}
};
class Node
{
public:
virtual void accept( NodeVisitor& nv)
{
nv.apply( *this);//this为Node*，与apply( Node*)匹配，调用apply( Node & n)
}
};
class Node_derived1: public Node
{
public:
virtual void accept( NodeVisitor& nv)
{
nv.apply( *this);//this为Node_derived1*，与apply(Node_derived1*)匹配，调用apply( Node_derived1& n)
}
};
int _tmain(int argc, _TCHAR* argv[])
{
Node n;
NodeVisitor nv;
n.accept( nv);//调用NodeVisitor::apply( Node& n)
Node_derived1 n1;
NodeVisitor_Derived1 nv1;
n1.accept( nv1);//调用NodeVisitor_Derived1::apply( Node_derived1& n)
system("pause");
return 0;
}
Node和NodeVisitor分别是节点基类，节点访问器基类。可以从它们继承，如Node_derived1对应NodeVisitor_Derived1。
如果想再添加Node_derived2~NodeVisitor_Derived2、Node_derived3~NodeVisitor_Derived3。但有个缺点，
就是每次除了加2个类，还需修改NodeVisitor基类，即在NodeVisitor类中加入virtualvoid apply( Node_derived_N& n)。
―――――――――――
OSG中的Node、Group、Geode的访问如下：
void NodeVisitor::apply(Node& node)
{
traverse(node);
}
void NodeVisitor::apply(Group& node)
{
traverse(node);
}
void NodeVisitor::apply(Geode& node)
{
apply(static_cast<Node&>(node));
}
inline void NodeVisitor::traverse(Node& node)
{
if (_traversalMode==TRAVERSE_PARENTS) node.ascend(*this);
else if (_traversalMode!=TRAVERSE_NONE) node.traverse(*this);
}
void Node::accept(NodeVisitor& nv)
{ if (nv.validNodeMask(*this))
{
nv.pushOntoNodePath(this);
nv.apply(*this);
nv.popFromNodePath();
}}
virtual void Node::traverse(NodeVisitor& /*nv*/) {}
virtual void Group::accept(osg::NodeVisitor& nv)
{ if (nv.validNodeMask(*this)) { nv.pushOntoNodePath(this); nv.apply(*this); nv.popFromNodePath(); }}
void Group::traverse(NodeVisitor& nv)
{
for(NodeList::iterator itr=_children.begin();
itr!=_children.end();
++itr)
{
(*itr)->accept(nv);
}}
virtual void Geode::accept(osg::NodeVisitor& nv)
{ if (nv.validNodeMask(*this)) { nv.pushOntoNodePath(this); nv.apply(*this); nv.popFromNodePath(); }}