Hallo,

ich habe ein Problem mit einem Programm (was auch sonst ? *g*).
Also das Programm soll eine Liste auslesen und auswerten in der Namen stehen und dann ausgeben wie oft ein Name vorkommt.
Bei der Liste handelt es sich um die "WhoReadMyStatusMessage"-Liste von Miranda (falls die jemand kennt), daher müssen die Namen vorher noch aus der Zeile ausgeschnitten werden.
Die Zeile sieht ungefähr so aus

markieren

Code:

[20/11/2003 - 19:49] [12345678] Manfred Mustermann read your Away message

Ok, soweit so gut. Der Name wird aus der Zeile ausgeschnitten und in ein separates Memo-Fenster ausgegeben. Nun sollen alle Namen in ein Array eingetragen werden. Das Klappt auch soweit.
Jetzt ist das Problem, dass die Namen ja nich doppelt in dem Array drinstehen sollen, deswegen geht eine 2. Schleifen den Array durch und vergleicht alle bisher eingetragenen Namen mit dem, der nun eingetragen werden soll. Dabei kommt es aber zu Konfusen einträgen die absolut nicht stimmen und ich kann mir nicht erklären wieso.

Vielleicht findet jemand den Fehler, danke ;)

Deklaration

markieren

Delphi-Quellcode:

type TNames = record
     Name : String[50];
     Hit : integer;
end;

var
  ....
  Auswertung : Array[0..300] of TNames;

Quelltext

zusammenfalten · markieren

Delphi-Quellcode:

var k,i,l,m,ext,nPos : integer;
     S,Part,Substr: String;

begin
 Memo2.Clear;

// ####################
// ### Definitionen ###
// ####################

 ext := Memo1.Lines.Count-1;
 Label3.Caption := IntToStr(ext);

// ###################
// ## Array säubern ##
// ###################

 FOR i := 0 TO ext DO BEGIN
  WITH Auswertung[i] DO BEGIN
   Name := '';
   Hit := 0;
  END;
 END;

// ##################
// # Cut First Part #
// ##################

   FOR i := 0 TO ext DO BEGIN
      S := Memo1.Lines[i];

     FOR k := 1 TO 2 DO BEGIN
      Substr := ']';
      nPos:=Pos(Substr, S);
      Part := Copy(Part,nPos+2,Length(S));
      Delete(S,1,nPos+1);
     END;

// ###################
// # Cut Second Part #
// ###################

    Substr := 'read';
    nPos:=Pos(Substr, S);
    Part := Copy(S,1,nPos-2);
// Memo2.Lines.Add(Part);

// ###################
// # Array eintragen # <<< HIER IST DAS PROBLEM, IN DEM UNTEREN ABSCHNITT.
// ###################


    FOR l := 0 TO i-1 DO BEGIN
    IF Auswertung[l].Name = Part THEN
      Auswertung[l].Hit := Auswertung[l].Hit+1
     ELSE
      Auswertung[i].Name := Part;
      Auswertung[i].Hit := Auswertung[i].Hit+1
    END;


 END;

END;

//EDIT Die Liste wird in Memo1 geladen, deswegen auch die Zuweisung S := memo1.lines[i]

hi
fängt ein array nicht mit 1 an und nicht mit 0 ????

also Array[1..300]


und die schleife
for i := 1 und nicht i := 0

Zitat von HomerGER:

hi
fängt ein array nicht mit 1 an und nicht mit 0 ????

Welches "nicht" möchtest du streichen?

Ein (statisches) Array fängt in Pascal mit dem Index an, den der Programmierer wünscht.

markieren

Delphi-Quellcode:

var myArray: array[2000..2010] of Integer;

myArray[2000] := 10;

Zitat:

FOR l := 0 TO i-1 DO BEGIN
IF Auswertung[l].Name = Part THEN
Auswertung[l].Hit := Auswertung[l].Hit+1
ELSE
Auswertung[i].Name := Part;
Auswertung[i].Hit := Auswertung[i].Hit+1
END;

Fehlt da nicht ein begin und ein end ? Der Algorithmus macht auch nicht das, was du oben geschrieben hast. Er überschreibt alle Elemente, die nicht schon Part ensprechen.

so, hab den ersten programmteil inzwischen optimiert.
aber mit dem eintragen in den array gehts irgendwie nicht voran. hab mich da irgendwie an was festgebissen was nicht geht.
vielleicht könnte mir jemand etwas code schreiben der mir die sache erleichtert.

vielen dank
mfg
guenni

zusammenfalten · markieren

Delphi-Quellcode:

type TNames = record
       Name : String[50];
       Hit : integer;
     end;
     PNames : ^TNames; //Typisierter Zeiger auf einen TNames-Record
var
  HitListe : TList;
...
procedure CountDaHits;
var
  i,
  j,
  ext : Integer;
  AktZeile : String;
  SchonDrinn : Boolean;
begin
  ext := Memo1.Lines.Count-1;
  Label3.Caption := IntToStr(ext);
  if not Assigned(HitListe) // prüfen ob Hitliste schon instanziiert wurde,
    then HitListe := TList.Create; // wenn nicht, dann erzeugen wir sie

  for i := 0 to ext do
  begin
    AktZeile := copy(Memo1.Lines[i],Pos(']',Memo1.Lines[i])+2,MaxInt);
    AktZeile := copy(AktZeile,1,Pos('read',AktZeile)-1);
    SchonDrinn := False;
    for j := 0 to HitListe.Count-1 do begin // wird bei der 1. Memo1-Zeile nicht ausgeführt
      if PName(HitListe[i]).Name = AktZeile
        then begin
          SchonDrinn := True;
          PName(HitListe[i]).Hit := PName(HitListe[i]).Hit+1;
        end;
    end; // for j
    if not SchonDrinn then begin
      HitListe.Add(new(PNames)); // von innen nach aussen:
                                  // 1. erzeugt neuen TNames-Record (reserviert Speicher),
                                  // 2. erzeugt Neuen PNames-Zeiger ( dto. )
                                  // 3. weist dem PNames-Zeiger die Adresse des TNames-Record zu
                                  // 4. Hängt den PNames-Zeiger als untypisierten Pointer an das
                                  // Ende der HitListe an
      PName(HitListe[i]).Name := AktZeile;
      Hit := 1;
    end; // if not SchonDrinn
  end; // for i
end;

// Um kein Speicherleck zu bekommen, müssen wir die Hitliste vor
// ProgrammEnde noch leeren und freigeben:
procedure VorDemFeierabend;
var i : Integer;
begin
  if Assigned(HitListe) // sollte die HitListe nicht Instanziiert worden sein, gäbe es
    then begin // eine Zugriffsverletzung, deswegen immer schön prüfen, ob'se da ist
      for HitListe.Count-1 downto 0 do begin
        Dispose(PNames(HitListe[i])); // gibt den Record, auf den der i. PNames zeigt frei
        HitListe.Delete(i); // Löscht den i.Zeiger und kürzt die Liste (deshalb
                                      // zähle ich auch von Hinten nach vorne)
      end;
    end;
    FreeAndNil(HitListe); // Zuguterletzt geben wir die HitListe frei - et voila
end;

Gruß

nimme am besten ne TStringlist - sorted := True - dublicates := dupignore und dann sollte auch nix doppelt in der Stringlist geadded werden können. (casesensitive)