Почему учебник Qt создает класс заголовка следующим образом? [Дубликат]

Это называется форвардной декларацией. Тело класса foo будет определено в более поздней части файла. Для определения циклических зависимостей выполняется следующее: определение класса Bar требует класса Foo и наоборот.

class Bar
{
   Foo * foo;
};
class Foo
{
   Bar * bar;
};

Как вы можете видеть, Bar имеет ссылку на Foo и наоборот , Если вы попытаетесь скомпилировать это, компилятор заявит, что он ничего не знает о Foo. Решение состоит в том, чтобы переслать объявление class Foo над Bar (так же, как вы объявляете прототип функции над main и определяете ее тело позже).

class Foo; //Tells the compiler that there is a class Foo coming down the line.
class Bar
{
   Foo * foo;
};
class Foo
{
   Bar * bar;
};

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

in foo.h
--------
#include "bar.h"

class foo
{
public:
    foo(bar *bar);
private:
    foo *m_foo;
};

and in bar.h
------------
class foo;
class bar
{
public:
    void methodFooWillCall();
protected:
    std::list<foo *> myFoos;
}

Это форвардная декларация класса 'foo'. Он позволяет объявлять указатели и ссылки на класс, но не использовать его (например, члены вызова или определить его размер), потому что он еще не определен! Это должно быть продолжено с полным нормальным объявлением (class foo { ... };).

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

Любопытно, зачем нам вообще нужно выражение forward ? Не является ли декларацией для перехода просто декларацией (в отличие от определения)?

class X;  // declaration

class X   // definition
{
    int member;
    void function();
};

Это forward declaration . Вам это нужно, например, если в строке класса указатель на объект foo, но вы не хотите сразу включать полное определение объекта foo.

Это называется форвардным объявлением. Он используется, чтобы ваш код знал, что класс foo существует. Это, в свою очередь, может использоваться панелью классов.

Обычно используется для решения круговых задач. Возьмем это, например,

//a.h
#include "b.h"

class A
{
    void useB(B obj);
}

и

// b.h
#include "a.h"
class B
{
     void useA(A obj);
}

Это вызывает проблему с круговым включением, так как a.h включает b.h, который по очереди включает a.h, в бесконечность. Вы можете решить эту проблему, сделав перед каждым заголовком декларацию в прямом выражении следующим образом:

//a.h
class B;

class A
{
    void useB(B obj);
}

// b.h
class A;

class B
{
     void useA(A obj);
}

Примечание. Очень часто, когда у вас есть проблема с круговым включением, это указывает на концепцию / моделирование проблема. Вероятно, вы должны спросить себя, четко ли определены ваши классы, прежде чем пытаться решить вашу проблему с помощью передовых объявлений.

Попытайтесь написать это:

file bar.h:

        #include "bar.h"

        class Foo
        {
        Bar* bar_ptr;
        }

file foo.h:

        #include "foo.h"

        class Bar
        {
            Foo* foo_ptr;
        }

t, сначала из-за бесконечной цепочки #include, то, если вы избавитесь от одного из включений, Foo не будет знать, что такое Bar, или Bar не будет знать, что такое Foo.

Попробуйте это вместо:

        class Bar;

        class Foo
        {
        Bar* bar_ptr;
        };

file foo.h:

        class Foo;

        class Bar
        {
            Foo* foo_ptr;
        };

Это передовая декларация. Рассмотрим следующий пример:

class foo; // you likely need this for the code beneath to compile
class bar {
    void smth( foo& );
};

Если вы не включили определение class foo таким образом, что компилятор видит его перед компиляцией определения class bar, код не будет компилироваться ( компилятор скажет, что не знает, что означает foo), если у вас нет прямого объявления.