Dynamic und Static Cast? oder einfach nur ein normales Cast?

BorisDieKlinge

jepp das würde natürlich auch gehen, da hast recht..

Wieso ist das bunt zusammengefwürfelt?

CAllocNode representiert ja einen Knoten der Baumstruktur.

CAllocNode *pFather=...;
CAllocNode *pChild=....;
pFather->add(pChild);

später hab ich 3 Unterschiedliche Allocationstypen A, B ,C welche jeweils unterschiedliche eigenschaften besitzen.

Theoretisch hätte ich das als Template progarmmieren können, wo ich dann jeweils A,B,C einsetze, aber das geht nich, weil ein CAllocNode noch 2 Eigesncahften bestutze was alle Allocationstypen verwenden, das ist quasie die gemeinsamkeit...

später werden dann in 3 unterschiedlichen Klassen jeweils mit A,B,C gearbeitet, wobei diese dann die Baumstruktur als basis verwenden.

CStoll

Was sind denn das für Spezialeigenschaften der einzelnen Allokationstypen?

BorisDieKlinge

Also:
-----------------------------------------------------
AllocNode besitzt die Grundlegen eigenschaften

double Allokationsstart;
double Allokationsdauer;

davon abgeleitet:

A (Process)

String ProzessTyp;

B (Handling)

int StartModul;
int Endmodul;
BYTE StateFlags;

C (Collision)

int Modul;

-----------------------------------------

es kann sein das noch divere Eigenscahfen hinzukommen...

CStoll

*grml* OK, dann fällt es wohl aus, für alles eine gemeinsame Schnittstelle anzubieten.

(denkt mal wieder über Boris' Baumstruktur nach) Wie setzen sich diese verschiedenen Knotentypen eigentlich in deinen Bäumen um? Und welche Beziehung besteht zwischen einem Vater und seinen Kindknoten im Baum?

BorisDieKlinge

Grund für meine Baumstruktur ist die Gruppierung und sequenzierung von AllocationKnoten (AllocNode)

Nehmen wir an ich habe eine Allocation aus drei 4 Knoten:

---- Base -----
---/-----\-----
--B------C-----
-------/---\---
----- A-----D--

Eine Allocation ist vergleichbar mit der Reservierung einer Ressoruce in einer best. Zeispanne.

d.h. die summe der Allocationzeistpanne entsprich C, wobei so die Summe der Gsammten Allocation "Base" sich aus B und C zusammen setzt.

CStoll

Und nach welchen Gesichtspunkten werden die Allokationen gruppiert? (btw, kann eine Gruppen-Allokation wie C auch eigene Zusatzattribute haben? und sind alle Nachfolger eines Knotens vom selben Typ?)

HumeSikkins

Konrad Rudolph schrieb:

HumeSikkins schrieb:
for (Iterator<Control> c = form->controls.begin(); c != form->controls.end(); ++c) {
    Button* b = dynamic_cast<Button*>(c);
    if (b) b->perform_click();
}
Ob das der Beste Weg ist, sei mal dahin gestellt.
Jetzt hast Du mich neugierig gemacht. Was wäre denn eine bessere Alternative?

Besser ist immer Kontextabhängig. Da ich den nicht kenne, kann ich dir nur ne andere Alternative vorschlagen: da wäre z.B. ein Observer-basierter Ansatz (wie er z.B. mit den Signal/Slots in der Qt verwendet wird). Hier würde das Formular verschiedene Ereignisse definieren. Interessierte Controls würden sich für bestimmte Ereignisse registrieren.

Mal unabhängig davon sollte man imo darauf hinweisen, dass dein Beispiel nicht mit dem des OP zu vergleichen ist. Im Form-Beispiel ist der dynamic_cast mehr eine "capability query" und am Ende ein Cast hin zu einer (weiteren) Abstraktion des Frameworks. Die Schleife ist nach wie vor unabhängig von konkreten (bzw. benutzerdefinierten) Klassen. Der OP castet hingegen hin zu konkreten Klassen. Hier stehen konkrete Typen und nicht mehr absrakte Fähigkeiten im Vordergrund. Das wiederum führt sehr leicht zur switch-on-type-Programmierung - mit all den bekannten Nachteilen.

BorisDieKlinge

nicht unbedingt der selbe typ , éin abgeleitest typ

A (Handling)

class A : public AllocNode{
};

clas A1: public A{
};

class A2: public A{
};

---- Base-------
--- /----\------
---A------A-----
-/--\---/-|-\---
A1--A2-A1-A1-A2-

ein Allocation kann nur Knoten mit den Bassis typen A,B,C und deren jweile abgeleiten kalssen enthalten.. also keine mischformen von A,B,C..

Es gibt zwei unterschiedliche gruppierungsmodi..

- sequentielle gruppierung, das heist alle Kinder allokationen folgen zeitlich aufeinandern und wird insgesammt dann als Vater allokation gesehen.

-parallele gruppierung, das heist alle Kinderkonten ihn ihren start und allokationdauer können/sind parallel angeodnet,
Bsp. Kind1 20 sek. länge. kind2 30sek., so wird die gsamtn Allokation (Vater ) 30 sek. sein...

CStoll

Ohje, ich fürchte, bei deinem Ansatz fehlt vor allem eins: ein vernünftiges Konzept. Bevor du weiter über solche Details nachdenkst, solltest du wohl zum Zeichenbrett zurückkehren und dir genau überlegen, was du überhaupt umsetzen willst.

BorisDieKlinge

wie würdest es du denn machen? was ist sooo schlecht? Welche denkfehler hab ich drin? wenn du dir mal die gruppierung weg denkst?

CStoll

Der Hauptfehler besteht darin, daß du dein Konzept nicht wirklich verständlich erklären konntest (wenn da überhaupt ein Konzept ist). Und da ich nicht weiß, was genau dein Ziel ist, wird es etwas schwierig, dort Hilfestellungen zu geben.

BorisDieKlinge

Also:

Stell dir vor du Willst eine best. Ressource bspw. ein PC reservieren für eine best zeit. In dem Zeitraum der reservierung wird der PC angeschaltet, es werden e-mail abgerufen, ein Dokument geschrieben, und wieder heruntergefahren.
das sind quasie 4 abläufe die nacheinander folgen, jeweils ne gewisse zeit andauern , und insgesammt die gesmantzeit der Reservierung (Allokation) des PCs
darstellen. Wenn wir nun noch die Gruppieren betrachten, könnte beispielsweise e-mail abrufen durch (Outlock öffnen, e-mail lesen, outlock schliesen) gruppeiren.

Soweit verstanden?

Was soweit logisch ist , besteht eine reservierung eins best. Dinges (Ressoruce) aus der zeitspannen und wann sie eintrifft, (e-mail lesen folgt sobald Outlock geöffnent ist) und wie lange sie geht.

so mit A,B,C will ich nun verschiede Ressourcen angeben können in dem beispiel hab ich ein PC definiert.

Besesr kapiert?

CStoll

Wenn das so ist, brauchst du nach dem Anlegen der Allokation eigentlich keinen Zugriff von außen auf ihre Attribute, oder? Du brauchst nur eine virtuelle Methode starte(), die ihr sagt, daß sie jetzt das tun soll, was immer nötig ist (innerhalb dieser Methode hast du vollen Zugriff auf alle Attribute, die du für die Arbeit brauchst).

PS: Kann es sein, daß du die Klassenhierarchie (es gibt eine abstrakte Basisklasse sowie verschiedene konkrete Allokations-Typen) und deine Baumstruktur (die Art, wie die Allokationen zusammengefasst/gruppiert werden) durcheinanderwirfst?

BorisDieKlinge

Meisnt du so?

wenn ich ressorurtentyp mit allokationdauer erstelle wird die dauer der reservierung über den Konstruktor der AllocNode übergeben..

Oder hab ich nich verstandne was du willst?

class A : public AllocNode){

