Die Objekt Klasse wird dann selbst zur Instanz. Optimal wäre es dann noch, wenn du die Methoden der Map-Klasse als virtual deklarierst, dadurch kann die Objekt, klasse, diese anpassen. Außerdem hast du durch die vererbung die möglichkeit, mehrere Verschiedene Objekt Klassen unter einem Hut zu verpacken.
|
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
|
class Map
{
public:
virtual void Do()
{
// Lass alle Children auch was machen
for(int i = 0; i < Children.GetLength(); ++i)
Children[i]->Do();
}
virtual void Sleep()
{
Sleep(500);
}
virtual void AddChild(Map* child)
{
Children.Add(child);
}
private:
Array<Map*> Children;
};
// ObjektA erbt von Map
class ObjectA : public Map
{
public:
void Do()
{
// Lass alle Children auch was machen
for(int i = 0; i < Children.GetLength(); ++i)
Children[i]->Do();
}
void Sleep()
{
Sleep(123445);
}
};
// ObjektB erbt von Map
class ObjectB : public Map
{
public:
void Do()
{
// Alle Children von ObjektB dürfen mal ne Pause machen.
}
void DoSomeOther()
{
// Mach was anderes
}
};
|
Der Vorteil ist nun der, das man sich ein Child raus suchen kann, ihn was machen lassen kann, und automatisch deren Childs auch was machen. Ist natürlich nicht immer anwendbar, aber gerade bei NPCs und KI kann man soetwas (in verbindung mit Grafik) sehr gut einsetzen. Außerdem ist dort ein wenig Polymorphi (oh gott, hoofentlich hab ich das jetzt auch richtig geschrieben) dabei. Das ist genauso wie die polymorphi bei den alten araban, wo man 50 Frauen hatte. Hier kann nun eine Map Klasse viele andere Klassen representieren, solange diese von der Map Klasse erben. Du kannst nun alle klassen die davon erben, in einem Array Packen, und deren vorgegebenen Methoden aufrufen.