# GAMBAS BOOK 3.15.2

## Data types

### Chapters

02.07.2018
k7:k7.4:k7.4.9:k7.4.9.1:start

## 7.4.9.1.1 Example 1 - Sorting a one-dimensional native array

Sorting the elements of one-dimensional native arrays works with the sort(…)method without any problems - as the following example shows:

```Public Sub btnNativesArraySortieren_Click()
Dim iCount, k As Integer
Dim a1DArray As New String[]
Dim aNames As String[] = ["Adler", "Bär", "Dachs", "Fuchs", "Meise", "Uhu", "Elch"]

iCount = 5
a1DArray.Resize(iCount)

Randomize

For k = 0 To a1DArray.Bounds[0] - 1
a1DArray[k] = aNames[Int(Rnd(0, aNames.Count))]
Next ' k

ShowElements(a1DArray)
a1DArray.Sort(gb.Ascent) ' Sortier-Standard a..z
ShowElements(a1DArray)
a1DArray.Reverse()
ShowElements(a1DArray)

End ' btnNativesArraySortieren_Click()

Public Sub ShowElements(aArray As String[])
Dim sElement As String

For Each sElement In aArray
Print sElement,
Next ' sElement
Print

End ' ShowElements(aArray As String[]) ```

Displays the elements of the a2DArray array in the console of the Gambas IDE:

```Bär     Uhu     Adler   Meise   Fuchs   → Original
Adler   Bär     Fuchs   Meise   Uhu     → Sorted in ascending order
Uhu     Meise   Fuchs   Bär     Adler   → Sorted elements inverted sorted sorted ```

Hint:

The rearranging of elements in an array with the method Array.Reverse() can be seen as a special case of sorting an array. All elements from[E0 to Ek] in the array are rearranged to[Ek to E0].

## 7.4.9.1.2 Example 2 - Sorting a one-dimensional derived array

The names of all control elements of the' Label' type are to be explored and sorted on the form. The following idea for implementation sounds plausible:

• First, all control elements of type Label are captured and the labels found are stored as an object in a derived array of aLabels of type Label[].
• Then the array aLabels (ascending) is sorted.
• Then the label names of the sorted labels are read and displayed in the array aLabels.

The following source code is used:

```Public Sub btnSortLabel1_Click()
Dim k As Integer
Dim lLabel As Label
Dim aLabels As New Label[]
Dim hControl As Control

For Each hControl In Me.Children
If Object.Type(hControl) = "Label" Then
Inc k
aLabels.Resize(k)
aLabels[k - 1] = hControl
Endif
Next ' hControl

For Each lLabel In aLabels ' Zur Kontrolle
Print lLabel.Name
Next
aLabels.Sort(gb.Ascent)
For Each lLabel In aLabels
Print lLabel.Name
Next

End ' btnSortLabel1_Click()```

For control purposes, the names of the labels are first output from the original, unsorted array. This result was shown in the console of the IDE:

```lblMultiArray
lblClassArray
lblLabels
lblDemonstration```

The order of the elements in the aLabels array corresponds to the order of the individual labels in the hierarchy of visible controls in the Gambas IDE. You can't be satisfied with the output of the names of the labels from the sorted array aLabels:

```lblClassArray
lblLabels
lblMultiArray
lblDemonstration```

Sorted looks different! The reason for this is that the elements in an array of the type Label[] - as a derived array - are compared by their addresses in memory, since the class Label does not implement a _compare () method.

The original idea is modified for this reason:

• First, all controls of type Label are captured and from all labels found, the label names are immediately stored in an array of aLabelNames of type String[].
• Then the native array aLabelNames (ascending) is sorted.
• Finally, the label names are read and displayed from the sorted array aLabelNames.

The modified source code can be read here:

```Public Sub btnSortLabel2_Click()
Dim k As Integer
Dim sName As String
Dim aLabelNames As New String[] ' Natives Array
Dim hControl As Control

For Each hControl In Me.Children
If Object.Type(hControl) = "Label" Then
Endif
Next ' hControl
For Each sName In aLabelNames ' Zur Kontrolle
Print sName
Next
Print
aLabelNames.Sort(gb.Ascent)
For Each sName In aLabelNames
Print sName
Next
End ' btnSortLabel2_Click()```

The console now displays the correct list of ascending sorted label names:

```lblClassArray
lblDemonstration
lblLabels
lblMultiArray```

Articles

## 7.4.9.1.1 Beispiel 1 – Sortierung eines eindimensionalen nativen Arrays

Das Sortieren der Elemente von eindimensionalen nativen Arrays funktioniert mit der Sort(..)-Methode problemlos – wie das folgende Beispiel zeigt:

