Strings mit Parameter in einer Konsolanwendung

[Robin2k]

Ich lerne seit ein paar Wochen Delphi und bin gerade dabei eine kleine Konsolen Anwendung zu schreiben. Zur Zeit sieht mein Code so aus :

Delphi-Quellcode:

program Project2;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils;

var VName,NName:String;
     PPasswort:String;


begin
WriteLn('################################Login###########################################');
WriteLn; //Eine Zeile auslassen
PPasswort:='';
begin
WriteLn('root@localhost ~ Insert password');
ReadLn(PPasswort);
CompareStr(PPasswort, '1337');
if(CompareStr(PPasswort, '1337') = 0) then
WriteLn('*Access granted*')
else begin
WriteLn('*Access denied*');
Sleep(2000);
exit;
end;
end;
WriteLn; //Eine Zeile auslassen
WriteLn('Wie lautet dein Vorname?');
ReadLn(VName);
WriteLn('Wie lautet dein Nachname?');
ReadLn(NName);
WriteLn;
WriteLn('Willkommen '+VName+' '+NName+'.');
ReadLn;
end.

Ich habe jetzt vor nach dem "Willkommen" eine String Wiederholungfunktion einzubauen mit Parameter.

Als Beispiel :

repeatstr Teststring 99 = Würde jetzt "Teststring" 99 mal hintereinander in der Console schreiben...

Meine Frage ist jetzt wie ich das am besten umsetzen könnte.

[Coffeecoder]

Zitat von Robin2k:

Ich habe jetzt vor nach dem "Willkommen" eine String Wiederholungfunktion einzubauen mit Parameter.

Hi, du sagst ja schon selbst: Die schreibt eine Funktion resp eine Prozedur dafür:

Delphi-Quellcode:

procedure wiederholen(wiederholungen : integer; text : String);
var i : integer;
begin
  for i := 1 to wiederholungen do
  begin
    writeln(text); 
  end; 
end;

P.S. : Willkommen in der

[Robin2k]

So atm sieht mein Code jetzt so aus :

Delphi-Quellcode:

program Project1;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils;

var text:String;
    wiederholungen:integer;
    var i : integer;

begin
WriteLn('Usage: repeatstr [string] [repeats]');
ReadLn(text);
ReadLn(wiederholungen);
begin
  for i := 0 to wiederholungen do
  begin
    writeln(text);
  end;
  end;
end.

Wie kann ich text & wiederholungen in einer Zeile auslesen?

[himitsu]

Zitat von Robin2k:

Wie kann ich text & wiederholungen in einer Zeile auslesen?

Du hast dir doch bestimmt schonmal die OH und einige Tutorials angesehn?

Dann ist dir bestimmt aufgefallen, daß WriteLn mehrere Parameter kann.

Delphi-Quellcode:

WriteLn(IntToStr(Wiederholungen) + Text);

WriteLn(Wiederholungen, Text);

Write(IntToStr(Wiederholunge));
Write(Text);
WriteLn;

Write(Wiederholunge);
Write(Text);
WriteLn;

Write(IntToStr(Wiederholunge));
WriteLn(Text);

Write(Wiederholunge);
WriteLn(Text);

uvm.

