C++ C++；不是命名空间

我真的不知道该怎么解释

我在名称空间中有两个类World和Entity：

阿耳特弥斯：：系统

和一个类组件

阿耳特弥斯：：成分

我已经在World和Entity方面遇到了问题，在尝试编译时，它说它们中的任何一个都不是声明的类型。（两者都包括对方） 因此，在这两个类中，在名称空间中，我都添加了一个转发声明。这似乎解决了问题

现在，当我尝试在我的组件.h中包含“world”时，会出现以下错误：

组件不是命名空间名称

我的组件类驻留在名称空间artemis:：Component中

这让我快发疯了。我真的不明白是什么导致了这个错误

标题组件.h

#ifndef _COMPONENT_H_
#define _COMPONENT_H_

#include <bitset>
#include "BitSize.h"
#include "World.h"
#include <unordered_map>
#include <typeinfo>
#include <string>
#include <iostream>
#include <assert.h>
//#include "EntityManager.h"

using namespace std;
using namespace artemis::system;

namespace artemis {
    namespace component {


        class Component {
            public:
                virtual ~Component() = 0;
            protected:
                Component(){};
        };


        /**
         * Identifies a bitset and id for a component object
         * Do not instantiate a ComponentType, instead use the ComponentTypeManager.
         * */
        class ComponentType {

            public:
                ComponentType();

                bitset<BITSIZE> getBit() const;
                int getId() const;
            private:

                static bitset<BITSIZE> nextBit;
                static int nextId;

                bitset<BITSIZE> bit;
                int id;
                void init();

        };


//Surpress unused variable warnning. Might need to rewrite it
//#pragma GCC diagnostic push
//#pragma GCC diagnostic ignored  "-Wunused-variable"
        /**
         * Manages the id and bitset for every component based on their type.
         * */

        class ComponentTypeManager {

            private:
                ComponentTypeManager();
                static unordered_map<size_t,ComponentType*> componentTypes;



        public:


                /**
                 *
                 **/
                static ComponentType & getTypeFor(const type_info &t);

                /**
                * Gets the component type object
                **/
                template<typename c>
                static ComponentType & getTypeFor() {

                    //Check if we are being legal with components and shizzle
                    //Component * c = (component*)0;

                    assert((std::is_base_of< Component, c >::value == true));

                    return getTypeFor(typeid(c));
                }

                /**
                * Gets the bit set of a component
                **/
                template<typename c>
                static bitset<BITSIZE> getBit() {

                    //Check if we are being legal with components and shizzle
                    //Component * c = (component*)0;

                    assert((std::is_base_of< Component, c >::value == true));

                    ComponentType & type = getTypeFor(typeid(c));
                    return type.getBit();
                }
                /**
                 * Gets the component id
                 **/
                template<typename c>
                static int getId() {

                    //Check if we are being legal with components and shizzle

                    assert((std::is_base_of< Component, c >::value == true));

                    ComponentType & type = getTypeFor(typeid(c));
                    return type.getId();
                };



                //typedef getCompBit bitset<BITSIZE>(*getBit<Component>)();

        };
//#pragma GCC diagnostic pop




        /*template<typename T>
        class ComponentMapper {

            private:
                //ComponentType * type;
                EntityManager * em;

            public:

                ComponentMapper(World &world) {
                    em = world.getEntityManager();
                    //type = ComponentTypeManager::getTypeFor<T>();
                }

                ~ComponentType() {
                    type = nullptr;
                    em = nullptr;
                }

                T & get(Entity * e) {
                    return &(T)em->getComponent<T>(e);
                }

        };*/

    };
};

#endif

\ifndef\u组件_
#定义组件_
#包括
#包括“BitSize.h”
#包括“World.h”
#包括
#包括
#包括
#包括
#包括
//#包括“EntityManager.h”
使用名称空间std；
使用名称空间artemis:：system；
名称空间阿耳特弥斯{
名称空间组件{
类组件{
公众：
virtual~Component（）=0；
受保护的：
组件（）{}；
};
/**
*标识组件对象的位集和id
*不要实例化ComponentType，而是使用ComponentTypeManager。
* */
类组件类型{
公众：
ComponentType（）；
bitset getBit（）常量；
int getId（）常量；
私人：
静态位集nextBit；
静态int nextId；
位集位；
int-id；
void init（）；
};
//超出未使用的变量警告。可能需要重写它
//#pragma GCC诊断推送
//#pragma GCC诊断被忽略“-Wunused变量”
/**
*根据每个组件的类型管理其id和位集。
* */
类组件类型管理器{
私人：
ComponentTypeManager（）；
静态无序映射组件类型；
公众：
/**
*
**/
静态组件类型和getTypeFor（const type_info&t）；
/**
*获取组件类型对象
**/
模板
静态组件类型&getTypeFor（）{
//检查我们是否对组件和外壳合法
//组件*c=（组件*）0；
断言（（std:：is_base_of：：value==true））；
返回getTypeFor（typeid（c））；
}
/**
*获取组件的位集
**/
模板
静态位集getBit（）{
//检查我们是否对组件和外壳合法
//组件*c=（组件*）0；
断言（（std:：is_base_of：：value==true））；
ComponentType&type=getTypeFor（typeid（c））；
返回类型：getBit（）；
}
/**
*获取组件id
**/
模板
静态int getId（）{
//检查我们是否对组件和外壳合法
断言（（std:：is_base_of：：value==true））；
ComponentType&type=getTypeFor（typeid（c））；
返回类型：getId（）；
};
//typedef getCompBit位集（*getBit）（）；
};
//#pragma-GCC-diagnostic-pop
/*模板
类组件映射器{
私人：
//组件类型*类型；
实体管理器*em；
公众：
组件映射器（世界和世界）{
em=world.getEntityManager（）；
//type=ComponentTypeManager:：getTypeFor（）；
}
~ComponentType（）{
类型=空PTR；
em=nullptr；
}
T&get（实体*e）{
返回和（T）em->getComponent（e）；
}
};*/
};
};
#恩迪夫

