spagetticode herr werden

fuse

wie werd ich nur herr mit diesem spagetticode.

ich habe das nudelgericht dort schon beschrieben:
http://www.c-plusplus.net/forum/viewtopic-var-t-is-190441-and-start-is-0-and-postdays-is-0-and-postorder-is-asc-and-highlight-is-.html

void __fastcall TForm1::FormPaint(TObject *Sender)
{
Canvas->Pen->Color = panel_1_to_65_;
Canvas->MoveTo(Panel1->Left + (Panel1->Width/2),Panel1->Top + (Panel1->Height/2));
Canvas->LineTo(Panel65->Left + (Panel65->Width/2),Panel65->Top + (Panel65->Height/2));

bis zu

Canvas->Pen->Color = panel_1_to_109_;
Canvas->MoveTo(Panel1->Left + (Panel1->Width/2),Panel1->Top + (Panel1->Height/2));
Canvas->LineTo(Panel109->Left + (Panel109->Width/2),Panel109->Top + (Panel109->Height/2));

und dann das ganze nochmal mit pannel 2 bis pannel 64.

und das alles nochmal für jede schicht.

geht das nicht irgendwie eleganter ?
kann man nen variablennamenteil mit anderen variablen angeben
die man inkrementiert (+1) z.b. mit (++[variablennahme];)
(in alten, simplen batch scripts ging das).
gibt es wenn nicht wenigstens ein tool das die zahlen
in aufsteigender reihenfolge einträgt ?

SideWinder

Stichwort: Array

MfG SideWinder

Bashar

Spaghetticode ist Code, dessen Kontrollfluss bis zur Unübersichtlichkeit verschlungen ist. Eine Sequenz einzelner Anweisungen mag manchmal unelegant sein, ist aber so ziemlich das Gegenteil davon.

fuse

ja gut spagetticode ist auch kein code der objektorientiert ist,
aber trotzdem ist der abschnitt lang wie ein spagetti.

auch wenn es ein spagetti mit übersichtlichen schlaufen ist.

wie würdest du sowas denn dann nennen ?

ich kenne ein array als wertetabelle,
aber außer durch oberflächliches probieren
noch nie für nötig befunden win array zu verwenden
und fände es nun interessant wie man ein array da einbetten würde.

es geht ja nicht nur um die variable/array
sondern auch um das entsprechende panelx.

mit welche syntax kann man das Panel[nummer] so ansprechen,
daß die sache scheifenfähig wird ?

Bashar

fuse schrieb:

ja gut spagetticode ist auch kein code der objektorientiert ist,
aber trotzdem ist der abschnitt lang wie ein spagetti.

Das hat nichts mit der Länge zu tun, nur mit der Verschlungenheit. Und OOP-Code kann auch Spaghetti-Code sein, das geht sogar sehr schnell.

fuse

danke für die wortdefinition
und wie sagt man nun zu code der unnötig lang ist
und den man vielleichti neiner schleife kürzer lösen könnte ?

ich habe nun die variable durch nen array ersetzt

das mit arrays war aber einfach..
das hatte ich doch schonmal verwendet
aber da es array heißt hab ich mir nicht gemerkt.
man hätte auch mehrdimensionale variablen sagen können oder ?

und wie mach ich das nun mit den panel objekten ?

Hi,

ich würde einfach die drei Zeilen in eine Funktion stecken und die jeweils mit den Argumenten Color und Panel aufrufen. Obs mit nem Array wirklich übersichtlicher ist ist die Frage, denn das muß ja auch erst mal gefüllt werden, wird also auch nicht kürzer.

void __fastcall TForm1::ZeichnePanel(TColor ColorWert, TPanel * AktuPanel )
{
Canvas->Pen->Color = ColorWert;
Canvas->MoveTo(Panel1->Left + (Panel1->Width/2),Panel1->Top + (Panel1->Height/2));
Canvas->LineTo(AktuPanel->Left + (AktuPanel->Width/2),AktuPanel->Top + (AktuPanel->Height/2));
}

ZeichnePanel( panel_1_to_65_, Panel65 );
ZeichnePanel( panel_1_to_66_, Panel66 );
...

Gruß Mümmel das Mümmel

Braunstein

Es ist schon deswegen kürzer, weil man dann den Aufruf in eine Schleife packen kann.
Bezüglich Array von panels siehe unsere FAQ (Komponenten benutzen).

std::vector<TPanel*>

Hi,

jaja, ist mir schon klar, aber sich selbst füllende Arrays gibts noch nicht, man muß also irgendwo auch das Array mit Werten füllen. Bei den Farben ist das nicht so das Problem, die muß man ja sowieso definieren, kanns also auch gleich in Arrayform machen. Aber wenn die einzelnen Panels nicht zur Laufzeit sondern zur Entwurfszeit erstellt werden ists nur Mehrarbeit.
Kommt immer auf die konkrete Situation an.
Nur um ein Array benutzen zu können extra erst den ganzen quelltext umstellen macht nicht immer Sinn. Da geht die Variante von mir sicher besser, auch wenn sie nicht optimal ist.
Wenn man aber noich in der Konzeptionsphase ist, ist der Arrayweg sicher besser.

Gruß Mümmel das Mümmel

fuse

genau und da es eine übung ist läuft es richtung array hinaus.
wenn sich der index im laufe der bearbeitung nicht schnell mal ändern würde
könnt man es ja auch so machen:

for(int zielindex=101; zielindex<146;++zielindex)
  {
  Canvas->Pen->Color = (TColor)verbindung_von_zu_[1][zielindex-36];
  Canvas->MoveTo(Panel1->Left + (Panel1->Width/2),Panel1->Top + (Panel1->Height/2));
  Canvas->LineTo(dynamic_cast<TPanel*>(Form1->Components[zielindex])->Left + (dynamic_cast<TPanel*>(Form1->Components[zielindex])->Width/2),dynamic_cast<TPanel*>(Form1->Components[zielindex])->Top + (dynamic_cast<TPanel*>(Form1->Components[zielindex])->Height/2));
  Memo2->Lines->Add(IntToStr(zielindex));
  }

um die panels in ein array zu gießen muß ich noch bissel knabbern.

muß ich die komponenten dynamisch erstellen um die in arrayform zu haben ?
haben die koponenten denn keinen eigenen index ?

wie lässt sich dies auf diesen code anwenden ?:
http://www.c-plusplus.net/forum/viewtopic-var-t-is-39211.html
kann jemand ein beispiel machen ?

fuse

ah hm ja array über pointer.
wir hatten 3 jahre c/c++ unterricht
und keiner kam auf die idee pointer durchzunehmen.

nunja bisher gings auch ganz gut ohne aber praktisch können sie snscheinend schon sein.

wenn ich was nicht wiß frag ich lieber.
obs peinlich ist spielt keine rolle.

wenn ab und zu einer was schreiebt ist es allerdings schon nett

akari

Hallo

Siehe FAQ hier im BCB-Forum, Abschnitt Komponenten benutzen, den Thread über Arrays von dynamische Controls.

Übrigens ist hier

dynamic_cast<TPanel*>(Form1->Components[zielindex])->Left

der dynamic_cast sinnlos. Sinn macht nur wenn nach dynamic_cast die Rückgabe auf 0 überprüft wird. Wenn du es nicht machst reicht auch ein einfacher static_cast

bis bald
akari

Braunstein

Zumal man diese Zeile auch ein wenig kürzen könnte

TPanel* pan = dynamic_cast<TPanel*>(Form1->Components[zielindex]);
if( pan )
  Canvas->LineTo(pan->Left + pan->Width/2,pan->Top + pan->Height/2);

Sieht doch gleich viel übersichtlicher aus.

fuse

cool

ich werd die komponenten dann wahrscheinlich bei zeiten zur laufzeit erzeugen,
da es anders nicht so sauber codierbar zu sein scheint.

außerdem kann die variante ja auch vorteile haben.

Du kannst die Komponente über ihren Namen identifizieren, das erfordert allerdings, dass du die Panels im ObjectInspector mit fortlaufenden Nummern versiehst (bzw. sie bennenst).

std::vector<TPanel*> Panels;

// Platz im Vektor reservieren
Panels.reserve( PANEL_COUNT );

for( unsigned int uiPanelID = 0; uiPanelID < PANEL_COUNT; ++uiPanelID )
{

   // Panelnamen bilden
   AnsiString strPanelName = "PANEL" + IntToStr( uiPanelID );

   // Panel bestimmen
   TPanel* pPanel = dynamic_cast<TPanel*>( FindComponent( strPanelName ) );
   if( NULL != pPanel )
   {
      Panels.push_back( pPanel );
   }
}

Jetzt benutzt du noch die Methode von Braunstein und hast den kompletten Code auf 20 Zeilen reduziert.

MfG
Doc

Nachtrag:
Wenn du es auch noch schaffen solltest, die Farbe des Panels im Panel selbst zu setzen kannst du über einen Functor und for_each den ganzen Abwasch erledigen:

class PaintPanelFunctor
{
   TCanvas* m_pCanvas;

public:
   PaintPanelFunctor( TCanvas* pCanvas ) :
      m_pCanvas( pCanvas )
   {
      assert( NULL != pCanvas );
   }

   void operator()( const TPanel* pPanel ) const
   {
      // Zeichne Panel auf Canvas
   }
};

Der Aufruf zum Zeichnen der Panels sieht dann so aus (benutze std::vector<TPanel*> aus obigem Post)

for_each( Panels.begin(), Panels.end(), PaintPanelFunctor( Canvas ) );

for_each(

fuse

hey das sind ja richtig cool tipps. danke