how to split cyclic dependency with 'using' directive

Question

Suppose classes A and B. Each can construct the other:

// A.hpp
#pragma once
class B;
class A {
  B foo();
};

// A.cpp
#include <A.hpp>
#include <B.hpp>
B foo(){ return B(); }

// B.hpp
#pragma once
class A;
class B {
  A foo();
};

// B.cpp
#include <B.hpp>
#include <A.hpp>
A foo(){ return A(); }

Let's introduce a new type:

// A_or_B.hpp
#pragma once

#include "A.hpp"
#include "B.hpp"
// or
class A;
class B;

using A_or_B = std::variant<A, B>;

Let's return A_or_B from A and B:

// A.hpp
#pragma once

#include "A_or_B.hpp" // woops!  the type for A_or_B is not resolved:
class A {
  A_or_B foo();
};

Justifications for the whoops:

if we use an include in A_or_B.hpp then A_or_B will not be able to include A (since the header guard) - so it will be referencing a non-existant type.
if we use a forward declaration then A_or_B will use uncomplete types and will not be usable in the linking stage

The cyclic problem doesn't occur between A and B because we split the declaration and implementation between hpp and cpp files. contrary to classes - typedefs or using directives can't be split.

what can be done to solve this?

What is the underlying problem you are to solve? Why should both `A` and `B` have a method that returns either `A` or `B`? — Yksisarvinen, Jul 18 '23 at 17:08
it's a state machine. the object that is of type ```A_or_B``` is the current state. The classes themselves are the states. — Eyal Kamitchi, Jul 18 '23 at 17:10
Using `std::variant;` with forward-declared classes is UB. The cyclic dependency here can not be solved because every step requires complete type. It can easily be solved by introducing pointer somewhere, for example `using A_or_B = std::variant ;` Or maybe even a hierarchy of classes `using A_or_B = ::std::unique_pt;` — user7860670, Jul 18 '23 at 17:17
So why don't you go the typical way using inheritance? `class State {virtual State* foo() = 0;}; class A: public State{/*override foo*/}; class B: public State{/*override foo*/}};`? You can't do what you want, as noted above. — Yksisarvinen, Jul 18 '23 at 17:20
I'll make it an actual class - that way I get to implement an ```advance``` function for the state machine too. — Eyal Kamitchi, Jul 18 '23 at 17:32

score 2 · Answer 1 · answered Jul 18 '23 at 17:33

You can forward declare A_or_B and then eventually define it as a class that publicly inherits from the variant type.

// A.hpp
#pragma once
class A_or_B;
class A {
    A_or_B foo();
};

// B.hpp
#pragma once
class A_or_B;
class B {
    A_or_B foo();
};

// A_or_B.hpp
#include "A.hpp"
#include "B.hpp"

class A_or_B : public std::variant<A, B> {
public:
    using base = std::variant<A, B>;
    using base::base;
    using base::operator=;
};

chrysante · Accepted Answer · 2023-07-19T04:41:59.870

0

You can define A_or_B as a typedef for std::variant<A, B> without defining A and B. Only to instantiate an object of type A_or_B do you need the definitions.

// A.hpp
#include "A_or_B_fwd.hpp"

class A {
    A_or_B foo();
};

// B.hpp
#include "A_or_B_fwd.hpp"

class B {
    A_or_B foo();
};

// A_or_B_fwd.hpp
#include <variant>

class A;
class B;

using A_or_B = std::variant<A, B>;

// A_or_B.hpp
#include "A.hpp"
#include "B.hpp"
#include "A_or_B_fwd.hpp"

// A.cpp
#include "A.hpp"
#include "A_or_B.hpp"

A_or_B A::foo() { /* ... */ }

// B.cpp analogously

Using "-fwd.hpp"-style headers can be reasonable when forward declarations are more complex than class X; The standard library also does it with <iosfwd>.

edited Jul 19 '23 at 04:41

answered Jul 18 '23 at 18:29

chrysante

2,328
4
24

and A.cpp will have: 1. include A.hpp 2. include A_or_B.hpp 3. definitions. right? – Eyal Kamitchi Jul 19 '23 at 02:29
"You can define A_or_B as a typedef for std::variant without defining A and B" - you can not. see https://stackoverflow.com/a/57226751/7860670 – user7860670 Jul 19 '23 at 04:04
1

@user7860670 [You can absolutely](https://godbolt.org/z/Wvxjs1r9Y). In the question you linked, `Rect` is indeed incomplete where `Shape` is instantiated. This does not need to be the case here. – chrysante Jul 19 '23 at 04:39
@EyalKamitchi Yes, and then define `A::foo()` and `B::foo` in their respective .cpp files. – chrysante Jul 19 '23 at 04:40

how to split cyclic dependency with 'using' directive

2 Answers2