C++ #include

Preprocesor jest programem, który pobiera Twój program, wprowadza pewne zmiany (na przykład pliki nagłówkowe (#include), rozszerzenie makr (#define) i w zasadzie wszystko, co zaczyna się od #) i daje "czysty" wynik kompilatorowi.

Preprocesor działa tak, gdy widzi #include:

Kiedy piszesz:

#include "some_file"

Zawartość some_file prawie dosłownie zostaje wklejona do pliku wraz z nią. Teraz, jeśli mieć:

a.h:
class A { int a; };

I:

b.h:
#include "a.h"
class B { int b; };

I:

main.cpp:
#include "a.h"
#include "b.h"

Otrzymujesz:

main.cpp:
class A { int a; };  // From #include "a.h"
class A { int a; };  // From #include "b.h"
class B { int b; };  // From #include "b.h"

Teraz możesz zobaczyć, jak A jest redefiniowane.

Kiedy piszesz strażnicy, stają się tak:

a.h:
#ifndef A_H
#define A_H
class A { int a; };
#endif

b.h:
#ifndef B_H
#define B_H
#include "a.h"
class B { int b; };
#endif

Przyjrzyjmy się więc teraz, jak #includes W main będzie rozszerzony (jest to dokładnie tak, jak w poprzednim przypadku: kopiuj-wklej)

main.cpp:
// From #include "a.h"
#ifndef A_H
#define A_H
class A { int a; };
#endif
// From #include "b.h"
#ifndef B_H
#define B_H
#ifndef A_H          // From
#define A_H          // #include "a.h"
class A { int a; };  // inside
#endif               // "b.h"
class B { int b; };
#endif

Teraz podążajmy za preprocesorem i zobaczmy, jaki "prawdziwy" kod z tego wyjdzie. Pójdę linia po linii:

// From #include "a.h"

Skomentuj. Ignoruj! Dalej:

#ifndef A_H

Czy A_H jest zdefiniowany? Nie! Następnie kontynuuj:

#define A_H

Ok teraz A_H jest zdefiniowana. Dalej:

class A { int a; };

To nie jest coś dla preprocesora, więc zostaw to. Dalej:

#endif

Poprzedni if skończył się tutaj. Dalej:

// From #include "b.h"

Skomentuj. Ignoruj! Dalej:

#ifndef B_H

Czy B_H jest zdefiniowany? Nie! Następnie kontynuuj:

#define B_H

Ok teraz B_H jest zdefiniowana. Dalej:

#ifndef A_H          // From

Czy A_H jest zdefiniowany? Tak! Wtedy ignoruj do momentu odpowiadającego #endif:

#define A_H          // #include "a.h"

Ignoruj

class A { int a; };  // inside

Ignoruj

#endif               // "b.h"

Poprzedni if skończył się tutaj. Dalej:

class B { int b; };

To nie jest coś dla preprocesora, więc zostaw to. Dalej:

#endif

Poprzedni if skończył się tutaj.

To znaczy, po wykonaniu preprocesora z plikiem, to jest to, co widzi kompilator:

main.cpp
class A { int a; };
class B { int b; };

Więc jak widzisz, wszystko, co może dostać #include d w tym samym pliku dwa razy, bez względu na to, czy należy go strzec bezpośrednio czy pośrednio. Ponieważ pliki .h są zawsze bardzo prawdopodobne, że zostaną dołączone dwa razy, dobrze jest, jeśli strzeżysz wszystkich swoich .pliki H.

P. S. zauważ, że masz również okrągłe #includes. wyobraź sobie, że preprocesor kopiuje kod fizyki.h do GameObject.h, który widzi, że istnieje #include "GameObject.h", co oznacza kopię GameObject.h w sobie. Kiedy kopiujesz, znowu dostajesz #include "Pysics.h" i utknąłeś w pętli na zawsze. Kompilatory temu zapobiegają, ale to oznacza, że twoje #include s są połowa skończona.

Jeśli masz:

#include "b.h"

class A
{
    B b;
};

Następnie kompilator musi wiedzieć wszystko o b, co najważniejsze, jakie ma zmienne itp., aby wiedział, ile bajtów powinien umieścić w miejscu b w A.

Jednakże, jeśli masz:

class A
{
    B *b;
};

Wtedy kompilator tak naprawdę nie musi nic wiedzieć o B (ponieważ wskaźniki, niezależnie od typu mają takie same rozmiar). Jedyne, co musi wiedzieć o B, to to, że istnieje!

Więc robisz coś, co nazywa się "forward declaration":

class B;  // This line just says B exists

class A
{
    B *b;
};

Jest to bardzo podobne do wielu innych rzeczy, które robisz w plikach nagłówkowych, takich jak:

int function(int x);  // This is forward declaration

class A
{
public:
    void do_something(); // This is forward declaration
}