标题实体.h

#ifndef _ENTITY_H
#define _ENTITY_H

#include <bitset>
#include <string>
#include <cstddef>
#include <typeinfo>
#include "BitSize.h"
#include "Component.h"
#include "ImmutableBag.h"
#include "World.h"
//#include "EntityManager.h"

using namespace artemis::util;
using namespace artemis::component;
//using namespace artemis;
using namespace std;



namespace artemis {
    namespace system {
        class World;
        class Entity {

            private:
                int id;
                long int uniqueId;
                bitset<BITSIZE> typeBits;
                bitset<BITSIZE> systemBits;
                World * world;
                //EntityManager * entityManager;
            protected:

            public:
                Entity(World * world, int id);
                ~Entity();
                int getID();
                void setUniqueId(long int uniqueId);
                long int getUniqueID();

                bitset<BITSIZE> getTypeBits();
                void addTypeBit(bitset<BITSIZE> bit);
                void removeTypeBit(bitset<BITSIZE> bit);
                bitset<BITSIZE> getSystemBits();
                void addSystemBit(bitset<BITSIZE> bit);
                void removeSystemBit(bitset<BITSIZE> bit);
                void setSystemBits(bitset<BITSIZE> systemBits);
                void setTypeBits(bitset<BITSIZE> typeBits);
                void reset();

                string toString();

                void addComponent(Component * c);

                //Might change to non template
                template<typename c>
                void removeComponent() {
                    //entityManager->removeComponent(this,ComponentTypeManager::getTypeFor<c>());
                }

                void removeComponent(ComponentType & type);
                bool isActive();

                Component * getComponent(ComponentType & type);

                /*template<typename c>
                Component * getComponent() {
                    return (c)entityManager->getComponent(ComponentTypeManager.getTypeFor<c>());
                }*/

                ImmutableBag<Component*> * getComponents();
                void refresh();
                void remove();
                void setGroup(string group);
                void setTag(string tag);


        };
    };
};
#endif // $(Guard token)

\ifndef\u实体
#定义实体
#包括
#包括
#包括
#包括
#包括“BitSize.h”
#包括“组件h”
#包括“ImmutableBag.h”
#包括“World.h”
//#包括“EntityManager.h”
使用名称空间artemis:：util；
使用名称空间artemis:：component；
//使用名称空间artemis；
使用名称空间std；
名称空间阿耳特弥斯{
名称空间系统{
阶级世界；
类实体{
私人：
int-id；
长内唯一性；
位集排字位；
位集系统位；
世界*世界；
//EntityManager*EntityManager；
受保护的：
公众：
实体（世界*世界，国际id）；
~Entity（）；
int getID（）；
void setUniqueId（long int uniqueId）；
long int getUniqueID（）；
位集getTypeBits（）；
void addTypeBit（位集位）；
void removeTypeBit（位集位）；
bitset getSystemBits（）；
void addSystemBit（位集位）；
void removeSystemBit（位集位）；
无效设置系统位（位设置系统位）；
无效设置类型位（位设置类型位）；
无效重置（）；
字符串toString（）；
无效组件（组件*c）；
//可能会更改为非模板
模板
void removeComponent（）{
//entityManager->removeComponent（这是ComponentTypeManager:：getTypeFor（））；
}
#ifndef _WORLD_H_
#define _WORLD_H_

//#include "SystemManager.h"
//#include "EntityManager.h"
#include "ImmutableBag.h"
#include "Entity.h"

using namespace artemis::util;



namespace artemis {
    namespace system {

    class Entity;

        class World {
            public:
                World();
                ~World();
                //SystemManager * getSystemManager();
                //EntityManager * getEntityManager();
                //TagManager *   getTagManager();
                //GroupManager * getGroupManager();
                int getDelta();
                void setDetla(int delta);
                void deleteEntity(Entity *e);
                void refreshEntity(Entity *e);
                //Entity* createEntity();
                //Entity* getEntity(int entityID);
                void loopStart();



            private:
                //SystemManager * systemManager;
                //EntityManager * entityManager;
                //TagManager * tagManager;
                //GroupManager * grouManager;
                int delta;
                Bag<Entity*> refreshed;
                Bag<Entity*> deleted;



        };
    };
};
#endif // $(Guard token)