Устранение ошибок построения из-за циклической зависимости между классами

вы можете избежать ошибок компиляции, если удалите определения методов из файлов заголовков и разрешите классам содержать только объявления методов и объявления/определения переменных. Определения метода должны быть помещены в a .файл cpp (так же, как говорится в руководстве по лучшей практике).

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

//A.h
#ifndef A_H
#define A_H
class B;
class A
{
    int _val;
    B* _b;
public:

    A(int val);
    void SetB(B *b);
    void Print();
};
#endif

//B.h
#ifndef B_H
#define B_H
class A;
class B
{
    double _val;
    A* _a;
public:

    B(double val);
    void SetA(A *a);
    void Print();
};
#endif

//A.cpp
#include "A.h"
#include "B.h"

#include <iostream>

using namespace std;

A::A(int val)
:_val(val)
{
}

void A::SetB(B *b)
{
    _b = b;
    cout<<"Inside SetB()"<<endl;
    _b->Print();
}

void A::Print()
{
    cout<<"Type:A val="<<_val<<endl;
}

//B.cpp
#include "B.h"
#include "A.h"
#include <iostream>

using namespace std;

B::B(double val)
:_val(val)
{
}

void B::SetA(A *a)
{
    _a = a;
    cout<<"Inside SetA()"<<endl;
    _a->Print();
}

void B::Print()
{
    cout<<"Type:B val="<<_val<<endl;
}

//main.cpp
#include "A.h"
#include "B.h"

int main(int argc, char* argv[])
{
    A a(10);
    B b(3.14);
    a.Print();
    a.SetB(&b);
    b.Print();
    b.SetA(&a);
    return 0;
}

запомните:

• Это не будет работать, если class A есть объект class B как член или наоборот.
• вперед объявление путь идти.
• порядок объявления имеет значение (именно поэтому вы перемещаете определения).
  • если оба класса вызывают функции другого, вы должны переместить определения.

прочитайте FAQ:

• как я могу создать два класса, которые оба знают друг о друге?
• какие особые соображения необходимы, когда прямые объявления используются с объектами-членами?
• какие особые соображения необходимы, когда прямые объявления используются со встроенными функциями?

Я когда-то решил эту проблему, перемещая все inlines после определения класса и поставить #include для других классов непосредственно перед inlines в заголовочном файле. Таким образом, убедитесь, что все определения+inlines установлены до того, как будут проанализированы inlines.

выполнение этого позволяет по-прежнему иметь кучу строк в обоих(или нескольких) заголовочных файлах. Но это необходимо иметь включить охранники.

такой

// File: A.h
#ifndef __A_H__
#define __A_H__
class B;
class A
{
    int _val;
    B *_b;
public:
    A(int val);
    void SetB(B *b);
    void Print();
};

// Including class B for inline usage here 
#include "B.h"

inline A::A(int val) : _val(val)
{
}

inline void A::SetB(B *b)
{
    _b = b;
    _b->Print();
}

inline void A::Print()
{
    cout<<"Type:A val="<<_val<<endl;
}

#endif /* __A_H__ */

...и делать то же самое в B.h

я поздно отвечаю на это, но на сегодняшний день нет ни одного разумного ответа, несмотря на то, что это популярный вопрос с высоко оцененными ответами....

Лучшая практика: заголовки прямого объявления

как показано в стандартной библиотеке <iosfwd> заголовок, правильный способ предоставить форвардные объявления для других-это иметь заголовок прямого объявления. Для пример:

а.переднеприводных.h:

#pragma once
class A;

а.ч:

#pragma once
#include "a.fwd.h"
#include "b.fwd.h"

class A
{
  public:
    void f(B*);
};

б.переднеприводных.h:

#pragma once
class B;

б.ч:

#pragma once
#include "b.fwd.h"
#include "a.fwd.h"

class B
{
  public:
    void f(A*);
};

разработчики A и B библиотеки должны нести ответственность за сохранение своих заголовков прямого объявления в синхронизации с их заголовками и файлами реализации, поэтому - например - если сопровождающий "B" приходит и переписывает код быть...

б.переднеприводных.h:

template <typename T> class Basic_B;
typedef Basic_B<char> B;

б.ч:

template <typename T>
class Basic_B
{
    ...class definition...
};
typedef Basic_B<char> B;

...тогда перекомпиляция кода для "А" будет вызвана изменениями в included b.fwd.h и должна завершиться без ошибок.

---

плохая, но распространенная практика: вперед объявлять вещи в других библиотеках

скажем-вместо использования заголовка прямого объявления, как описано выше-код в a.h или a.cc вместо вперед-заявляет class B; сам по себе:

