Глобальные объекты и места их обитания29.11.2016 16:34

Итак, что же за зверь этот глобальный объект, как его приручить и пользоваться удобствами, сведя недостатки к минимуму? Давайте разбираться вместе.

Существует масса способов создать глобальный объект. Самый простой — объявить extern-переменную в заголовочном файле и создать её экземпляр в cpp:

// header file
extern Foo g_foo;
// cpp file
Foo g_foo;

void PrepareFoo(...)
{
FooManager::getInstance().Initialize ();
}

В общем случае предпочтительно использование локальных переменных вместо глобальных. К примеру, если вам нужно отрисовать некий объект и есть глобальный Renderer, то лучше его передать напрямую в метод void Draw(Renderer& render_instance), а не использовать глобальный Render::Instance(). Больше примеров и обоснований, почему не стоит использовать синглтон, можно почитать в посте.

Однако совсем без глобальных объектов обойтись сложно. Если нужен доступ к настройкам или прототипам, то к каждому объекту не прицепишь все нужные контейнеры, фабрики и прочие параметры. Этот случай мы и будем рассматривать.

Для начала постановка задачи:

1. К объекту должен быть доступ из любой части программы.
2. Все перерабатываемые глобальные объекты должны храниться централизованно — для простоты поддержки.
3. Возможность добавлять и/или заменять глобальные объекты в зависимости от контекста — реальный запуск или тестирование.

Интересное решение было подсмотрено в недрах CryEngine (смотреть SSystemGlobalEnvironment). Глобальные объекты завёрнуты в одну структуру и являются указателями на абстрактные сущности, которые инициализируются в нужный момент в нужном месте программы. Никаких дополнительных накладных расходов, никаких лишних надстроек, контроль за типом во время компиляции — красота!

CryEngine представляет собой достаточно старый и годами обточенный проект, где все интерфейсы устаканились, а новое прикручивается подобно тому, что существует на данный момент. Поэтому нет необходимости придумывать дополнительные обёртки или способы работы с глобальными объектами. Есть и другой вариант — молодой и бурно развивающийся проект, где нет строгих интерфейсов, где функционал постоянно меняется, что сподвигает вносить правки в интерфейсы достаточно часто. Хочется иметь решение, которое поможет в старых проектах производить рефакторинг, а в новых, где всё же необходим глобальный доступ, минимизировать недостатки использования. Для поиска ответа можно попробовать подняться на уровень выше и посмотреть на проблему под другим углом — создать хранилище глобальных объектов, наследуемых от GlobalObjectBase. Использование оболочки добавит операции во время исполнения, поэтому обязательно нужно обратить внимание на производительность после изменений.

Для начала необходимо создать базовый класс, наследников которого можно будет поместить в объект-хранилище.

	class GlobalObjectBase
	{
	public:
		virtual ~GlobalObjectBase() {}
	};

class GlobalObjectsStorage
{
private:
	using ObjPtr = std::unique_ptr;
	std::vector m_dynamic_globals;
private:
	GlobalObjectBase* GetGlobalObjectImpl(size_t i_type_code) const
	{ … }
	void AddGlobalObjectImpl(std::unique_ptr ip_object)
	{ … }
	void RemoveGlobalObjectImpl(size_t i_type_code)
	{ … }
public:
	GlobalObjectsStorage() {}	

	template 
	void AddGlobalObject()
	{
		AddGlobalObjectImpl(std::make_unique());
	}
	template 
	ObjectType* GetGlobalObject() const
	{
		return static_cast(GetGlobalObjectImpl(typeid(ObjectType).hash_code());
	}

	template 
	void RemoveGlobalObject()
	{
		RemoveGlobalObjectImpl(typeid(ObjectType).hash_code());
	}
};

Итак, первый тест-драйв — работает!

class FooManager : public GlobalObjectBase
{
public:
	void Initialize() {}
};

static GlobalObjectsStorage g_storage; // имитируем глобальность хранилища

void Test()
{
	// делаем объект "глобальным"
	g_storage.AddGlobalObject();
	// используем
	g_storage.GetGlobalObject()->Initialize();
	// и удаляем
	g_storage.RemoveGlobalObject();
}

template 
class ObjectStorageBase
{
private:
	virtual BaseObject* GetGlobalObjectImpl(size_t i_type_code) const = 0;
	virtual void AddGlobalObjectImpl(std::unique_ptr ip_object) = 0;
	virtual void RemoveGlobalObjectImpl(size_t i_type_code) = 0;
public:
	virtual ~ObjectStorageBase() {}
	template 
	void AddGlobalObject()
	{
		AddGlobalObjectImpl(std::make_unique());
	}

