Hi!
Ich habe ein kleines Problem, welches ich nicht wirklich (gut) lösen kann. Mir fehlt da wohl fundamentales Grundlagenwissen...
Egal, mein Problem wird am besten von einem Sourcecode beschrieben:
|
C-/C++-Quelltext
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
void Stream::append(const void* data, std::size_t sizeInBytes)
{
if (data && (sizeInBytes > 0))
{
std::size_t start = m_data.size();
m_data.resize(start + sizeInBytes);
std::memcpy(&m_data[start], data, sizeInBytes);
}
}
//Foo, Definition der abgeleiteten, rein virtuellen Funktion "Update"
void Foo::Update(const Stream& stre)
{
Stream strE = stre;
void* p = const_cast<void*>(strE.getData());
const std::size_t size = strE.getDataSize();
/*Wie nun auf die Daten zugreifen?*/
}
//Irgendwo; std::vector<std::shared_ptr<Foo>> m_irgendwas
{
Stream stream;
for(auto at = objekte.begin(); at != objekte.end(); ++at)
{
stream.clear();
stream.append(anderesObjekt, sizeof(anderesObjekt));
for(auto it = irgendwas.begin(); it != irgendwas.end(); ++it)
stream.append(&**it, sizeof(**it));
at->update(stream);
}
}
|
Das Hauptproblem ist eigentlich, dass dort Objekte drin sind, die nicht von einer gemeinsamen Grundklasse abstammen.
Zur Lösung hatte ich mir überlegt noch eine Grundklasse zu machen, wo ich lediglich eine Variable habe, die mir mitteilt, von welchen folgenden Basisklassen geerbt wird, sodass ich sicher hin und her casten und schließlich überhaupt iterieren kann. Ich möchte wissen, ob dieser Weg "gut" ist oder ob euch was besseres einfällt. Ich bin mir einfach unsicher.
MfG
Check