Может кто-то помогать разъяснить, как заголовочные файлы работают?

Лучше всего думать о ваших файлах заголовков как о «автоматическом копировании и вставке».

Хороший способ подумать об этом (хотя и не о том, как это на самом деле реализовано) состоит в том, что, когда вы компилируете файл C или файл C ++, препроцессор запускается первым. Каждый раз, когда он встречает оператор #include, он фактически вставляет содержимое этого файла вместо оператора #include. Это делается до тех пор, пока не кончатся включения. Последний буфер передается компилятору.

Это вводит несколько сложностей:

Во-первых, если A.H включает B.H, а B.H включает A.h, у вас проблема. Потому что каждый раз, когда вы хотите вставить A, вам понадобится B, и у него внутри будет A! Это рекурсия. По этой причине в файлах заголовков используется #ifndef, чтобы гарантировать, что одна и та же часть не будет прочитана несколько раз.Скорее всего, это происходит в вашем коде.

Во-вторых, ваш компилятор C читает файл после того, как все файлы заголовков были «сглажены», поэтому вы должны учитывать это, когда рассуждаете о том, что объявлено перед тем.

включает в себя работу очень просто, они просто командуют препроцессору для добавления содержимого файла в то место, где установлено включение. основная идея - включить заголовки, от которых вы зависите. в player.h вы должны включить custvector.h и Health.h . В основном только player.h , потому что все необходимые включения будут перенесены с player. и вам вообще не нужно включать main.h в player.h .

Хорошо также убедиться, что заголовок включен только один раз. в этом вопросе дается общее решение Как предотвратить множественные определения в C? в случае Visual Studio вы можете использовать #pragma once , если Borland c ++ существует также уловка, но я забыл Это.

Вы хотите организовать свой #includes (и библиотеки, если на то пошло) в DAG (направленный, ациклический граф). Это сложный способ сказать «избегайте циклов между файлами заголовков»:

Если B включает A, A не должен включать B.

Итак, используя «one big master main.h "- неправильный подход, потому что сложно # включать только прямые зависимости.

Каждый файл .cpp должен включать свой собственный файл .h. Этот файл .h должен включать только то, что ему самому требуется для компиляции .

Обычно нет main.h , потому что main.cpp никому не нужно определение main.

Кроме того, вы захотите включить охранников , чтобы защитить вас от нескольких включений.

Например

//player.h
#ifndef PLAYER_H_
#define PLAYER_H_
#include "vector.h"  // Because we use Vector
#include "health.h"  // Because we use Health
class Player {
    private:
        Vector playerPos;
    public:
        Health playerHealth;
};
#endif

-

//vector.h
#ifndef VECTOR_H_
#define VECTOR_H_
struct Vector {
   int X;
   int Y;
   int Z;
};
#endif

-

//health.h
#ifndef HEALTH_H_
#define HEALTH_H_
class Health {
    private:
        int curHealth;
        int maxHealth;
    public:
        int getHealth() const;
        void setHealth(int inH);
        void modHealth(int inHM);
};
#endif

Единственный раз, когда вы хотите объединить группу #include в один заголовок, это когда вы предоставляете его как удобство для очень большой библиотеки.

В вашем текущем примере вы немного переборщили - каждому классу не нужен собственный файл заголовка. Он может все войдите в main.cpp.

Препроцессор c буквально вставляет файл из #include в файл, который включает его (если он еще не был вставлен, поэтому вам нужен include gu ОРДС). Это позволяет вам использовать классы, определенные в этих файлах, потому что теперь у вас есть доступ к их определению.

У вас круговая зависимость. Player включает main.h, а main.h включает player.h. Решите эту проблему, удалив одну зависимость или другую.\

Player.h должен включать health.h и custvector.h, и на данный момент, я не думаю, что main.h нуждается в каких-либо включениях. В конце концов, ему может понадобиться player.h.