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 ?

MfG SideWinder

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 ?

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.

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 ?

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

std::vector<TPanel*>

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

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 ?

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

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

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.

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.

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

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(