1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:

//Umwandlung der Eingabetexte von einem String in eine Dezimalzahl
  Lagerhöhe    := Strtofloat (EditLagerhoeheEingabe.Text);    //Angabe in Metern
  Regallänge   := Strtofloat (EditRegallaengeEingabe.Text);   //Angabe in Metern
  Palettenlast := Strtofloat (EditPalettenlastEingabe.Text);  //Angabe in Metern
...
...
...
  //Berechnung der Zeilenanzahl
  Zeilenanzahl := trunc((Lagerhöhe - 1)/1.5);                 

  //Berechnung der Spaltenanzahl
  SpaltenanzahlEinePalette   := trunc(Regallänge/((0.9 * 1) + 0.1));   
  SpaltenanzahlZweiPaletten  := trunc(Regallänge/((0.9 * 2) + 0.1));
  SpaltenanzahlDreiPaletten  := trunc(Regallänge/((0.9 * 3) + 0.1));
  SpaltenanzahlVierPaletten  := trunc(Regallänge/((0.9 * 4) + 0.1));
  SpaltenanzahlFünfPaletten  := trunc(Regallänge/((0.9 * 5) + 0.1));
  SpaltenanzahlSechsPaletten := trunc(Regallänge/((0.9 * 6) + 0.1));

  //Berechnung der Ständerlänge
  StänderlängeEinePalette   := (4 * SpaltenanzahlEinePalette * (Zeilenanzahl - 1) * 1.5);   
  StänderlängeZweiPaletten  := (4 * SpaltenanzahlZweiPaletten * (Zeilenanzahl -1) * 1.5);   
  StänderlängeDreiPaletten  := (4 * SpaltenanzahlDreiPaletten * (Zeilenanzahl -1) * 1.5);  
  StänderlängeVierPaletten  := (4 * SpaltenanzahlVierPaletten * (Zeilenanzahl -1) * 1.5);  
  StänderlängeFünfPaletten  := (4 * SpaltenanzahlFünfPaletten * (Zeilenanzahl -1) * 1.5);  
  StänderlängeSechsPaletten := (4 * SpaltenanzahlSechsPaletten * (Zeilenanzahl -1) * 1.5);   

  //Berechnung des Ständergewichts
  StändergewichtEinePalette   := (StänderlängeEinePalette   * 10.9) * 0.001;  
  StändergewichtZweiPaletten  := (StänderlängeZweiPaletten  * 10.9) * 0.001;
  StändergewichtDreiPaletten  := (StänderlängeDreiPaletten  * 10.9) * 0.001;
  StändergewichtVierPaletten  := (StänderlängeVierPaletten  * 10.9) * 0.001;
  StändergewichtFünfPaletten  := (StänderlängeFünfPaletten  * 10.9) * 0.001;
  StändergewichtSechsPaletten := (StänderlängeSechsPaletten * 10.9) * 0.001;

//  --> Ab hier taucht das Problem jetzt auf.Der Ständerpreis ist abhängig vom Gewicht.
//  --> Alles bis 400kg kostet 1995€,weil der Preis pro Tonne angegeben ist,0.4
//  --> Alles über 400kg und bis 999kg kostet 1639€ und da gibts Probleme mit, wenn z.B
//  -->fürs Gewicht 0.6Tonnen rauskommen, wählt Delphi nicht 1639€, sondern 1995€ als Preis

  //Zuordnung der Ständerpreise, da der Preis vom errechneten Gewicht abhängig ist
  If (StändergewichtEinePalette <= 0.4) then  Ständerpreis := 1995;   //0,4 stehen für 0,4 Tonnen, da Preis pro Tonne angegeben wird, bis 400kg
  If (StändergewichtEinePalette > 0.4)  and  (StändergewichtEinePalette <= 0.999) then Ständerpreis := 1639;    //
  If (StändergewichtEinePalette >= 1)   then  Ständerpreis := 1426;   //Ständergewicht ab 1000kg

  If (StändergewichtZweiPaletten <= 0.4) then Ständerpreis := 1995;
  If (StändergewichtZweiPaletten > 0.4)  and  (StändergewichtZweiPaletten <= 0.999) then Ständerpreis := 1639;
  If (StändergewichtZweiPaletten >= 1)   then Ständerpreis := 1426;
...
...
...
// --> Der von Delphi gewählte Ständerpreis soll dann hier eingesetzt werden (was auch funktioniert, bis auf 
// --> Die Tatsache, dass er den falschen Wert einsetz)

  //Berechnung der Ständerkosten
  StänderkostenEinePalette   := (StändergewichtEinePalette   * Ständerpreis);
  StänderkostenZweiPaletten  := (StändergewichtZweiPaletten  * Ständerpreis);
  StänderkostenDreiPaletten  := (StändergewichtDreiPaletten  * Ständerpreis);
  StänderkostenVierPaletten  := (StändergewichtVierPaletten  * Ständerpreis);
  StänderkostenFünfPaletten  := (StändergewichtFünfPaletten  * Ständerpreis);
  StänderkostenSechsPaletten := (StändergewichtSechsPaletten * Ständerpreis);					

