Variable erhöhen, wie es in php möglich ist (varx++)?

[NoGAD]

Zitat von Harry Stahl:

Oder so:

Das ist ja mal eine geniale Lösung!
Die gefällt mir, weil die sehr schön übersichtlich bleibt.


Diese Zeile ist mir gänzlich neu, so ein Konstrukt habe ich noch nie gesehen:

  TMyIntegerHelper = record helper for TMyInt Sehr Interessant!


Ganz herzlichen Dank.


Nachtrag:
Ich habe die function erweitert, damit das inc(x,n) kompatibel bleibt

function inc(aAnzahl: Integer = 1): TMyInt; inline;
LG

[mytbo]

Wünsche einen schönen guten Abend!

Zitat von NoGAD:

Delphi-Quellcode:

  varx[1].a := 'Bla 1';
  varx[1].b := 'Bla 1 b';
  varx[2].a := 'Bla 2';
  varx[2].b := 'Bla 2 b';
  varx[3].a := 'Bla 3';
  varx[3].b := 'Bla 3 b';

Hmm, der Wunsch war ja, sich lästige Tipparbeit zu sparen. Warum empfinde ich jetzt ausgerechnet die Ausgangsform als kurz und gut lesbar, während sich dieses Gefühl bei den vorgeschlagenen Varianten nicht einstellen mag?

Bis bald...
Thomas

[KodeZwerg]

Zitat von Harry Stahl:

Zitat von KodeZwerg:

Oder einfach "Succ()" verwenden und den Rest rausschmeißen.

Succ liefert nur ein Funktionsergebnis zurück, erhöht x selber aber nicht, dürfte also nicht helfen...

Stimmt!

Delphi-Quellcode:

  for var i := 1 to 3 do
    begin
      varx[i].a := 'Bla ' + IntToStr(i);
      varx[i].b := 'Bla ' + IntToStr(i) + ' b';
    end;

oder

Delphi-Quellcode:

procedure SetContent(const AIndex: Integer);
begin
  varx[AIndex].a := 'Bla ' + IntToStr(AIndex);
  varx[AIndex].b := 'Bla ' + IntToStr(AIndex) + ' b';
end;


...

  for var i := 1 to 3 do
    SetContent(i);

oder

Delphi-Quellcode:

procedure SetContent(const AIndex: Integer; const AStr1, AStr2: string);
begin
  varx[AIndex].a := AStr1;
  varx[AIndex].b := AStr2;
end;


...

  for var i := 1 to 3 do
    SetContent(i, 'String1', 'String2');

oder oder oder

[NoGAD]

Zitat von mytbo:

Wünsche einen schönen guten Abend!
Hmm, der Wunsch war ja, sich lästige Tipparbeit zu sparen. Warum empfinde ich jetzt ausgerechnet die Ausgangsform als kurz und gut lesbar

Hallo und einen guten Abend zurück!


Ich habe hier den record, den ich mit über 100 Strings definieren möchte. (Es ginge auch mit vielen anderen Mitteln, wie resourceen, textdateien, inifiles usw.)

Wenn ich nun meinen Originalcode nehme, müsste ich alle Einträge händisch durchnummerieren. Mit den Möglichkeiten, die mir gegeben wurden, kann ich aber einfach immer zwei Zeilen kopieren und einfügen, muss dann nur die Strings einfügen. Das ist mir einfach zu lästig.

LG

[NoGAD]

[QUOTE=KodeZwerg;1502959][QUOTE=Harry Stahl;1502956]

Zitat von KodeZwerg:

Delphi-Quellcode:

  for var i := 1 to 3 do
    begin
      varx[i].a := 'Bla ' + IntToStr(i);
      varx[i].b := 'Bla ' + IntToStr(i) + ' b';
    end;

Hallo KodeZwerg,

leider ist das nicht nutzbar, weil Du leider die Frage falsch verstanden hast. Mir ging es nicht um die Werte in den Strings, die sich erhöhen sollen, sondern das Array soll dynamisch sein.

varx[i].a <-- das i wollte ich automatisch erhöhen lassen, weil die Strings fix sind.

LG

[Uwe Raabe]

Alles schön und gut, aber mir persönlich erscheint dann dies hier immer noch am übersichtlichsten. Ist halt Geschmackssache (und PHP ist mir nicht ganz geheuer).

Delphi-Quellcode:

  x := 1;
  varx[x].a := 'Bla 1';
  varx[x].b := 'Bla 1 b';

  Inc(x);
  varx[x].a := 'Bla 2';
  varx[x].b := 'Bla 2 b';

  Inc(x);
  varx[x].a := 'Bla 3';
  varx[x].b := 'Bla 3 b';

[KodeZwerg]

Zitat von NoGAD:

leider ist das nicht nutzbar, weil Du leider die Frage falsch verstanden hast.

Wir gehen verschiedene Wege, soll vorkommen :-]
(ps: hab noch mehr rangepappt da oben)