```Public Sub btnNativesArraySortieren_Click()
Dim iCount, k As Integer
Dim a1DArray As New String[]
Dim aNames As String[] = ["Adler", "Bär", "Dachs", "Fuchs", "Meise", "Uhu", "Elch"]

iCount = 5
a1DArray.Resize(iCount)

Randomize

For k = 0 To a1DArray.Bounds[0] - 1
a1DArray[k] = aNames[Int(Rnd(0, aNames.Count))]
Next ' k

ShowElements(a1DArray)
a1DArray.Sort(gb.Ascent) ' Sortier-Standard a..z
ShowElements(a1DArray)
a1DArray.Reverse()
ShowElements(a1DArray)

End ' btnNativesArraySortieren_Click()

Public Sub ShowElements(aArray As String[])
Dim sElement As String

For Each sElement In aArray
Print sElement,
Next ' sElement
Print

End ' ShowElements(aArray As String[]) ```

Anzeige der Elemente des Arrays a2DArray in der Konsole der Gambas-IDE:

```Bär     Uhu     Adler   Meise   Fuchs   → Original
Adler   Bär     Fuchs   Meise   Uhu     → Aufsteigend sortiert
Uhu     Meise   Fuchs   Bär     Adler   → Sortierte Elemente invertiert sortiert ```

Hinweis:

Das Umsortieren der Elemente in einem Array mit der Methode Array.Reverse() kann als Spezialfall des Sortierens eines Arrays aufgefasst werden. Dabei werden alle Elemente von [E0 bis Ek] im Array auf [Ek bis E0] umsortiert.

## 7.4.9.1.2 Beispiel 2 – Sortierung eines eindimensionalen abgeleiteten Arrays

Es sollen die Namen aller Steuerelemente vom Typ 'Label' auf dem Formular erkundet und sortiert ausgegeben werden. Die folgende Idee zur Umsetzung klingt plausibel:

• Zuerst werden alle Steuerelemente vom Typ Label erfasst und die gefundenen Label als Objekt in einem abgeleiteten Array aLabels vom Typ Label[ ] gespeichert.
• Dann wird das Array aLabels (aufsteigend) sortiert.
• Anschließend werden die Label-Namen der sortierten Label im Array aLabels ausgelesen und angezeigt.

Folgender Quelltext wird eingesetzt:

```Public Sub btnSortLabel1_Click()
Dim k As Integer
Dim lLabel As Label
Dim aLabels As New Label[]
Dim hControl As Control

For Each hControl In Me.Children
If Object.Type(hControl) = "Label" Then
Inc k
aLabels.Resize(k)
aLabels[k - 1] = hControl
Endif
Next ' hControl

For Each lLabel In aLabels ' Zur Kontrolle
Print lLabel.Name
Next
aLabels.Sort(gb.Ascent)
For Each lLabel In aLabels
Print lLabel.Name
Next

End ' btnSortLabel1_Click()```

Zur Kontrolle werden zuerst die Namen der Label aus dem originalen, unsortierten Array ausgegeben. Es zeigte sich dieses Ergebnis in der Konsole der IDE:

```lblMultiArray
lblClassArray
lblLabels
lblDemonstration```

Die Reihenfolge der Elemente im Array aLabels entspricht der Reihenfolge der einzelnen Label in der Hierarchie der sichtbaren Steuerelemente in der Gambas-IDE. Mit dem Ergebnis bei der Ausgabe der Namen der Label aus dem sortierten Array aLabels kann man nicht zufrieden sein:

```lblClassArray
lblLabels
lblMultiArray
lblDemonstration```

Sortiert sieht anders aus! Der Grund ist darin zu sehen, dass die Elemente in einem Array vom Typ Label[ ] – als einem abgeleitetem Array – nach ihren Adressen im Speicher verglichen werden, da die Klasse Label keine _compare()-Methode implementiert.

Die ursprüngliche Idee wird aus diesem Grund modifiziert:

• Zuerst werden alle Steuerelemente vom Typ Label erfasst und von allen gefundenen Labeln sofort die Label-Namen in einem Array aLabelNames vom Typ String[ ] gespeichert.
• Dann wird das native Array aLabelNames (aufsteigend) sortiert.
• Abschließend werden die Label-Namen aus dem sortierten Array aLabelNames ausgelesen und angezeigt.

Der modifizierte Quelltext ist hier nachzulesen:

```Public Sub btnSortLabel2_Click()
Dim k As Integer
Dim sName As String
Dim aLabelNames As New String[] ' Natives Array
Dim hControl As Control

For Each hControl In Me.Children
If Object.Type(hControl) = "Label" Then
Endif
Next ' hControl
For Each sName In aLabelNames ' Zur Kontrolle
Print sName
Next
Print
aLabelNames.Sort(gb.Ascent)
For Each sName In aLabelNames
Print sName
Next
End ' btnSortLabel2_Click()```

In der Konsole wird nun die korrekte Liste der aufsteigend sortierten Label-Namen angezeigt:

```lblClassArray
lblDemonstration
lblLabels
lblMultiArray```