Strings mit Parameter in einer Konsolanwendung

[Back2Code]

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.

:thumb:

[Coffeecoder]

Zitat:

Zitat von Robin2k (Beitrag 1149798)

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 :dp:

[Back2Code]

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:

Zitat von Robin2k (Beitrag 1149803)

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

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

Delphi-Quellcode:

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.

[Back2Code]

Funktioniert jetzt einigermaßen wie ichs wollte..ich wundere mich etwas, da die Binary jetzt über 1 MB groß ist :shock: 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 :)

[Back2Code]

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

[Sir Rufo]

Einen großen Teil macht dabei

Delphi-Quellcode:

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)