有没有办法解决模板类中的前向声明？

Question

I have a template class defined as such:

template <typename T> void ProxyNoOp(T *) {}
template <typename T> void ProxyDelete(T * ptrT) {delete ptrT;}

template <typename T, typename C, void (* Release)(T *) = ProxyNoOp<T>  >
class Proxy
{
public:
    class Container : public std::list<T *>
    {
    public:
        Container() {}
        ~Container() {clear();}

        void clear()
        {
            iterator clsEnd = end();
            for (iterator clsCurrent = begin(); clsCurrent != clsEnd; ++clsCurrent)
            {
                T * ptrT = *clsCurrent;
                static_cast<Proxy *>(ptrT)->m_ptrContainer = NULL;
                Release(ptrT);
            }   
        }
    };

private:
    iterator m_clsPosition;
    C *      m_ptrContainer;

public:
    Proxy() : m_ptrContainer(NULL) {}
    ~Proxy()
    {
        if ( m_ptrContainer != NULL )
        {
            Container * ptrContainer = static_cast<Container *>(m_ptrContainer);
            static_cast<std::list<T *> >(ptrContainer)->erase(m_clsPosition);
        }
    }

    C * GetContainer() const {return m_ptrContainer;}
};

A lot of the code has been removed or changed for the sake of brevity. The idea of the data structure is that not only does a container maintain references to contained elements, but the contained elements maintain a reference to the container PLUS their position in the container, making removal quick (constant time) and automatic (called in the destructor)

A problem with this approach can be demonstrated by this code:

#include "proxy.h" // the above template class

class Child;
class Parent : public Proxy<Child, Parent>::Container {};
class Child : public Proxy<Child, Parent> {};

When compiling Parent , the definition of Proxy<Child, Parent>::Container causes an error at this line: static_cast<Proxy *>(ptrT)->m_ptrContainer = NULL; - at the point in the compilation, Child has not been defined, only declared. If I change the declaration order of Parent and Child to be this:

#include "proxy.h"

class Parent;
class Child : public Proxy<Child, Parent> {};
class Parent : public Proxy<Child, Parent>::Container {};

the definition of Proxy<Child, Parent> causes an error at this line: Container * ptrContainer = static_cast<Container *>(m_ptrContainer); , the reason being the same as before - at that point in the compilation, Parent is not fully defined.

Is there any way I can get around this and still use templates? Is there a standard data structure in STL, BOOST, etc. that accomplishes this?

EDIT:

The code will not compile as-is, I should have been clearer about that (to quote myself from above: A lot of the code has been removed or changed for the sake of brevity. ). It doesn't actually use std::list<T *> , but a custom doubly linked that is effectively the same. I didn't want to post a ton of ancillary code when only asking about this one issue.

I wasn't asking for critique on the data structure itself (although I am fine to hear it), but for those wondering why it was created here are a couple examples:

A game engine has models and instances of those models, such as a war game where there is one tank model and any number of tanks created from it. The classes could be written as such:

class Instance;
class Model : public Proxy<Model, Instance, ProxyDelete<Instance> >::Container {...};
class Instance : public Proxy<Model, Instance, ProxyDelete<Instance> > {...};

When a model is deleted, all instances made from that model should also be deleted (hence the ProxyDelete<Instance> template parameter) since it doesn't make sense for an instance to exist without the model it was made from.

Suppose your graphical user interface (GUI) renderer keeps track of all visible elements (buttons, frames, etc.) so it knows what to render, but text is rendered differently since it is a different call to the graphics API:

class GuiTextElement;
class GuiRenderer : public Proxy<GuiRenderer, GuiTextElement, ProxyNoOp<GuiTextElement> >::Container {...};
class GuiTextElement : public Proxy<GuiRenderer, GuiTextElement, ProxyNoOp<GuiTextElement> > {...};

---

The less astute will say "why don't you simply add std::list<Instance *> as a member of the Model and std::list<GuiTextElement *> as a member of GuiRenderer ?". Here are a few reasons:

1. Elements that are "owned" by their containers are not automatically deleted when the container is destroyed (yes, I am aware of boost::ptr_list ).
2. There is no way, without adding another class member, to refer to the container using a contained element. For example, to get a Model from an Instance .
3. If you did add a class member to accomplish #2, you would also need to update it when elements are removed from their containers.
4. For the speed fanatics - if contained elements don't maintain an iterator to their position in the container, before that element can be removed the container must first be searched for it.

Answer 1

I don't think the code you've shown us exhibits the problem you're asking about.

I made minimal changes to get past the earlier compiler errors, so I could get to the point where I could reproduce your problem. But, having done so, your problem does not exist.

Here are my changes:

• Add #include <list> .
• Replace each instance of iterator with typename Container::iterator
• Make Container inherit from list publicly instead of privately, so I get access to its iterator type.

You can try adding them one by one to see what errors each one solves—none of them have anything to do with your problem. Or you can download the code and compile it yourself.

I compiled this with a three different compilers, clang-4.2, g++-4.6, and g++-4.2-apple; in both C++11 and C++98 modes where appropriate; with -Wall enabled. In all cases, it compiled without any errors or warnings.

Also I don't see how the referenced line could have the error you described. It doesn't matter whether T or C are incomplete, because all you do is:

• static_cast a T * to a Proxy * , which only requires having T declared, not defined.
• Access a member of a Proxy , which does not depend in any way on type T .
• Set a C * to NULL, which only requires having C declared, not defined.

The previous line depends on calling operator * on an iterator , and that's apparently a custom class of your that might be dependent on T or C in some way, but that couldn't possibly cause an error on the next line.

So, there are a few possibilities:

• The error is not the error your described, nor is it on the line you described, and the problem is in either the iterator class or the list class that you didn't show us.
• The code you've shown us is so different from your real code that it no longer has even a trace of the part that causes a problem.
• My trivial changes aren't as trivial as I thought and somehow fixed your problem.