Thread: Two objects that has a pointer to each other

I need to have two objects that has a pointer to each other.

Code:

class A
{
      .....
      B* pointer_to_B;
}

Code:

class B
{
      .....
      A* pointer_to_A;
}

It seems like it's not possible since one of them can't know about the other cuz of the include...

I find it really odd if it can't be done.

Thanks! (:

Use forward declarations, e.g.,

Code:

class B;

class A
{
      .....
      B* pointer_to_B;
};

Thanks, assumed there's something like this, but it still doesn't work:

CountsNode.h

Code:

#ifndef COUNTS_NODE_H
#define COUNTS_NODE_H
#include "RBNode.h"
#include "CNode.h"

class CNode;

class CountsNode : public RBNode
{
	private:
		int num_of_books;
		CNode* customer;


	public:
		CountsNode(CNode* customer)
		{
			this->num_of_books = 1;
			this->customer = customer;
		};
};
#endif

CNode.h

Code:

#include "RBNode.h"
#include "Customer.h"

class CNode : public RBNode
{
	private:
		Customer* customer; // customer info object

	public:
		CNode(Customer* customer);
		int GetKey() {return this->customer->id;};
		void Print();
		void CopyTo(RBNode* node);
};

Customer.h

Code:

#ifndef CUSTOMER_H
#define CUSTOMER_H
#include <iostream>
#include <string>
#include "RBNode.h"
#include "CountsNode.h"

using namespace std;

class CountsNode;

class Customer
{
	public:
			static const int MAX_BOOKS = 10;
			Customer(int id, string familyName);
			int GetCount() {return (this->count == NULL ? 0 : this->count->GetKey());};
			
	private:
			int id;
			CountsNode* count;
			string name;

	friend class CNode;
};
#endif

I think the problem is with the includes (it's recursive). If I remove the include of CNode.h from CountsNode.h the build succeed but I can't it says that objects customer has no properties (which is logical since I didn't include it, just declare).

I removed the include of CNode.h in CountsNode.h and moved the implementation just as you said but still 'No memebers' for customer... /:

Great. Thank you!

Btw, consider using smart pointers if you are using pointers.

Also, I'd make sure that you really should be structuring the code like this, or if there's a better way. Sometimes this scenario comes up, but often there's a better way to accomplish what you need without tightly coupling these two classes.

Some design choices that can help in some cases are the creation of abstract interfaces, and the observer pattern. The latter is particularly useful when you have objects that have an owner / owned relationship and the owner needs to be informed about certain changes to the owned object. Rather than the owned object needing to know who its owner is, the owner registers itself as a listener for events, and the owned object just broadcasts its state change to anyone who cares.

An example - suppose you have data objects that have a UID and other associated data, and you've got a collection class which is storing these in some kind of key-value container structure to look up objects by UID. If the data object has a method that allows its UID to change, the container object needs to know because it probably needs to re-key the data internally. You *could* make the data object aware of its container object, but that limits reuse of the data object. A better way would be to make the data object observable and let the container object register itself as an observer if it needs to. That makes the data object more easily reused.