4. Dynamisches Array von BitBtns

Dynamisches Array von BitBtns

  • L

    Hallo,

    in bisherigen Anwendungen habe ich zur Erstellung einer Matrix aus BitBtns das nachstehende Verfahren angewendet. Da bei Programmbeginn die Dimensionen bekannt waren, konnte das Matrixfeld testBtns[][] 'statisch' dimensioniert werden.

    In einer neuen Anwendung soll soll der Benutzer jedoch die Möglichkeit haben, bei Programmstart die Dimensionen festzulegen.

    Was muss ich ändern?

    ButtonMatrix.h

    //---------------------------------------------------------------------------
enum  { N_ZEILEN = 5, N_SPALTEN = 7 };
class TForm1 : public TForm
{
__published:	// IDE-verwaltete Komponenten
//(…)
private:	// Benutzer-Deklarationen
	// Zeiger auf Buttons in einer Matrix
	TButton* testBtns[N_ZEILEN][N_SPALTEN];

//(…)

public:		// Benutzer-Deklarationen
	__fastcall TForm1(TComponent* Owner);
 // __fastcall ~TForm1();   nicht noetig
};
//---------------------------------------------------------------------------
extern TForm1 *Form1;
//---------------------------------------------------------------------------
#endif

    ButtonMatrix.cpp

    //(...)
void __fastcall TForm1::btn_KomponentenDynamischErzeugenClick(TObject *Sender)
{
    // 35 Buttons dynamisch erzeugen
    int left, top; // Fuer Knoeppe
    for (int zeile = 0; zeile < N_ZEILEN; zeile++)
    {
        top = 15 + zeile * 25; 
        for (int spalte = 0; spalte < N_SPALTEN; spalte++)
        {
            // Referenzen sparen Tipparbeit
            TButton* (&theButton) = testBtns[zeile][spalte];
    	    theButton = new TButton(this); // Owner = Formular

            left = 5 + spalte * 45;
            theButton->SetBounds(left, top, 40, 20);  // 40*20 Rechteck
            theButton->Parent = GroupBox1; // Parent setzen

            // Ereignis-Handler zuweisen
            theButton->OnClick = matrixBtnClick;

            // Tag-Eigenschaft 
            theButton->Tag = zeile * 10 + spalte;
        } 
   }

}
//---------------------------------------------------------------------------
//(...)
void __fastcall TForm1::btn_KomponentenLoeschenClick(TObject *Sender)
{
     for (int zeile = 0; zeile < N_ZEILEN; zeile++)
        for (int spalte = 0; spalte < N_SPALTEN; spalte++)
    	    delete testBtns[zeile][spalte];
}
//---------------------------------------------------------------------------
//(...)

    Besten Dank für Eure Anregungen.

    Gruß
    Leo

    0
  • B

    ➡ FAQ - Dynamische Array

    0
  • L

    BigNeal schrieb:

    ➡ FAQ - Dynamische Array

    Hallo,

    könntest Du Deinen Tipp etwas präzisieren. Ich finde weder in der C++-FAQ, noch in der Borland FAQ zum Suchbegriff 'Dynamische Array' einen Eintrag.

    Gruß
    Leo

    0
  • B

    ➡ FAQ - Komponenten benutzen - Dynamische Arrays von Komponenten oder Objekten 😉

    0
  • L

    BigNeal schrieb:

    ➡ FAQ - Komponenten benutzen - Dynamische Arrays von Komponenten oder Objekten 😉

    Sorry, mein Fehler. Aber ich staune etwas, dass der Algorithmus der Suchfunktion den von Dir genannten Eintrag nicht liefert, wenn ich nach 'Dynamische Array' suche?!

    Zum eigentlichen Problem:
    Ich habe zu diesem Thema schon alle möglichen Hilfen gelesen, und da bringt mich Dein Hinweis auf die FAQ leider nicht weiter. Mir wäre geholfen, wenn sich jemand auf mein Beispiel beziehen würde - 'mehr'dimensionales Array -, um idealerweise lernen zu können, was bei mir falsch ist, und dies verändern kann.

    Besten Dank
    Leo

    0
  • B

    1. du musst das ganze mit DynamicArray deklarieren
    zB

    DynamicArray<TButton*> testBtns;             // eindimensionales array

    und durch new eine erstellen

    testBtns.Length++;                //nachlesen
testBtns[0] = new TButton;             // Butten erstellen
testBtns[0]->Caption = "Hallo";         // so kannst du es ansteuern
...
..
..
delete testBtns[0];       // nicht vergessen

    und zu 2 dimensionalen array.. BCB-Hilfe "DynamicArray"

    Mehrdimensionale dynamische Arrays

Dynamische Arrays können mehrdimensional sein, wobei die einzelnen 
Dimensionen nicht gleich groß sein müssen. Die Größe jeder Dimension 
kann über die Eigenschaft Length festgelegt werden. Dazu ein Beispiel:

typedef DynamicArray< DynamicArray < AnsiString > > T2DStringArray; // 2 dimensionales Dynamisches Array wird definiert  -- schlüssel befehl für dich

