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

[NoGAD]

Hallo,

gibt es eine Möglichkeit, wenn z.B. ein Record gefüllt werden soll und ich die Zuweisung bei einer Initialisierung wie folgt vornehmen muss:

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';

den Zähler wie in php zu erhöhen, dass ich mir Tipparbeit ersparen kann?

Delphi-Quellcode:

  x:=0;
  varx[x++].a := 'Bla 1'; //x = 1
  varx[x].b := 'Bla 1 b';
  varx[x++].a := 'Bla 2'; //x = 2
  varx[x].b := 'Bla 2 b';
  varx[x++].a := 'Bla 3'; //x = 3
  varx[x].b := 'Bla 3 b';

Eine Schleife kommt nicht in Frage, weil die Zuweisung eine Art Initialisierung ist.

LG

[dummzeuch]

Nicht schön, aber tut, was Du willst:

Delphi-Quellcode:

function doInc(var _i: integer): integer;
begin
 _Inc(_i);
 Result := _i;
end;

  x := 0;
  varx[doInc(x)].a := 'Bla 1'; //x = 1
  varx[x].b := 'Bla 1 b';
  varx[doInc(x)].a := 'Bla 2'; //x = 2
  varx[x].b := 'Bla 2 b';
  varx[doInc(x)].a := 'Bla 3'; //x = 3
  varx[x].b := 'Bla 3 b';

Wobei: Bist Du dir sicher, dass in PHP x++ ein Pre-Increment ist? In C ist es ein Post-Increment (Pre-Increment wäre ++x), also Liefert:

Code:

x := 0;
y := x++

wirklich x = 0 und y = 1 ?

[NoGAD]

Das mit der function hatte ich schon überlegt. Hoffe aber, dass es etwas Neues gibt, was Ich noch nicht kannte.


Vielen Dank für die Hilfe. Für meine Belange habe ich es erst einmal so gemacht:

Delphi-Quellcode:

  x := 0;
  varx[doInc(x)].a := 'Bla 1'; //x = 1
  varx[x].b := 'Bla 1 b';
  inc(x,1);
  varx[doInc(x)].a := 'Bla 2'; //x = 2

Macht es etwas einfacher.

LG :-)

[Andreas13]

Hallo Mathias,
es ist sehr fehleranfällig, was Du machst! Wenn Du z. B. zwei Zeilen vertauschst oder eine neue einfügst, geriet alles durcheinander. Wenn Du schon unbedingt so vorgehen willst, würde ich Thomas' Vorschlag etwas entschärfen:

Delphi-Quellcode:

function doInc(CONST _i: integer; Anz: integer = 1): integer;
begin
 _Inc(_i, Anz);
 Result := _i;
end;

Dann würden Deine Aufrufe wie folgt aussehen:

Delphi-Quellcode:

  x := 0;
  varx[doInc(x)].a := 'Bla 1'; //x = 1
  varx[x].b := 'Bla 1 b';
  // inc(x,1); überflüssig
  varx[doInc(x, 2)].a := 'Bla 2'; //x = 2

Gruß, Andreas

[NoGAD]

Hallo Andreas,

wieso darf eine konstante verändert werden? 🤔

LG.

[Andreas13]

Zitat:

Zitat von NoGAD (Beitrag 1502950)

.. wieso darf eine konstante verändert werden? 🤔

Nein, eine Konstante darf (schon lange) nicht (mehr) verändert werden. :oops: Eigentlich wollte ich damit nur andeuten, daß es kein VAR-Parameter sein soll. In Thomas ' Code war noch ein kleiner Tippfehler: "_Inc". Da die Unterstriche bei lokalen Variablen eh nicht nötig sind, lasse ich sie weg. Korrekt wäre es also z.B. so:

Delphi-Quellcode:

function doInc(i: integer; Anz: integer = 1): integer;
begin
 Inc(i, Anz);
 Result := i;
end;

Grüße, Andreas

[NoGAD]

Hallo nochmal, Andreas.

Ich glaube, es sollte doch eine Variable sein in der function, weil ansonsten der Wert immer gleich bleibt und nicht hochgezählt wird.

Aber genau das bezwecke ich ja bei der Zuweisung.

LG

[Harry Stahl]

Oder so:

Delphi-Quellcode:

  var x: TMyInt := 0;

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

Das könnte man mit einem Record-Helper machen:

