C++ shared DB between 2 classes - c++

Question

my problem is the following: I have 2 classes which both contain vector of data, the vector length and the data struct is very big and almost 90% of the data is sam between the 2 classes. Current implementation is that each class holds its own vector of data thus there is big memory consumption.
My goal is to optimize the memory and create some kind of DB where it will hold the data, and the classes will hold some kind of reference to the DB.
Guidelines:
Each class can manipulate its vector of data and it needs to reflect on the DB, means that for example both classes hold a ref to the same data struct and one of the classes removes it from its vector, the DB still need to hold the data for the second class.
if no class hold ref to data, the data needs to be deleted from DB.
if both classes hold the same data, I don't want replication.
My design was to use some kind of a hash map where the classes will hold key to the map, and the hash map itself will hold a reference count, but than I thought about smart pointers in C++.
This is the code for my design but I am not sure regarding my implementation:
class Data {
public:
Data(const int xTemp, const int yTemp, const int idTemp) {
x = xTemp;
y = yTemp;
id = idTemp;
}
int getX() { return x; }
int getY() { return y; }
int getId() { return id; }
private:
int x;
int y;
int id;
};
class ModelA {
public:
ModelA() {
vector.clear();
}
private:
std::vector<std::tuple<int /*key to DB */, std::shared_ptr<Data> /* ptr to data */, std::string /* id Type per Model */> > vector;
};
class ModelB {
ModelB() {
vector.clear();
}
private:
std::vector<std::tuple<int /*key to DB */, std::shared_ptr<Data> /* ptr to data */, std::string /* id Type per Model */> > vector;
};
std::unordered_map<int, std::shared_ptr<Data> > db;
Basically we can insert elements to modelA and modelB and we don't want to have same memory if the data is the same(based on id).
Thanks.

Answer 1

You could make your scheme work along these lines:
class Database {
std::unordered_map<int, std::weak_ptr<Data> > db;
public:
std::shared_ptr<Data> add(int key, const Data& val) {
std::weak_ptr<Data>& wp = db[key];
std::shared_ptr<Data> ret = wp.lock();
if (!ret) {
ret = std::make_shared<Data>(val);
wp = ret;
}
return ret;
}
// Must be called **after** disposing of your copy of
// the `shared_ptr<Data>`
void remove(int key) {
if (db[key].expired()) {
// No more references.
db.erase(key);
}
}
};
Upon further thought, remove could be called automatically by a deleter. Something like this (not tested):
class Database {
std::unordered_map<int, std::weak_ptr<Data> > db;
struct Deleter {
Database* db;
int key;
void operator()(const Data* ptr) {
db->remove(key);
delete ptr;
}
};
public:
std::shared_ptr<Data> add(int key, const Data& val) {
std::weak_ptr<Data>& wp = db[key];
std::shared_ptr<Data> ret = wp.lock();
if (!ret) {
ret = std::shared_ptr<Data>(
new Data(val), Deleter{this, key});
wp = ret;
}
return ret;
}
private:
void remove(int key) {
assert(db[key].expired());
db.erase(key);
}
};
You lose the optimization of make_shared that uses a single allocation for the object and the control block. Now two heap allocations per Data instance are performed.