1:
2:
3:
4:
5:
6:
7:
8:

  if (StändergewichtEinePalette <= 0.4) then
    Ständerpreis := 1995   //0,4 stehen für 0,4 Tonnen, da Preis pro Tonne angegeben wird, bis 400kg
  else
    if (StändergewichtEinePalette > 0.4) and (StändergewichtEinePalette <= 0.999) then
      Ständerpreis := 1639    //
    else
      if (StändergewichtEinePalette >= 1) then
        Ständerpreis := 1426;   //Ständergewicht ab 1000kg					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:

Type
  PreisList = Array of Real;

function Preis(aAnzahl, aHoehe, aLaenge, aLast: Integer): PreisList;
var
  i: integer;
  Zeilen,
  Laenge,
  Spalte,
  Gewicht: extended;
begin;
  SetLength(Result, aAnzahl);

  Zeilen := (aHoehe - 1) / 1.5;

  for i := low(result) to high(result) do begin
    Spalte := (aLaenge / (0.9 * (i+1) + 0.1));
    Laenge := (4 * Spalte * (Zeilen - 1) * 1.5);
    Gewicht  := (Laenge  * 10.9) * 0.001;

    if (Gewicht < 0.4) then
      result[i] := 1995 * Gewicht
    else
    if (Gewicht > 0.4) and (Gewicht <= 0.999) then
      result[i] := 1639 * Gewicht
    else
       if (Gewicht >= 1) then
      result[i] := 1426 * Gewicht;

  end;
end;

meinpreis := Preis(10, 5, 5, 100)[6]					

1:

Function Name(Paramter1,Parameter2,...,Paramter3: Typ1; Parameter4, Paramter5: Typ2): Rückgabetyp;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:

type
  TPreisList = Array of Real;

function Preis(aAnzahl, aLaenge,aHoehe, aLast: Integer): TPreisList; 
var
  i,
  Zeilen,
  Laenge,
  Spalte: Integer; // Ganzzahlen
  Gewicht: Extended; // Extended entspricht Real = Fließkommazahl/Fließpunktzahl
begin
  {Ein Array stellt eine Aneinanderkettung n Elemte dar, ersetzt also deine zig einzeln deklarierten Variablen für jede Palettenanzahl!
  In diesem Fall wird ein dyn. Array verwendet, um flexibel auf die Palettenanzahl reagieren zu können.
  Dynamisch ist das Gegenteil von statisch. Bei einem statischen Array werden die Grenzen (Anzahl der Elemente) bereits beim Deklarieren festgelegt. Beispiel: Array[1..10] of Integer;
  Bei einem Dynamischen werden die Grenzen erst im Code via SetLength(Array, Länge) festgelegt. Zu beachten ist, dass ein dynm. Array immer bei 0 beginnt!!
  Result meint hier das, was die Funktion zurückgibt. }
  SetLength(Result, aAnzahl); 

  Zeilen := Trunc((aHoehe - 1) / 1.5);

  // Low ermittelt die untere, High die obere Grenze eines Arrays! 
  for i := Low(result) to High(result) do begin
    Spalte := Trunc(aLaenge / (0.9 * (i+1) + 0.1)); // i+1, da der Index bei 0 beginnt ;-)
    Laenge := Trunc(4 * Spalte * (Zeilen - 1) * 1.5);
    Gewicht  := (Laenge  * 10.9) * 0.001;

  { Result ist die Variable, die die Funktion zurückgibt. Da der Rückgabetyp als Array deklariert wurde, greifen wir mittels Index auf die einzelnen Elemente zu.
    result[3] meint beispielsweise die Variable Nummer 4 in der Liste vom Typ Real! }
   if (Gewicht < 0.4) then
      result[i] := 1995 * Gewicht
    else
    if (Gewicht > 0.4) and (Gewicht <= 0.999) then
      result[i] := 1639 * Gewicht

    else
       if (Gewicht >= 1) then
      result[i] := 1426 * Gewicht;
  end;
end;

 // Nun kann man Beispielsweise wie folgt die Funktion verwenden:
    Showmessage( FloatToStr( Preis(10,20,5,100)[1] ));
 // Zeigt das Ergebnis für zwei Paletten an.					

1:
2:
3:

If (StändergewichtZweiPaletten <= 0.4) then Ständerpreis := 1995;
  If (StändergewichtZweiPaletten > 0.4)  and  (StändergewichtZweiPaletten <= 0.999) then Ständerpreis := 1639;
  If (StändergewichtZweiPaletten >= 1)   then Ständerpreis := 1426;					

1:
2:
3:

If (StändergewichtZweiPaletten <= 0.4) then StänderkostenZweiPaletten := (StändergewichtZweiPaletten  * 1995) else
  If (StändergewichtZweiPaletten > 0.4)  and (StändergewichtZweiPaletten <= 0.999) then StänderkostenZweiPaletten := (StändergewichtZweiPaletten  * 1639) else
  If (StändergewichtZweiPaletten >= 1)   then StänderkostenZweiPaletten := (StändergewichtZweiPaletten  * 1426);