Mutually dependent classes

Let's say I have two mutually dependent classes, such as

Code:

---

<A.h>
class B;
class A { A(B b) };

---

Code:

---

<B.h>
class B { foo(A a) };

---

Code:

---

<C.h>
#include "A.h"
#include "B.h"

---

On GCC I get foward declaration/incomplete type errors. Suppose these two files are in two seperate header files. What is the right way to declare and define classes like this?

A forward declaration is only sufficient if you are using a pointer or reference to the type being forward-declared. Passing by value, in the example you provide, is not possible because the full definition of the type is not available yet.

To expand on what Brewbuck says: You litterally CAN NOT DO THAT.

Use references, pointers or come up with another way of solving the entire problem.

--
Mats

So the only way is to make the parameters const reference or reference (or pointer, I assume)?

EDIT: Posted this before I saw matsp's post. Thanks, I guess I can use references as I feel the design is what I need.

If you have circular dependency, you've either got bad code or you've got a special case where you can't avoid it.

Exactly what kind of problem are you trying to solve? A little more information from you will help us to understand why you have a circular dependency and if there's a possible other solution in which you can avoid it.

I'm making a C++ regular expression wrapper class (wraps the C regex library) that is similiar to the Java.regex package.

It's got two classes: Pattern and Matcher.

The Pattern class has a function like:
Matcher Pattern::match(std::string pattern)

and the Matcher class needs to have a method such as:
void Matcher::setPattern(Pattern)

As you can see, I can't define the Pattern class without first defining the Matcher class, and vice-versa.
Of course, I could change the argument into setPattern to a const reference and define the Matcher class before the Pattern class. I can't think of any other way to implement this design without circular dependency.

Quote:

---

Originally Posted by MacNilly

I'm making a C++ regular expression wrapper class (wraps the C regex library) that is similiar to the Java.regex package.

It's got two classes: Pattern and Matcher.

The Pattern class has a function like:
Matcher Pattern::match(std::string pattern)

and the Matcher class needs to have a method such as:
void Matcher::setPattern(Pattern)

---

In that case, setPattern() should take a const Pattern &, since it will presumably compile it down internally, and there's no real need to pass by value. On the other hand, returning a Matcher by value from Pattern::match() is the right way to go.

Quote:

---

Originally Posted by MacNilly

I'm making a C++ regular expression wrapper class (wraps the C regex library) that is similiar to the Java.regex package.

---

Is the Boost Regex library insufficient for your needs?

Probably not, but I'm doing this as a personal project to learn the C regex library.

You only need a forward declaration of a type to write a declaration of a function that takes or returns that type by value. You only need the full definition when you define the function. In other words, this is perfectly fine:

Code:

---

struct A;

struct B {
  A frabuzzle(A);
};

---

But you need the full definition of A before you can implement B::frabuzzle.