citation needed.Quote:
generell ist es jedoch sauberer die Daten per Parameter zu übergeben
Dafür spricht die Wiederverwendbarkeit. Dagegen das häufige Übergeben. Würde je nach Anwendungsfall entscheiden. Hier würde ich es nicht immer übergeben.Quote:
citation needed.
Wieso ist das besser für die Wiederverwendbarkeit?Quote:
Nennt sich Abstraktion und lässt sich lösen, indem man z.B. Interfaces bzw. abstrakte Klassen verwendet oder auch direkt cool ist und Iteratoren verwendet (wir sind hier immerhin in der C++ Sektion). Extra für dich, ein komplett generischer Merge Sort (unter der Annahme, dass bool operator<(const T&, const T&) existiert): [Only registered and activated users can see links. Click Here To Register...]Quote:
Wenn ich z.b. eine such Funktion für eine Listbox schreibe, schreibe ich diese für allgemeine Listen, und gehe in der Prozedur nicht exakt auf diese listbox ein, um diese Methode auf andere Listen auch anwenden zu können
ziemlich bescheiden. Langeweile läst grüßen. Das mit dem zeigern ist schon sinnig aber da die gesamten Buffer im Device nacher sind (Sprites) und jeweils meine "Os" nurnoch die Pointer managed bleibe ich lieber dabei.Quote:
Gefühlt wären da evtl. smart pointer (std::weak_pointer und std::shared_ptr) nützlich, ansonsten würde ich den Zeiger keinesfalls speichern wenn das Objekt unabhängig vom Kontext, in dem der D3D Zeiger erstellt wird, existieren kann.
P.S.: Deine Klassennamen sind ziemlich bescheiden. Dafür wurden namespaces erfunden.
"citation needed" ist mehr oder weniger ein witz, dass du deine aussage bitte auch belegen sollst - was du imo nicht kannst, da die objektorientierte lösung deutlich sauberer ist, da sie die redundanten übergaben des devices in eine einzige methode (z.b. konstruktor) auslagert - dafür nimmst du halt ein duplikat des device ptrs in der klasseninstanz in kauf - die 4/8 byte sind aber verschmerzbar.Quote:
//cool typedefs here
//...
class DrawableMenu
{
public:
virtual void Draw(DeviceType *device) = 0;
//...
};
class FancyMenu : public DrawableMenu
{
void DrawSomeSubMenu(DeviceType *device);
public:
virtual void Draw(DeviceType *device);
//...
};
void FancyMenu::DrawSomeSubMenu(DeviceType *device)
{
//draw this shit
}
void FancyMenu::Draw(DeviceType *device)
{
DrawSomeSubMenu(device);
//draw even more
}
class MenuController
{
std::vector<DrawableMenu *> _menus;
DeviceType *_device;
public:
MenuController(DeviceType *device, const std::vector<DrawableMenu *> &menus)
: _device(device)
, _menus(menus)
{}
void UpdateMenus();
};
void MenuController::UpdateMenus()
{
//...
for (DrawableMenu *menu : _menus)
{
menu->Draw(_device);
}
//...
}
std::vector<DrawableMenu *> CreateMenus()
{
//...
}
HRESULT __stdcall hkEndScene(DeviceType *device)
{
static MenuController menuController(device, CreateMenus());
//...
menuController.UpdateMenus();
return origEndScene(device);
}
Nur dass eine Instanzvariable für etwas zu verwenden nicht automatisch bedeutet, dass es objektorientiert(er) ist als die Version mit dem Parameter.Quote:
da die objektorientierte lösung deutlich sauberer ist
[...]
Kann zwar je nach anwendungsfall anders sein, in der regel wird aber die objektorientierte lösung wesentlich sauberer sein - und nicht per parameter.
^thisQuote:
Du musst halt überlegen, wie du die Relation am besten darstellen kannst. Wenn dein Sprite-Objekt unabhängig vom D3D-Kontext existieren kann, würde ich nicht unbedingt den Zeiger speichern, da du nicht wissen kannst, ob der noch gültig ist.
Hm, da ich nur 1 mal eine Klassenvererbung mit nur 1 virtuellen funktion nutze, bleibe ich einfach erstmal bei meinem ;)Quote:
Allgemein kann man sagen "Parameter sind besser als Instanzvariablen", so wie man sagen kann "Lokale Variablen sind besser als globale". Es ist immer besser, den Gültigkeitsbereich so klein wie möglich und so groß wie nötig zu halten.
Hier ist aber überhaupt nicht definiert, welcher Gültigkeitsbereich nötig ist.
Z.B. ist gar nicht genannt, was denn "die jeweilige Klasse" ist. Das spielt aber, wie folgendes Beispiel zeigt, eine wichtige Rolle.
(man entschuldige meine eingerosteten C++ Kenntnisse)Code://cool typedefs here //... class DrawableMenu { public: virtual void Draw(DeviceType *device) = 0; //... }; class FancyMenu : public DrawableMenu { void DrawSomeSubMenu(DeviceType *device); public: virtual void Draw(DeviceType *device); //... }; void FancyMenu::DrawSomeSubMenu(DeviceType *device) { //draw this shit } void FancyMenu::Draw(DeviceType *device) { DrawSomeSubMenu(device); //draw even more } class MenuController { std::vector<DrawableMenu *> _menus; DeviceType *_device; public: MenuController(DeviceType *device, const std::vector<DrawableMenu *> &menus) : _device(device) , _menus(menus) {} void UpdateMenus(); }; void MenuController::UpdateMenus() { //... for (DrawableMenu *menu : _menus) { menu->Draw(_device); } //... } std::vector<DrawableMenu *> CreateMenus() { //... } HRESULT __stdcall hkEndScene(DeviceType *device) { static MenuController menuController(device, CreateMenus()); //... menuController.UpdateMenus(); return origEndScene(device); }
MenuContoller realisiert hier eine Verwaltung von mehreren D3D Menüs für ein Device. Er selbst speichert daher selbiges Device, da er daran gebunden ist und es mehr oder weniger verwaltet.
Ein Menü hingegen kann an beliebig vielen Controllern hängen und zumindest rein theoretisch mit beliebig vielen Devices gezeichnet werden. Es hat also keine Instanzvariable, sondern erhält das Device für die Zeichnung als Parameter. Zwar wird das Device ebenfalls in weiteren privaten Methoden gebraucht, aber an den nötigen Stellen wird es dann halt durchgereicht, denn es wäre unsauber und fehleranfällig, eine Instanzvariable zum Durchreichen zu verwenden, nur um sich den zusätzlichen Parameter bei den betroffenen Methoden zu sparen.
Nur dass eine Instanzvariable für etwas zu verwenden nicht automatisch bedeutet, dass es objektorientiert(er) ist als die Version mit dem Parameter.
^this