Delphi-Quellcode:

Type
  TMyInt = Type Integer;

  TMyIntegerHelper = record helper for TMyInt 
  public
    function inc: TMyInt; inline;
  end;

Implementation

function TMyIntegerHelper.inc: TMyInt;
begin
  self := self+1;
  Result := self;
end;

Leider kann man den bestehenden Recordhelper für Integer nicht erweitern oder vererben, daher der Umweg über einen eigenen Typ

Trotzdem kann man bei Bedarf auf x den normalen Integerhelper nutzen mit (Integer(x).tostring) z.B.

[KodeZwerg]

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

[Harry Stahl]

Zitat:

Zitat von KodeZwerg (Beitrag 1502955)

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...

[NoGAD]

Zitat:

Zitat von Harry Stahl (Beitrag 1502954)

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:

Delphi-Quellcode:

  TMyIntegerHelper = record helper for TMyInt

Sehr Interessant!


Ganz herzlichen Dank.


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

Delphi-Quellcode:

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

LG :-)

[mytbo]

Wünsche einen schönen guten Abend!

Zitat:

Zitat von NoGAD (Beitrag 1502938)

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? :gruebel:

Bis bald...
Thomas

[KodeZwerg]

Zitat:

Zitat von Harry Stahl (Beitrag 1502956)

Zitat:

Zitat von KodeZwerg (Beitrag 1502955)

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:

Zitat von mytbo (Beitrag 1502958)

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:

Zitat von KodeZwerg (Beitrag 1502955)

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:

Zitat von NoGAD (Beitrag 1502961)

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:

Zitat von NoGAD (Beitrag 1502982)

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

Da muss ich doch gleich mal meckern:

Zitat:

Zitat von NoGAD (Beitrag 1502982)

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).

[NoGAD]

Zitat:

Zitat von dummzeuch (Beitrag 1502983)

Da muss ich doch gleich mal meckern

Dankeschön :-)

Zitat:

Zitat von dummzeuch (Beitrag 1502983)

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).

Genau. Das soll den aktuellen Index des Array zurückgeben.

Im Übrigen habe ich bemerkt, dass bei meinem Code immer eine Arraylänge zuviel dran ist. Wenn ich 10 erstelle, sind es 11. Warum ist das so?

LG

[Uwe Raabe]

Ich verstehe denn Zweck des ganzen Brimboriums nicht. Warum nicht einfach eine generische Liste:

Delphi-Quellcode:

type
  TMyTippOfDayRecord = record
    Tipp: String;
    Info: String;
    constructor Create(const ATipp, AInfo: string);
  end;

Type
  TMyTippOfDay = TArray<TMyTippOfDayRecord>;

constructor TMyTippOfDayRecord.Create(const ATipp, AInfo: string);
begin
  Tipp := ATipp;
  Info := AInfo;
end;

function CreateTippOfDay: TMyTippOfDay;
var
  List = TList<TMyTippOfDayRecord>;
begin
  List := TList<TMyTippOfDayRecord>.Create;
  try
    List.Add(TMyTippOfDayRecord.Create('Bla 1', 'Hallo 1');
    List.Add(TMyTippOfDayRecord.Create('Bla 2', 'Hallo 2');
    List.Add(TMyTippOfDayRecord.Create('Bla 3', 'Hallo 3');
    List.Add(TMyTippOfDayRecord.Create('Bla 4', 'Hallo 4');
    Result := List.ToArray;
  finally
    List.Free;
  end;
end;

Noch einfach geht es, wenn man statt des Arrays gleich ganz mit der Liste arbeitet.

[DeddyH]

Und ich habe gedacht, ich bin der Einzige, der sich das fragt. :-D

[NoGAD]

Hallo Uwe und Detlev,


ganz am Anfag meines Beitrags war die Frage eine gänzlich andere. Außerdem suchte ich nach einer Möglichkeit, ein Array ohne viele Umwege zu erstellen - und auch, ohne, dass ich mich um die Verwaltung dessen kümmern muss. Die Lösung von Dir, Uwe, ist dem, was ich nun gemacht habe wahrlich besser und auch strukturierter.

Ich bin leider kein gelernter Programmierer, mir fallen solche Dinge nicht leicht. Jedoch macht es Spaß Lösungen zu Problemen zu finden, die sich ergeben.

Danke an euch alle!

LG