Was ich dir aber noch dringen anraten würde:
Codformatierung nutzen ... schon ist der code übersichtlicher/verständlicher. (der Code aus Post #1 ist irgendwie grausam)

Delphi-Quellcode:

CompareStr(PPasswort, '1337');
if(CompareStr(PPasswort, '1337') = 0) then

Was macht das nutzlose CompareStr dort? Also das vovon der Rückgabewert nicht ausgewertet wird.

Delphi-Quellcode:

if CompareStr(PPasswort, '1337') = 0 then

if not SameStr(PPasswort, '1337') then

if PPasswort <> '1337' then

Mal so aus privatem Interesse: Was haben eigentlich die Prefixe V, N und P, bei den Variablen, für eine Bedeutung?

[edit]
OK, V und N hab ich grade bemerkt, aber warum heißen die Variablen dann nicht gleich Vorname und Nachname?

[Sir Rufo]

Also der Code ist ja grauslich formatiert

Warum die Funktion nicht so benennen wie der TE das schon vorgeschlagen hat?
Und einen String Parameter nach Möglichkeit immer als const definieren.

Delphi-Quellcode:

program Project2;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils;

var 
  VName, NName : String;
  Passwort     : String; // PPasswort würde eigentlich auf einen Pointer schließen lassen

function RepeatStr( const Str : string; Count : integer ) : string;
var
  idx : integer;
begin
  Result := '';
  for idx := 1 to Count do
    Result := Result + Str;
end;

begin
  WriteLn( '################################Login###########################################' );
  WriteLn; //Eine Zeile auslassen
  Passwort := '';

  begin // <= ist überflüssig

    WriteLn( 'root@localhost ~ Insert password' );
    ReadLn( Passwort );

    CompareStr( Passwort, '1337' ); // <= ist überflüssig

    if 
      ( CompareStr( Passwort, '1337' ) = 0 ) 
    then
      WriteLn( '*Access granted*' )
    else 
      begin
        WriteLn( '*Access denied*' );
        Sleep( 2000 );
        exit;
      end;

  end; // <= ist so überflüssig, wie das begin weiter oben

  WriteLn; //Eine Zeile auslassen
  WriteLn( 'Wie lautet dein Vorname?' );
  ReadLn( VName );
  WriteLn( 'Wie lautet dein Nachname?' );
  ReadLn( NName );
  WriteLn;
  WriteLn( 'Willkommen ' + VName + ' ' + NName + '.' );

  // Aufruf der Funktion mit gleichzeitiger Ausgabe
  WriteLn( RepeatStr( 'Teststring', 99 ) );

  ReadLn;
end.

[Robin2k]

Funktioniert jetzt einigermaßen wie ichs wollte..ich wundere mich etwas, da die Binary jetzt über 1 MB groß ist Gibts da ein paar Tricks wie ich die kleiner bekomme?

[Sir Rufo]

Wenn du dein Profil dahingehend anpassen würdest, mit welcher Delphi-Version du arbeitest, dann wäre das sehr hilfreich

Vermutlich erzeugst du eine Debug-Version ... mit eben all den Debug-Informationen, und dass lässt natürlich die erzeugte exe anwachsen

[Robin2k]

Danke für den Tipp. Jetzt sind's nur noch 130 kb.

[Sir Rufo]

Einen großen Teil macht dabei SysUtils aus (ca. 100KB).

Dieses kann man vermeiden, wenn man gezielt auf Teile von SysUtils verzichtet oder nur die benötigten Teile in eine eigene Unit auslagert.

Delphi-Quellcode:

program ConsoleTest;

{$APPTYPE CONSOLE}
{$R *.res}

uses
  // System.SysUtils;

  // statt der sehr großen SysUtils nehmen wir unsere eigene  

  uSmallSysUtils in 'uSmallSysUtils.pas';

var
  VName, NName : String;
  Passwort :     String; // PPasswort würde eigentlich auf einen Pointer schließen lassen

function RepeatStr( const Str : string; Count : integer ) : string;
var
  idx : integer;
begin
  Result   := '';
  for idx  := 1 to Count do
    Result := Result + Str;
end;

begin
  WriteLn( '################################Login###########################################' );
  WriteLn; // Eine Zeile auslassen
  Passwort := '';

  WriteLn( 'root@localhost ~ Insert password' );
  ReadLn( Passwort );

  // statt SysUtils.CompareStr vergleichen wir so

  if ( Passwort <> '1337' )
  then
    WriteLn( '*Access granted*' )
  else
    begin
      WriteLn( '*Access denied*' );
      Sleep( 2000 );
      exit;
    end;

  WriteLn; // Eine Zeile auslassen
  WriteLn( 'Wie lautet dein Vorname?' );
  ReadLn( VName );
  WriteLn( 'Wie lautet dein Nachname?' );
  ReadLn( NName );
  WriteLn;
  WriteLn( 'Willkommen ' + VName + ' ' + NName + '.' );

  // Aufruf der Funktion mit gleichzeitiger Ausgabe
  WriteLn( RepeatStr( 'Teststring', 99 ) );

  ReadLn;

end.

und die uSmallSysUtils.pas sieht dann so aus (ist halt nur die Sleep-Funktion)

Delphi-Quellcode:

unit uSmallSysUtils;

interface

procedure Sleep(milliseconds: Cardinal);{$IFDEF MSWINDOWS} stdcall; {$ENDIF}
{$IFDEF MSWINDOWS}
(*$EXTERNALSYM Sleep*)
{$ENDIF}

implementation

{$IFDEF MSWINDOWS}
procedure Sleep; external 'kernel32.dll' name 'Sleep'; stdcall;
{$ENDIF MSWINDOWS}
{$IFDEF POSIX}

procedure Sleep( milliseconds : Cardinal );
begin
  usleep( milliseconds * 1000 ); // usleep is in microseconds
end;
{$ENDIF POSIX}

end.

Jetzt ist die Release-Version nur noch 32KB groß ... aber ...

grundsätzlich sollte man gerade als Anfänger davon erstmal absehen

[himitsu]

Wobei die paar 118 98 KB heutzutage ja kaum noch auffallen.
(da kann man schonmal zwischen Aufwand und Nutzen abwägen)