void foo(T2DStringArray &s_array)
{
  SetLength(s_array, 10);
  for (int i=0; i<s_array.Length; i++)
  { // Größe der zweiten Dimensionen festlegen 
    // (Beachten Sie die unterschiedliche Größe!) 
    SetLength(s_array[i], i+1); 
    for (int j=0; j<s_array[i].Length; j++)
    /* */ s_array[i][j] = itoa(i*10+j);
  }
}

    die erste zeile musst du verstehen... der rest sollte sich mehr oder weniger erklähren

    0
  • L

    BigNeal schrieb:

    <Fullquote gelöscht>

    Hallo,

    das Beispiel aus der Hilfe habe ich auch schon studiert. Abgesehen davon, dass es nicht vollständig ist, d.h. die Methoden

    fillArrayOfString(oneD);

    und

    fill2DArrayOfString(twoD);

    werden unterschlagen.

    Außerdem kann ich aus diesem Beispiel nicht ableiten, wodurch denn die AnsiString-Methoden

    SetLength

    bzw.

    xyz.Length

    bei der Verwendung von Button-Objekten ersetzt werden müsste.

    Hier wäre ein passenderes Beispiel sicherlich erleuchtender.

    Gruß
    Leo

    Edit:
    Zitate bitte auf das Notwendigste beschränken. Danke!

    0
  • B

    ich war gestern gerade auf dem heimweg und ich hatte das auch noch nie gemacht..
    aber ich habe hier mal ein beispiel zusammengestellt.
    ich hoffe es hilft weiter..

    void __fastcall TForm1::Button1Click(TObject *Sender)
{
   btn2D.set_length(1);    //1. Dimension grösse auf 1 setzen

   //btn2D.Low = 0;
   for (int x=0;x<6;x++)
   {
      btn2D.Length++;     // grösse für 1. Dimension vergrössern

     // btn2D[x].set_length(10);   //grösser der 2. Dimension für btn2D[x] auf 10 setzen
      for (int y=0;y<6;y++)
      {
         //ShowMessage((String)x+"/"+(String)y);        // durchläufe kontrollieren
         btn2D[x].Length++;
         btn2D[x][y] = new TButton(this);
         btn2D[x][y]->Parent = Form1;
         btn2D[x][y]->Caption = (String)x+"/"+(String)y;
         btn2D[x][y]->Height = 20;
         btn2D[x][y]->Width = 30;
         btn2D[x][y]->Top = y*20;
         btn2D[x][y]->Left = x*30;

      }
   }
}
//---------------------------------------------------------------------------

void __fastcall TForm1::FormDestroy(TObject *Sender)
{
   btn2D.Length = 0;           // dynamisches Array freigeben
}

    soweit ich die bcb-hilfe verstanden habe, hat sich das delete erledigt..

    BCB-Hilfe schrieb:

    Um ein dynamisches Array freizugeben, setzen Sie einfach seine Größe auf 0:

    arrayOfInt.Length = 0;

    BigNeal

    [edit] im h-File noch:

    typedef DynamicArray< DynamicArray< TButton* > >T2DButtonArray;
   T2DButtonArray btn2D;

    [/edit]

    0
  • B

    das Beispiel aus der Hilfe habe ich auch schon studiert. Abgesehen davon, dass es nicht vollständig ist, d.h. die Methoden

    fillArrayOfString(oneD);

    und

    fill2DArrayOfString(twoD);

    werden unterschlagen.

    die Funktionen:

    dumpArrayOfString() 
dump2DArrayOfString()

    sind angegeben..
    dump = Ausgeben
    fill = Auffüllen
    d.h.: in den fill... funktionen werden nur Daten in die Ansistrings reingeladen, welche in den dump.. ausgegeben werden..

    BigNeal

    0
  • L

    Hallo,

    Vor Deiner letzten Antwort habe ich aus lauter Verlegenheit eine 'Krücke' gebaut, bei der ich ein 1-dimensionales Array 2-dimensional interpretiere.

    // Header

    DynamicArray<TBitBtn* >fldBitBtn;
    int miZeilen;
    int miSpalten;
    int miAnzahl;

    // Cpp-Datei

void __fastcall TForm_Main::sub_definiere_Matrix(int iZeilen, int iSpalten)
{
    miZeilen = iZeilen;
    miSpalten = iSpalten;
    miAnzahl = iZeilen * iSpalten;
}

void __fastcall TForm_Main::sub_erzeuge_Komponenten()
{
    fldBitBtn.Length = miAnzahl; // Größe setzen
    for (int i=0; i<fldBitBtn.Length; i++){
        fldBitBtn[i] = new TBitBtn(this);
    }
} 

void __fastcall TForm_Main::sub_setze_Matrix()
{
    int k = 0;
    for (int zeile=0; zeile<miZeilen; zeile++){
        for (int spalte=0; spalte<miSpalten; spalte++){

            // Beschriftung
            fldBitBtn[k]->Caption = IntToStr(k+1);
            fldBitBtn[k]->SetBounds(spalte*40, zeile*25, 40, 25);
            fldBitBtn[k]->Parent = Form_Main;
            k++;
        }
    }
}

    ... aber jetzt kenne ich ja den eleganteren Weg.

    Danke für die Hilfen!

    Gruß
    Leo

    0
Anmelden zum Antworten