 int balbal;

 A(double start, double dauer,int blalbal) : AllocNode(start,dauer), balbal  (blalbla){}

}

ne das sieht nur in dem baum diagrmm oben so aus....

A kann auch A kinder haben, und A1 kinder kann auch A1 kinder haben etc.

CStoll

BorisDieKlinge schrieb:

Meisnt du so?

wenn ich ressorurtentyp mit allokationdauer erstelle wird die dauer der reservierung über den Konstruktor der AllocNode übergeben..

Oder hab ich nich verstandne was du willst?

Ja, so in etwa. Jetzt brauchst du noch eine Methode (eventuell abstrakt in der Basisklasse), die die Allokation "ausführt". Die A-Version dieser Methode wertet dann den Inhalt von 'int blabal;' aus, um ihre jeweiligen Ziele zu erreichen.

Und für die inneren Knoten der Baumstruktur solltest du zwei eigene Klassen ParallelAlloc und SequentialAlloc anlegen, die jeweils eine list<AllocNode*> verwalten und zum Ausführen über diese list<> laufen und alle Elemente anschubsen:

class Alloc
{
  double start,len;
public:
  Alloc(double st,double ln) : start(st),len(ln) {}
  virtual void execute() = 0;
};

class MailAlloc : public Alloc
{
  string server,pw;
public:
  MailAlloc(...);
  virtual void execute()
  {
    //verbinde dich mit Mail-Server und hole alle anstehenden E-Mails
  }
};

class SequentialAlloc : public Alloc
{
  list<Alloc*> elements;
public:
  SequentialAlloc(...);
  //Methoden zum Anlegen der Liste
  ...

  virtual void execute()
  {
    for(list<Alloc*>::iterator p=elements.begin();p!=elements.end();++p)
      (*p)->execute();
  }
};

BorisDieKlinge

ok danke, ich schau mir das mal an und denk drüber nach.. vll. komm ich ja auf ne die...

Konrad Rudolph

HumeSikkins schrieb:

Mal unabhängig davon sollte man imo darauf hinweisen, dass dein Beispiel nicht mit dem des OP zu vergleichen ist.

Ja, das ist mir schon klar. Darum ging es ja auch nie, ich habe mein Beispiel in einem ganz anderen Kontext gebracht.