• если a.h или a.cc включены :
  • компиляция A завершится с ошибкой, как только она доберется до конфликтующего объявления/определения B (т. е. вышеуказанное изменение на B сломало A и любые другие клиенты, злоупотребляющие прямыми объявлениями, вместо того, чтобы работать прозрачно).
• в противном случае (если A в конечном итоге не включал b.h - возможно, если a просто хранит / передает Bs указателем и / или ссылка)
  • построить инструменты, опираясь на #include анализ и измененные временные метки файлов не будут перестраиваться A (и его дальнейший зависимый код) после изменения на B, вызывая ошибки во время ссылки или во время выполнения. Если B распространяется как DLL, загруженная во время выполнения, код в "A" может не найти по-разному искаженные символы во время выполнения, которые могут или не могут быть обработаны достаточно хорошо, чтобы вызвать упорядоченное завершение работы или приемлемо уменьшить функциональность.

если код A имеет шаблонные специализации / "черты" для старого B, они не вступят в силу.

Я написал сообщение об этом один раз:разрешение циклических зависимостей в c++

основной метод заключается в разделении классов с помощью интерфейсов. Так что в вашем случае:

//Printer.h
class Printer {
public:
    virtual Print() = 0;
}

//A.h
#include "Printer.h"
class A: public Printer
{
    int _val;
    Printer *_b;
public:

    A(int val)
        :_val(val)
    {
    }

    void SetB(Printer *b)
    {
        _b = b;
        _b->Print();
    }

    void Print()
    {
        cout<<"Type:A val="<<_val<<endl;
    }
};

//B.h
#include "Printer.h"
class B: public Printer
{
    double _val;
    Printer* _a;
public:

    B(double val)
        :_val(val)
    {
    }

    void SetA(Printer *a)
    {
        _a = a;
        _a->Print();
    }

    void Print()
    {
        cout<<"Type:B val="<<_val<<endl;
    }
};

//main.cpp
#include <iostream>
#include "A.h"
#include "B.h"

int main(int argc, char* argv[])
{
    A a(10);
    B b(3.14);
    a.Print();
    a.SetB(&b);
    b.Print();
    b.SetA(&a);
    return 0;
}

вот решение для шаблонов: Как обрабатывать циклические зависимости с помощью шаблонов

ключом к решению этой проблемы является объявление обоих классов перед предоставлением определений (реализаций). Невозможно разделить объявление и определение на отдельные файлы, но вы можете структурировать их так, как если бы они были в отдельных файлах.

простой пример, представленный в Википедии, работал для меня. (вы можете прочитать полное описание по адресу http://en.wikipedia.org/wiki/Circular_dependency#Example_of_circular_dependencies_in_C.2B.2B)

файл "a. h":

#ifndef A_H
#define A_H

class B;    //forward declaration

class A {
public:
    B* b;
};
#endif //A_H

файл "'b. h"':

#ifndef B_H
#define B_H

class A;    //forward declaration

class B {
public:
    A* a;
};
#endif //B_H

File "' main.cpp"':

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

int main() {
    A a;
    B b;
    a.b = &b;
    b.a = &a;
}

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

вот как вы можете это сделать, точно сохраняя все детали и удобство использования:

• решение точно такое же, как изначально предполагалось
• встроенные функции по-прежнему inline
• пользователи A и B может включать A. H и B. H в любом порядке

создайте два файла, A_def.h, B_def.ч. Они будут содержать только Aи С:

// A_def.h
#ifndef A_DEF_H
#define A_DEF_H

class B;
class A
{
    int _val;
    B *_b;

public:
    A(int val);
    void SetB(B *b);
    void Print();
};
#endif

// B_def.h
#ifndef B_DEF_H
#define B_DEF_H

class A;
class B
{
    double _val;
    A* _a;

public:
    B(double val);
    void SetA(A *a);
    void Print();
};
#endif

и затем, A. h и B. h будет содержать это:

// A.h
#ifndef A_H
#define A_H

#include "A_def.h"
#include "B_def.h"

inline A::A(int val) :_val(val)
{
}

inline void A::SetB(B *b)
{
    _b = b;
    _b->Print();
}

inline void A::Print()
{
    cout<<"Type:A val="<<_val<<endl;
}

#endif

// B.h
#ifndef B_H
#define B_H

#include "A_def.h"
#include "B_def.h"

inline B::B(double val) :_val(val)
{
}

inline void B::SetA(A *a)
{
    _a = a;
    _a->Print();
}

inline void B::Print()
{
    cout<<"Type:B val="<<_val<<endl;
}

#endif

обратите внимание, что A_def.h и B_def.h-это" частные " заголовки, пользователи A и B не следует их использовать. Публичный заголовок-A. h и B. h.