c++ how to create classes that are interdependent - c++

Question

I have a storage class. members of this class are often modified.
each time a member is modified, I'd like to save the state of the class (clone class instance and save it).
So I'd like to create a new class, that will save these states.
For Example:
Say I have a Storage class in file storage.h
class Storage
{
public:
Int m_cnt;
<lots of other members...>
StorageHistory m_his;
};
and a StorageHistory class in file storagehistory.h
class StorageHistory
{
public:
std::vector<Storage> m_history_vec;
};
Assumptions:
StorageHistory class should be kept in Storage class. the reason for that is that Storage class is a main class that can be accessed in all classes/packages. to minimize the changes in the code, I'd like StorageHistory to be coupled with Storage class.
StorageHistory cannot be static or singleton since multiple instance of Storage are created.
Problems:
Cannot compile this code. storage.h needs to be compiled before storagehistory.h and vice versa
If StorageHistory cannot be stored in Storage class then were do I keep it? who is the owner of this class?
Need help to define the connection between these two classed?

Answer 1

First of all: don't make data members public, unless you define a pure data structure. Then: Int is no C++ type.
Now to your questions: you can use forward declarations. Since StorageHistory is used directly in Storage, it cannot be forward declared, but Storage is only used in a template data member (namely a std::vector) in StorageHistory, and that template does not need the definition of Storage if it's only declared as a variable. You need the definition only when you use methods of vector.
So here's the untangled code:
StorageHistory.h
#include <vector>
class Storage;
class StorageHistory
{
std::vector<Storage> m_history_vec;
public:
/* method declarations */
};
Storage.h
#include "StorageHistory.h"
class Storage
{
int m_cnt;
/* <lots of other members...> */
StorageHistory m_his;
public:
/* method declarations */
};
Storage.cpp
#include "Storage.h"
#include "StorageHistory.h" //not necessarily needed, because implicitly included, but thats a matter of coding style
/* ... Storage methods definitions ... */
void Storage::changeVar(/*...*/)
{
m_his.push_back(*this);
/* ... */
}
StorageHistory.cpp
#include "StorageHistory.h"
#include "Storage.h"
/* ... StorageHistory method definitions ... */

Answer 2

Add to your header files
Storage.h
class Storage; //to declear the class before the include
#include "StorageHistory.h"
//continue with the old declearation
class Storage{
....
}
and
StorageHistory.h
class StorageHistory; //to declear the class before the include
#include "Storage.h"
//continue with the old declearation
class StorageHistory{
....
}
remember to have include guards first in the files.
This can be done for all classes to avoid this kind of problem in the future.

Answer 3

You're essentially doing memento design pattern. Your current compilation problems will go away with forward declaration. But for better design and implementation you can see this and this.

Answer 4

You need to use forward declarations for your solution to work. The easiest way is to put these classes in the same header file (but it may be solved a little bit differently):
class StorageHistory; // *** Forward declaration ***
class Storage
{
public:
Int m_cnt;
<lots of other members...>
StorageHistory m_his;
};
class StorageHistory
{
public:
std::vector<Storage> m_history_vec;
};
I don't like your solution, though. The m_his will contain a list of Storage classes and all of them will contain a list of Storage classes (empty, though).
I'd create a singleton with a map of vectors of Storages and wrap a Storage with container containing an UID.
class StorageContainer
{
private:
static int nextUID = 0;
int uid;
Storage data;
public:
StorageContainer()
{
uid = nextUID++; // Watch out for concurrency problems
}
Storage & GetData()
{
return data;
}
};
You could then access a history of a Storage by its UID.
class StorageHistory
{
// The usual singleton stuff
private:
std::unordered_map<int, std::vector<Storage>> history;
public:
std::vector<Storage> & operator[] (int uid)
{
auto iter = history.find(uid);
if (iter == unordered_map::end)
{
std::vector<Storage> newHistory;
history[uid] = newHistory;
}
return history[uid];
}
};