Why am I getting "too many include files : depth = 1024"?

I'm using Visual Studio 2008 Express edition, and keep getting the following error:

"Cascadedisplay.h(4) : fatal error C1014: too many include files : depth = 1024.

Obviously I'm doing something very wrong with include files, but I just can't see what.

Basically, I have an interface class, StackDisplay, from which I want to derive CascadeDisplay in another file:

#if !defined __BASE_STACK_DISPLAY_H__
#define __BASE_STACK_DISPAY_H__

#include <boost\shared_ptr.hpp>
#include "CascadeDisplay.h"

namespace Sol
{
    class StackDisplay
    {
        public:
            virtual ~StackDisplay();
            static boost::shared_ptr<StackDisplay>
            make_cascade_display(boost::shared_ptr<int> csptr)
            {
                return boost::shared_ptr<StackDisplay>(new CascadeDisplay(csptr));
            }
    };
}
#endif

and then in CascadeDisplay.h:

#if !defined __CASCADE_DISPLAY_H__
#define __CASCADE_DISPAY_H__

#include "StackDisplay.h"
#include <boost\shared_ptr.hpp>

namespace Sol
{
    class CascadeDisplay: public StackDisplay
    {
        public:
            CascadeDisplay(boost::shared_ptr<int> csptr){};
    };
}

#endif

So what开发者_运维问答's up with that?

#if !defined __CASCADE_DISPLAY_H__
#define __CASCADE_DISPAY_H__

Second line should be:

#define __CASCADE_DISPLAY_H__

Same with:

#if !defined __BASE_STACK_DISPLAY_H__
#define __BASE_STACK_DISPAY_H__

Also, names that contain a double-underscore are reserved for the implementation, you are not allowed to create such names in your own code. Same goes for names that begin with a single underscore and an uppercase letter.

There is a typo in your guards

#if !defined __CASCADE_DISPLAY_H__     <--- here you have DISPLAY
#define __CASCADE_DISPAY_H__           <--- here you have DISPAY (no L!)

and yes, avoid double underscores in such names

Is #if !defined... legit? I always used #ifndef.

Either way, why does your "base" class require the reference to CascadeDisplay? That doesn't seem right. Consider replacing your call to create a new CascadeDisplay with a call to a pure virtual function in StackDisplay that your subclass must implement appropriately.

IE, something like (and forgive, I don't have a c++ compiler handy to check this):

namespace Sol
{
    class StackDisplay
    {
        public:
            virtual ~StackDisplay();
            boost::shared_ptr<StackDisplay>
            make_cascade_display(boost::shared_ptr<int> csptr)
            {
                return make_display(csptr);
            }

        protected:
            virtual boost::shared_ptr<StackDisplay> make_display(boost::shared_ptr<int> csptr) = 0;
    };

    class CascadeDisplay: public StackDisplay
    {
        public:
            CascadeDisplay(boost::shared_ptr<int> csptr){};

        protected:
            virtual boost::shared_ptr<StackDisplay> make_display(boost::shared_ptr<int> csptr)
            {
                return new CascadeDisplay(csptr);
            }
    };
}

I believe this solution is superior, in general, to the forward declaration because you're eliminating some tight coupling between your superclass and your subclass, and making a more generic interface besides. This lets you eliminate the #include of CascadeDisplay.h in StackDisplay.h.