[NoGAD]

Guten Morgen.

Mir ist diese Nacht bewusst geworden, dass es im Prinzip doch auch viel einfacher geht.

Warum soll ich mich eigentlich mit der Verwaltung des 'index' beschäftigen?

Eine Verarbeitung, mittels .add('string1', 'string2'); macht doch noch mehr Sinn. Innerhalb der Verarbeitung kann ich dann sogar das Array wieder selbst verwalten und muss die Größe nicht im vorraus fixieren..

Ich bastel das nachher zusammen und gebe das dann hier als Rückmeldung bekannt. 🤗👋🏻

[NoGAD]

Hier meine Idee der Umsetzung eines sich selbst erhöhenden Arrays, mit gleichzeitiger Zuweisung von Werten.

Delphi-Quellcode:

interface

type
  TMyAddResult = record
    MyResult: Boolean;
    MyIndex: Integer;
  end;

type
  TMyTippOfDayRecord = record
    Tipp: String;
    Info: String;
  end;

Type
  TMyTippOfDay = Array of TMyTippOfDayRecord;

  function Add(var aTippArray: TMyTippOfDay; aTipp, aInfo: String): TMyAddResult;

var
  ToDRecord: TMyTippOfDay;

implementation

function Add(var aTippArray: TMyTippOfDay; aTipp, aInfo: String): TMyAddResult;
var
  DummyIndex: Integer;
begin
  Dummyindex := 1;
  try
    try
      if Length(aTippArray) > 0 then
        DummyIndex := Succ(Length(aTippArray));

      SetLength(aTippArray, DummyIndex);
      aTippArray[Pred(DummyIndex)].Tipp := aTipp;
      aTippArray[Pred(DummyIndex)].Info := aInfo;
    finally
      Result.MyIndex := DummyIndeX;
      Result.MyResult := True;
    end;
  except
    Result.MyResult := False;
    Result.MyIndex := -1;
  end;

end;

initialization

if not Add(ToDRecord, 'Bla 1', 'Hallo 1').MyResult then
  ShowMessage('Ein Fehler trat auf.');
if not Add(ToDRecord, 'Bla 2', 'Hallo 2').MyResult then
  ShowMessage('Ein Fehler trat auf.');
if not Add(ToDRecord, 'Bla 3', 'Hallo 3').MyResult then
  ShowMessage('Ein Fehler trat auf.');
if not Add(ToDRecord, 'Bla 4', 'Hallo 4').MyResult then
  ShowMessage('Ein Fehler trat auf.');

Ein Zugriff später könnte dann wie folgt passieren:

Delphi-Quellcode:

var
  DummyX: Integer;
begin
  for DummyX := 0 to Pred(Length(ToDRecord)) do
    ShowMessage('Tipp: ' + ToDRecord[DummyX].Tipp + slinebreak+
                'Info: ' + ToDRecord[DummyX].Info);

Was ich noch schön fände, wäre, wenn function Add zu TMyTippOfDay gehören würde. Aber das geht scheinbar nur bei records.


Edit: Code wurde korrigiert.

LG

[dummzeuch]

Zitat von NoGAD:

Hier meine Idee der Umsetzung eines sich selbst erhöhenden Arrays, mit gleichzeitiger Zuweisung von Werten.

Da muss ich doch gleich mal meckern:

Zitat von NoGAD:

Delphi-Quellcode:

function Add(var aTippArray: TMyTippOfDay; aTipp, aInfo: String): TMyAddResult;
var
  DummyIndex: Integer;
begin
  Dummyindex := 1;
  try
    try
      if Length(aTippArray) > 0 then
        DummyIndex := Succ(Length(aTippArray));

      SetLength(aTippArray, DummyIndex);
      aTippArray[Pred(DummyIndex)].Tipp := aTipp;
      aTippArray[Pred(DummyIndex)].Info := aInfo;
    finally
      Result.MyIndex := DummyIndeX;
      Result.MyResult := True;
    end;
  except
    Result.MyResult := False;
    Result.MyIndex := -1;
  end;

end;

Diese ganze Rechnerei mit dem Index ist doch unnötig:

Delphi-Quellcode:

begin
  try
    try
      DummyIndex := Length(aTippArray);
      SetLength(aTippArray, DummyIndex+1);
      aTippArray[DummyIndex].Tipp := aTipp;
      aTippArray[DummyIndex].Info := aInfo;
      Inc(DummyIndex);
    finally
      Result.MyIndex := DummyIndex;
      Result.MyResult := True;
    end;
  except
    Result.MyResult := False;
    Result.MyIndex := -1;
  end;
end;

macht genau dasselbe und ist einfacher zu lesen. Wobei ich mir nicht ganz sicher bin, was MyIndex sein soll. Der Index des neu hinzugefügten Wertes? In dem Fall entfällt das Inc(DummyIndex).