	template 
	ObjectType* GetGlobalObject() const
	{
		return static_cast(GetGlobalObjectImpl(typeid(ObjectType).hash_code()));
	}

	template 
	void RemoveGlobalObject()
	{
		RemoveGlobalObjectImpl(typeid(ObjectType).hash_code());
	}
	virtual std::vector GetStoredObjects() = 0;
};


class GameGlobalObject : public GlobalObjectBase
{
	public:
		virtual ~GameGlobalObject() {}

		virtual void Update(float dt) {}
		virtual void Init() {}
		virtual void Release() {}
};

class DefaultObjectsStorage : public ObjectStorageBase
{
private:
	using ObjPtr = std::unique_ptr;
	std::vector m_dynamic_globals;

private:
	virtual GameGlobalObject* GetGlobalObjectImpl(size_t i_type_code) const override
	{    …	}
	virtual void AddGlobalObjectImpl(std::unique_ptr ip_object) override
	{    …	}
			virtual void RemoveGlobalObjectImpl(size_t i_type_code) override
	{    …	}

public:
	DefaultObjectsStorage() {}
	virtual std::vector GetStoredObjects() override { return m_cache_objects; }
};

static std::unique_ptr> gp_storage(new DefaultObjectsStorage());

void Test()
{
	// делаем объект "глобальным"
	gp_storage->AddGlobalObject();
	// используем
	gp_storage->GetGlobalObject()->Initialize();
	// и удаляем
	gp_storage->RemoveGlobalObject();
}

for (auto p_object : g_storage->GetStoredObjects())
p_object->Init();

Всё ли в итоге у нас хорошо?

class GlobalObjectBase
{
protected:
	size_t m_hash_code;
public:
	...
	size_t GetTypeHashCode() const { return m_hash_code; }
	virtual void RecalcHashCode() { m_hash_code = typeid(*this).hash_code(); }
};

template 
class ObjectStorageBase
{
	…
public:
	template 
	void AddGlobalObject()
	{
		auto p_object = std::make_unique();
		p_object->RecalcHashCode();
		AddGlobalObjectImpl(std::move(p_object));
	}
	template 
	ObjectType* GetGlobalObject() const
	{
		static size_t type_hash = typeid(ObjectType).hash_code());
		return static_cast(GetGlobalObjectImpl(type_hash);
	}
	…	
};

class DefaultObjectsStorage : public ObjectStorageBase
{
	…
private:
	virtual GlobalObjectBase* GetGlobalObjectImpl(size_t i_type_code) const override
	{
		auto it = std::find_if(m_dynamic_globals.begin(), m_dynamic_globals.end(), [i_type_code](const ObjPtr& obj)
		{
			return obj->GetTypeHashCode() == i_type_code;
		});
		if (it == m_dynamic_globals.end())
		{
		// здесь можно добавить ассерт о том, что что-то пошло не так
			return nullptr;
		}
		return it->get();
	}
	…
};

struct Foo : public GlobalObjectBase
{
   	int x = 0;
   	virtual void SetX()
   	{
         	x = rand()%1;
   	}
};
 
struct FooTest : public Foo
{
   	virtual void SetX() override
   	{
         	x = 5;
   	}
   	virtual void RecalcHashCode() { m_hash_code = typeid(First).hash_code(); }
};
g_getter.AddGlobalObject();
g_getter.GetGlobalObject()->SetX();

По ссылке можно найти финальный код оболочки и описанные тесты.

Комментарии (2)

• gbg

  29 ноября 2016 в 15:54

  +1

  ↑

  ↓

  Вектор. С линейным поиском по хэшу. Но вектор. Тут что-то явно не логично.
  То есть, пока объектов мало, и все влезает в кэш (процессора) — все будет хорошо, и даже быстрее std: map какого-нибудь. А вот если объектов будут сотни тысяч, это все повылезает и будет смотреть на вас с немым укором.

  Без иронии — вы гонитесь за скоростью, но используете линейный поиск. В таком случае, стоило бы пояснить, почему вы не используете структуру с логарифмическим временем доступа.
  

  • Jester92

    29 ноября 2016 в 16:00

    0

    ↑

    ↓

    Предположительно, в проекте не будет больше 30–40 глобальных переменных. В том же CryEngine насчитал в структуре около 45. С этим расчётом разрабатывалось и тестировалось. В случае, если количество глобальных объектов переваливает за сотню, то, возможно, с архитектурой проекта не всё хорошо.
    В любом случае замечание дельное и в ближайшее время постараюсь потестировать с большим количеством объектов и разными контейнерами. Благодарю за отзыв.