I realize why member template functions cannot be virtual, but I am unsure exactly what the best workaround is.

I've some code such as this:

struct Entity
{
    template<typename It>
    virtual It GetChildren(It it) { return it; }
};

struct Person : public Entity
{
    template<typename It>
    virtual It GetChildren(It it) { *it++ = "Joe"; }
};

struct Node : public Entity
{
    Node left, right;
    const char *GetName() { return "dummy"; }

    template<typename It>
    virtual It GetChildren(It it)
    {
        *it++ = left.GetName();
        *it++ = right.GetName();
        return it;
    }
};

Clearly, I need dynamic dispatch. But considering that the courses are really pretty large, I'd rather not template the entire class. And That I still wish to support any type of iterator.

What's the easiest method to accomplish this?

If supporting any type of iterator may be the only factor you would like, you can utilize an iterator that utilizes type erasure. I believe there's an any_iterator implemented somewhere within the Boost Sandbox/Vault or Adobe Labs or one of these. This is actually the first derive from Google:

http://thbecker.net/free_software_utilities/type_erasure_for_cpp_iterators/any_iterator.html

Because you don't want to template whole class, and don't wish to make use of an iterator with type erasure, the only real option would be to create your personal iterator.

Incidentally, your example looks strange. You may can have a look regarding how to enhance the design, which may build your problem disappear.

You won't want to generically "support any type of iterator."

You need to fulfill the STL Container needs to supply an iterator that customers can generically support. Make an iterator, then offer an iterator typedef for the container:

class Entity_Iterator {
public:
    Entity_Iterator operator++() { /* et cetera */ }
    Entity& operator*() const { /* et cetera */ }
private:
    Entity* entity_ptr_;
    // et cetera
}

class Entity_Container {
public:
    typedef Entity_Iterator iterator;
    iterator begin() const { /* et cetera */ }
    iterator end() const  { /* et cetera */ }
private:
    Entity* head_;
    // et cetera
}

Now a person can stick to the STL Container convention to apply your container, and you will have the ability to apply STL Calculations for your container too:

Entity_Container x;
Entity_Container::iterator i = x.begin();
i->GetName();

Edit add link:

http://www.sgi.com/tech/stl/Container.html

Edit

I am attempting to Google a hyperlink to some complete C++ code stub template for applying an STL Container which i remember seeing once, but I am discovering it tough to Google STL template.

Edit

Get it done by doing this, and you will have the ability to write your container like a tree structure that may contain heterogeneous types inherited from Entity with virtual techniques, so it appears like is exactly what you are attempting to do?

Or possibly not?