Performancefrage: Viele Änderungen an einem string

[yankee]

Hi @ll,

wenn ich einen string sehr langsam verändere/verlängere, zum Beispiel so:

Delphi-Quellcode:

var mystring: string;
begin
mystring :='';
while someCondition() do mystring :=mystring + 'A';
end;

Problem: Ich weiss nicht, wie lang der String werden wird. Ich kann aber sagen, dass der String höchstwahrscheinlich nicht länger als 30 Zeichen wird.
Wenn ich dann dem String eine feste Länge gebe:

Delphi-Quellcode:

var mystring: string[30];

Wie geht Delphi dann vor?
Nicht, dass Delphi immer schon bei
mystring :='';
die feste Länge wieder über den haufen wirft...

Oder wie mache ich das geschickt?

[Thorben_K]

Delphi schneidet das einfach ab, also wenn du hast

Delphi-Quellcode:

var s : String[8];

begin
  s := '1234567890';
  ShowMessage(s);
end;

Es wird nur '12345678' in der ShowMessage ausgegeben, es gibt auch keine Fehlermeldung

Und die Maximale lände des String bekommst du mit hilfe

Delphi-Quellcode:

  ShowMessage(IntToStr(SizeOf(s) -1));

SizeOf liefert dir die Byte zahl des Strings, Pro zeichen ein Byte und davor steht noch eine Zahl die die länge angibt, diese Zahl musst du abziehen.

Vieleicht kannst du diese zahl auch direkt auslesen, aber so geht es auf jedenfall auch

Thorben

[yankee]

mhh... das heisst ja, ich könnte bei jedem durchlauf der schleife mit length() prüfen, ob der String die maximale Länge ausgereizt hat. Wenn das der Fall ist, kopiere ich den string in einen anderen string mit dynamischer länge und fange wieder von vorne an den string aufzufüllen.

Oder ich nehme immer wieder setlength um den string zu verlängern, wenn die Länge ausgereizt ist. Das hiesse wahrscheinlich, dass ich strings dynamischer Länge nehmen um sie mit setlength verändern zu können.

EDIT: Moment: was macht denn setlength da eigentlich? Length() würde mir dann doch die gesetzte Länge des strings zurückgeben und nicht wieviele Zeichen der string wirklich hat...?

[Chewie]

Zitat:

Zitat von yankee

Oder ich nehme immer wieder setlength um den string zu verlängern, wenn die Länge ausgereizt ist. Das hiesse wahrscheinlich, dass ich strings dynamischer Länge nehmen um sie mit setlength verändern zu können.

Exakt. Du erzeugst eined dynamischen String und legst die Maximallänge fest. Wird der String nun verlängert, muss kein zusätzlicher Speicher alloziert werden, solange die tatsächliche Länge unter der Maximallänge liegt.

[yankee]

Zitat:

Zitat von Chewie

Exakt. Du erzeugst eined dynamischen String und legst die Maximallänge fest. Wird der String nun verlängert, muss kein zusätzlicher Speicher alloziert werden, solange die tatsächliche Länge unter der Maximallänge liegt.

Das heisst aber, dass, wenn ich die Länge des stringes sprenge der string weiter verlängert wird oder wird ab dann wieder abgeschnitten? Und wenn nein, wie stelle ich fest, dass ich die länge ausgereizt habe und wieder setlength aufrufen muss? Soll ich mitzählen, wieviele chars ich da reingeschoben habe?

[bitsetter]

Hallo,

Delphi-Quellcode:

var
  mystring: string;
begin
  setlength(mystring, 30);
  zeromemory(@mystring[1], length(mystring));//alles mit #0 füllen
  //length(mystring);//länge von mystring= 30

  mystring[1]:= 'A';//erste Zeichen= 'A'
  //length(mystring);//länge von mystring= 30

  setlength(mystring, 30);
  mystring:= mystring+ 'A';
  length(mystring);//länge von mystring= 31

  mystring:= '';
  //length(mystring);//länge von mystring= 0

  mystring:= '';
  mystring :=mystring + 'A';
  //length(mystring);//länge von mystring= 1

  mystring := 'A';
  mystring :=mystring + 'A';
  //length(mystring);//länge von mystring= 2

Delphi-Quellcode:

var
  mystring: string[3];//alles was länger 3 ist wird ignoriert
begin
  //length(mystring);//länge von mystring= 0

  mystring:= '';
  //length(mystring);//länge von mystring= 0

  mystring:= '';
  mystring :=mystring + 'A';
  //length(mystring);//länge von mystring= 1

  mystring:= 'AAAAAAAAAAAAAAAAAAAAA';
  //länge von mystring trotzdem= 3

[sirius]

Wie sieht es damit aus:

Delphi-Quellcode:

const max=30;
var s:string;
    i:integer;
begin
  setlength(s,max);
  i:=0;
  while something do begin
   inc(i);
   s[i]:='A';
  end;
  setlength(s,i);
end;

[yankee]

mhh... ist doch alles nicht ganz einfach....
Der Buffer soll sich ja auch noch vergössern, sobald er voll ist. Was halted ihr hiervon:

Delphi-Quellcode:

var buffer: string;
    bufcur,bufend: PChar;
begin
  setlength(buffer, 31);
  bufcur :=@buffer[0];
  bufend :=@buffer[30];
  while someCondition do
  begin
    if bufcur =bufend then
    begin
      setlength(buffer, length(buffer)+10);
      bufend :=@buffer[length(buffer)-1];
      bufcur :=@buffer[length(buffer)-11];
    end;
    bufcur^ :='A';
    inc(bufcur);
  end;
end;

:?:

[sirius]

Auch nicht schlecht. Damit sparst du dir das "IsUniqueString", da du PChar als Zuweisung nimmst. Hat ich auch schon dran gedacht.