Was ist Eleganter??
-
Base enthält basisparameter welche ich in manchen fällen ob A oder B travestieren möchte! Dann gibts fällte wo ich einmal nur mit A arbeite und einmal nur mit B!
-
(D)Evil schrieb:
... du brauchst keinen std::vector in dem Fall ...
Irgendwie wundert mich Dein Kreuzzug gegen string und vector ein wenig. Sehe ich überhaupt keinen Vorteil darin...(weder hier noch an all den anderen Stellen, an denen Du die Fragesteller auf char* o.ä. hetzt).
Beantwortet Dein Code die wesentliche Frage von Boris überhaupt ?@Boris: Ich würde tendenziell die 2. Variante vorziehen - mit folgenden Rahmenbedingungen:
- Inhalte ruhig als Stackobjekte:
class System{ const int iB; const int iA; std::vector<A> mvDataA; std::vector<B> mvDataB; System(UINT a,UNIT b) : iA(a), iB(b), mvDataA(a),mvDataB(b) mvDataA.insert(mvDataA.begin(), a, A()); mvDataB.insert(mvDataB.begin(), b, B()); // Alternativ: (vielleicht noch etwas sprechender) // fill_n(mvDataA.begin(), a, A()); // fill_n(mvDataB.begin(), b, B()); } A& GetA(int iIndex){ return mvDataA[iIndex]; } B& GetB(int iIndex){ return mvDataB[iIndex]; } };- Solange es sich nicht um viele Typen handelt. Ansonsten könnte der "Gemeinsame Base"-Ansatz nochmal interessant werden ... allerdings sollte da besser virtual-Polymorphie genutzt werden - casts möglichst nicht.
- Insgesamt bleibt immer zu überlegen, ob solche "Containersammlungen" wirklich notwending sind, oder ob man nicht besser so einen Container "außen" hält.
Gruß,
Simon2.
-
BorisDieKlinge schrieb:
Base enthält basisparameter welche ich in manchen fällen ob A oder B travestieren möchte! Dann gibts fällte wo ich einmal nur mit A arbeite und einmal nur mit B!
Und? Ist doch in beiden Fällen kein Problem.
-
zwischen eleganz und machbarkeit ist zu unterscheiden...!
naja ich werde dann auch VAriante 2 verwenden.:)
-
BorisDieKlinge schrieb:
zwischen eleganz und machbarkeit ist zu unterscheiden...!
Nur, dass das nichts mit dem Zugriff auf die Member der Basisklasse zu tun hat. Wenn du wissen willst, ob mit oder ohne cast, dann frag doch auch das.
-
BorisDieKlinge schrieb:
Base enthält basisparameter welche ich in manchen fällen ob A oder B travestieren möchte!
du ziehst deinen variablen frauenkleider an?
-
ja entwickle ein Modesoftware für Travesiten
-
(D)Evil schrieb:
//... class System { const std::size_t m_countB; //konstant, aber nicht zur Compilezeit bekannt const std::size_t m_countA; //dito base** m_data[m_countB + m_countA]; //Ein Array von Zeigern auf Zeiger mit einer nicht zur Compilezeit bekannten Größe //... };... du brauchst keinen std::vector in dem Fall ...
Das stimmt, allerdings wolltest du wohl ein Array erzeugen, dass zur Laufzeit mit new erzeugt wird, oder?
//... class System { private: const size_t m_countB; const size_t m_countA; base **m_data; public: System(size_t a, size_t b) : m_countB(b), m_countA(a) { m_data = new base*[a+b]; for(size_t i = 0; i < a; ++i) { m_data[i] = new A(); } for(size_t i = a; i < a+b; ++i) { m_data[i+a] = new A(); } } ~System() { for(size_t i = 0; i < m_countA + m_countB; ++i) { delete m_data[i]; } delete[] m_data; } };Felix
-
Anfang: fragwürdiger Code mit std::vector<>.
Status Quo: noch fragwürdigerer Code mit viel new und delete.
Grosser Fortschritt.
-
ne, die anzahl der element bleibt constant...! ist also egal ob ich ein eigenes Array oder std:arry oder std:vector anlege....! grüße
-
Ich verstehe überhaupt nicht, was das Ganze soll.
-
BorisDieKlinge schrieb:
ne, die anzahl der element bleibt constant...! ist also egal ob ich ein eigenes Array oder std:arry oder std:vector anlege....! grüße
Nicht wenn du es dynamisch anlegst.
-
es ist so, habe eine System, welche zwei unterschiedliche Modultypen, welche Basis Parameter enthalten! Die anzahl der modul Typen A und B werden beim start des Progammes fest definiert!
Der Vorteil liegt darin das ich die gleiche Schleife /Iteratoren travesieren kann umd die basis parameter zu lesen!
Und zur not kann ich zwei iteratoren anlegen, welche einmal die B teil und A teil des vector iterieren können!
-
aber muss dein System zeug wissen, mit was es da zu tun hat? gerade das ist ja der sinn von polymorphie.
struct Base { virtual void foo() = 0; }; struct A : public Base { void foo(){ cout << "A" << endl; } void bar(){ cout << "bar" << endl; } }; struct B : public Base { void foo(){ cout << "B" << endl; } }; struct System { vector<Base*> vec; Base* get(int index){ return vec[index]; } void doStuff() { for(vector<Base*>::iterator iter = vec.begin(); iter != vec.end(); ++iter) (*iter)->foo(); } }; int main() { System s; s.vec.push_back(new A); s.vec.push_back(new B); s.doStuff(); A* a = dynamic_cast<A*>(s.get(0)); a->bar(); }für aufrufende methoden mag es wichtig sein zu wissen, was fürn typ im vector steckt. dafür muss man sich halt den index merken o.ä. aber für System ists unwichtig.
-
ja die A und B sind nicht abwechseln gestaffelt, sonder ein feste anzahl A Module dann eine feste Anzahl B module!
Um ein down-cast komm ich nicht drum rum, da ich bei bestimmten funktionen die erweiteren parameter von A bzw. B nutzen wille nicht nur die basis parameter!
-
thordk schrieb:
aber muss dein System zeug wissen, mit was es da zu tun hat?...
Manchmal schon.
Ich würde anders herum sagen: WENN Dein System nicht unbedingt wissen muss, welcher Typ konkret vorliegt, DANN ist (Laufzeit-)Polymorphie das erste Mittel der Wahl.
Im konkreten Fall scheinen aber die Typen A und B nur unwesentlich miteinander verknüpft zu sein, so dass eine getrennte Handhabung sinnvoller ist.
struct Schule { vector<Schueler> schueler; vector<Raum> raeume; };... würde man ja auch nicht per Polymorphie in denselben vector pressen.
Gruß,
Simon2.
