Programmiersprachen vergleichen durch einfache Programme

Hallöchen,

ich dachte mir, man könnte doch mal die verschiedensten Sprachen zusammenrufen und sie alle das selbe Programm erstellen lassen. Soll heißen, wir wählen ein Thema, etwas simples was man schnell machen kann, und jeder schreibt das ganze mal in seiner am liebsten benutzten Sprache. Das soll dem Zweck dienen, am Ende einen Vergleich aufstellen zu können, welche Sprache dafür am besten geeignet war, welcher Syntax am besten aussieht oder am besten angeordnet ist und sowas eben. Oder wie groß die EXE Datei zum Schluss dann ist.

Vorschlag meinerseits:

Wie wäre es zum Auftackt mit einer einfachen Übung - ein springender Ball im Bildschirm? (Nicht als Fensteranwendung sonder als Screen)
Das ist extra so einfach und ohne viel Spielraum gehalten (für den Anfang), damit man später besser vergleichen kann, wie viele Zeilen welche Programmiersprache benötigt hat, wie groß die EXE und ist und sowas eben.

Von daher, es sollten dann folgendes hier reingestellt werden:

Zitat:

---

- Die compilierte .exe Datei

- den dazugehörigen Sourcecode (Falls es sich dabei um eine Datei handelt, die nur mit bestimmten programmen geöffnet werden kann, dann bitte per Textdokument abspeichern, dass man den Syntax betrachten kann)

- Angaben zur benutzten Sprache, welche man verwendet hat

- Effektive Zeilen (ohne Kommentare oder Absätze)

- Gesamte Anzahl Zeilen (Alle Zeilen incl. Absätzen und Kommentaren)

---

So, das wäre mein Vorschlag. Hätte denn jemand Interesse, mitzumachen?
Oder gibt es noch Vorschläge zum Ablauf hier, oder neue Themen?

1.) Das am weitesten verbreitet Beispielprogramm ist Hallo Welt. Es gibt bereits eine Seite, auf der diverse Sprachen anhand von HW miteinander verglichen werden (ich empfehle Brainfuck).

2.) Die Größe der kompilierten Datei ist abhängig vom Compiler (und seinen Einstellungen), dem System und der Implementierung. Wenig aussagekräftig.

3.) Das Verteilen von fertig kompilierten Programmen sollte nach Möglichkeit vermieden werden. Da kann man sich leicht was wegholen.

hm klingt soweit gut, jedoch waere ich nicht unbedingt fuer eine vollbildanwendung, da sowas mit manchen sprachen aeusserst unguenstig ist ... imho z.B bei Java ..

zudem sollte man noch sagen, ob und wenn ja, welche API genutzt werden soll ...

zudem sind graphikanwendingen sowieso ungeeignet, da fuer graphik vornehmlich API genutzt werden muss und API ist sowieso in jeder sprache groesstenteils gleich ...

ich waere ehr fuer ein Programm, das sich auf die grundlagen beschraenkt, z.B. einen Text ausgeben, zwei Zahlen von der Tastatur einlesen und dann das Produkt ausgeben

sozusagen ein etwas erweitertes Hallo Welt Programm

Gruss Ineluki

Jup, Hallo Welt kenn ich auch^^ Das war das erste was ich gemacht habe. Aber, ich dachte ja sowieso an mehrere Beispiele, nicht nur eines. Deshalb schlag ich vor, den Ball im Screen springen lassen, und als nächste Möglichkeit dann das Hallo Welt Programmchen...

Zitat:

---

3.) Das Verteilen von fertig kompilierten Programmen sollte nach Möglichkeit vermieden werden. Da kann man sich leicht was wegholen.

---

Wie genau ist das jetzt gemeint? Etwas abschauen oder so? Gut, aber man muss ja schlussendlich auch das Resultat begutachten, ob der Code denn überhaupt funktioniert. Somit muss zwangsweise eine exe Dabei sein. Außerdem, aus einem fertigen Programm kann man noch immer nicht den Syntax erkennen, wie etwas geschrieben wurde, und da sich die Sprachen ja auch schonmal unterscheiden, wird es noch schwerer dort etwas abzuschauen.

Programmgröße, nun ja, es macht schon einen Unterschied ob es nun 5 KB oder 200 KB sind oder? Und dann wählt man eben einen möglichst passenden compiler der es mit der besten Performance und Größe compiliert. Na ja, und man könnte noch die Größe des Sourcecodes nehmen, da ist ja ASCII Text, und könnte in einer einfachen TXT Datei verglichen werden.

Möchte denn jemand mitmachen?


EDIT: Ok, Luki, kein Problem. Eine Fensteranwendung könnt man auch machen. Wie wäre es dann (nach deiner Idee) mit einem Taschenrechner der die 4 Grundrechenarten beherscht? ( + | - | * | /)

Bei der API würde ich die WinAPI mit einschließen. Sonst könnte man noch Direct X oder open GL nehmen, aber die benötigt man ja eher bei Vollbildanwendungen... Ich denke mal, es steht erst einmal frei, welche API oder?

Zitat:

---

Original geschrieben von Sunny
Wie genau ist das jetzt gemeint? Etwas abschauen oder so?

---

Ich bezog mich eher darauf, daß man sich einen Virus einfangen könnte. Es braucht dazu nur zwei Rechner mit nicht ganz aktueller Antivirensoftware...
Es bleibt das Problem, daß fertige Binaries (abgesehen von der Frage, ob das Programm überhaupt funktioniert) kaum aussagekräftig sind. Die Größe einer Binary hängt von unzähligen Faktoren ab (zu der oben genannten Liste will ich an dieser Stelle noch das Betriebssystem hinzufügen).

APIs sollte man nach Möglichkeit vermeiden... Es gibt einfach zu viele Möglichkeiten. Ein Programm, das versucht, direkt mit X zu interfacen wird unglaublich kompliziert aussehen, obwohl der meiste Code nur für X draufgeht.

Den einfachen, konsolenbasierten Rechner halte ich für eine gute Idee. Vielleicht könnte man ihn noch um ein paar Funktionen erweitern (Potenzen und Quadratwurzeln gehören zum Standardrepertoire der meisten (höheren) Sprachen).

hm, na ja, wenn ich aber das Fenster genau mittig des Desktops platzieren will, kann ich doch über die WinAPI die Auflösung abfragen und das dadurch machen... Es sieht vielleicht komplexer aus, aber das ist es ja dann auch^^
Also die WinAPI halte ich in machen fällen schonmal für nützlich, bei einem so simplen Programm ansich noch nicht so sehr, aber auch Kleinigkeiten kann man dort ja nutzen. (Fenstertext oder Icon ändern, wobei das ja nur kleine Spielerei ist)... Ach ja, ich meinte mit Rechner eigentlich nich den Konsolenbasierenden, sonder eine Fensteranwendung... Für was wären denn die Anderen?

Hm, aber irgendwie muss man die Programme ja dann doch testen, also mit EXE... Dann schlage ich vor, die exen hochzuladen, und ich teste sie auf Viren durch und stelle mich als Tester bereit. Ich sag euch aber schonmal gleich, wer mir hier die Platte löscht, dem bin ich ehrlich böse!^^

So, ja dann machen wir doch zu Beginn mal einen Taschenrechner. Mit den 4 Rechenarten (wahlweise + quadrat und Quadratwurzel.)

So hier das Erste Beispiel in der Consolenvariante von Delphi .. sozusagen Turbo Pascal aequivalent

Eine GUI Variante wird noch nachgeliefert ... das sieht dann GANZ anders aus

Code:

---

program Rechner;

{$APPTYPE CONSOLE}

uses
  SysUtils;

var z1,z2:real;
    op:string;

begin
 Writeln('Hallo Welt.');
 Write('Bitte erste Zahl eingeben: '); readln(z1);
 Write('Bitte zweite Zahl eingeben: '); readln(z2);
 repeat
  Write('Bitte Operation waehlen + - * / ');readln(op);
 until (op='+') or (op='-') or (op='*') or (op='/');
 if op='+' then Writeln(z1,' + ',z2,' = ',z1+z2);
 if op='-' then Writeln(z1,' - ',z2,' = ',z1-z2);
 if op='*' then Writeln(z1,' * ',z2,' = ',z1*z2);
 if op='/' then Writeln(z1,' / ',z2,' = ',z1/z2);
 Writeln('Danke fuer die Benutzung. Zum Beenden Enter druecken.');
 readln;
end.

---

und hier die Exe dazu -> ftp://ftp.uni-freiburg.de/incoming/delphi/rechner.exe 42Kb

Natuerlich hab ich jetzt auf Fehlerbehandlung und Eingabeueberpruefung verzichtet .. sollte das gewuenscht sein, liefere ich das natuerlich gerne nach ^^

So ich liefer nun die GUI version nach ...

Code:

---

unit RechnerGUI;

interface

uses
 SysUtils, Forms, Classes, Controls, StdCtrls;

type
  TForm1 = class(TForm)
    EdZ1: TEdit;
    EdZ2: TEdit;
    EdErg: TEdit;
    Btnplus: TButton;
    BtnMal: TButton;
    BtnMinus: TButton;
    BtnDurch: TButton;
    procedure BtnClick(Sender: TObject);
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.BtnClick(Sender: TObject);
var z1,z2,erg:real;
    error:integer;
    noerror: Boolean;
begin
 if Sender is TButton then
  begin
  val(EdZ1.Text,z1,error); // Text in Zahl umwandeln
  noerror:=(error=0);      // Trat Fehler auf ?
  if (error<>0) then application.MessageBox('Zahl1 ist keine Zahl','Fehler');

  val(EdZ2.Text,z2,error);
  noerror:=noerror and (error=0); // War Fehler oder ist Fehler
  if (error<>0) then application.MessageBox('Zahl2 ist keine Zahl','Fehler');

  if noerror then begin
                    if TButton(Sender).Caption='+' then erg:=z1+z2;
                    if TButton(Sender).Caption='-' then erg:=z1-z2;
                    if TButton(Sender).Caption='*' then erg:=z1*z2;
                    if TButton(Sender).Caption='/' then erg:=z1/z2;
                    EdErg.Text:=format('%1.5f',[erg]);
                  end;
  end;
end;

end.

---

Natuerlich muss man nicht den ganzen code schreiben .. das meisste uebernimmt die Visuelle Umgebung ^^ ... und hier ist natuerlich eine Ueberpruefung dabei, ob das Eingegebene auch wirklich Zahlen sind.

und zum austesten auch hier die Exe -> ftp://ftp.uni-freiburg.de/incoming/d...rechnergui.exe 365 Kb -> Auch wegen den beinhalteten Cursor und Icongraphiken ... ist ja GUI

So, also Lukis exen sind Virenfrei^^

Aber nun meine:

Den Sourcecode gibts hier: (*.txt)
http://derfeind2k.de/daten/rechner.txt

Die Exe dazu gibts hier:
http://derfeind2k.de/daten/rechner.exe

-----
[edit] Neue Version hochgeladen. Mit dem kleinen Kasten unter der Anzeige kann man den Rechner wieder auf 0 setzen.
[/edit]
-----

Code:

---

Sprache:  Purebasic

*Effektive Zeilen:  155

**Gesamte Zeilenanzahl:  193

Größe des Source in KB:  4,39 KB

Größe der Exe in KB:  16,00 KB (extra incl. selfmade-Icon)

API:  WinAPI
---------
* Zeilen ohne Kommentare und Absätzen
** Alle Zeilen incl. Absätzen und Kommentaren

---

Ach ja, ich hab Quadrat und Wurzel vorerst nicht mit eingebaut, weil Luki das ja auch nicht getan hat.^^
Und Konsolenprogrammierung hab ich noch nie gemacht, daher nur eine Fensteranwendung.

So, ich hoffe es beteiligen sich noch ein paar Leutchen hier. Der Rechner kann auch noch einfacher aufgebaut sein, hauptsache die 4 Rechenarten sind dabei.
Erlaubt ist jede Sprache...

Ach, und bitte den Sourcecode nicht so wie Luki posten, dass macht alles so unübersichtlich. Besser wäre es, per *.txt Datei hochzuladen.

So, ich habe das Ding mal mit C++/FLTK umgesetzt.

Weil es alles einfach einzubauen war, beherrscht das Teil die Fuktionen +, -, *, /, Potenzierung, Quadratwurzel und Modulo. Es hat sogar Tooltips.
Eingabeüberprüfung und Fehlerbehandlung sind schon eingebaut (entweder direkt bei C++ oder bei FLTK).

Das Programm basiert auf OpenGL und läßt sich auf jedem System kompilieren, auf dem OpenGL verfügbar ist.

Ich habe den Code in der FLTK-IDE (fluid version 1.0104) gemacht und nicht nachträglich verändert, deshalb ist er etwas unübersichtlich.

Der Sourcecode:
www.rpgmaker.info/temp/code/calc.cxx (Programm; 3,98 KiB)
www.rpgmaker.info/temp/code/calc.h (Header, 543 B)

Das Programm:
www.rpgmaker.info/temp/code/calc.exe (262 KiB)

Code:

---

                Sprache: ISO-konformes C++

      Effektive Zeilen: 108 (.cxx) + 18 (.h) = 126
  Gesamte Zeilenanzahl: 135 (.cxx) + 21 (.h) = 156

Größe des Source in KiB: 4,51 KiB
Größe der Binary in KiB: 262  KiB
        Art der Binary: Win32 Executable

                    API: OpenGL via FLTK

              Benötigt: FLTK, C++-Standardheader

              Compiler: gcc version 3.3.1 (cygming special)
        Kompiliert als: gcc -I/code/fltk-1.1.4/bin/include -mwindows -DWIN32 -mno-cygwin
                        -o calc calc.cxx /code/fltk-1.1.4/bin/lib/libfltk.a
                        -lole32 -luuid -lcomctl32  -lwsock32 -lsupc++ -O4

---

Anmerkung:
"Benötigt" beschreibt, was man alles installiert haben muß, um das Programm kompilieren zu können (oder ausführen, bei Interpretersprachen).
"Kompiliert als" gibt an, wie der Compiler aufgerufen wurde (wenn diese Angabe möglich ist).
"Art der Binary" ist hier nebensächlich und nur aus Gründen der unnötigen Vollständigkeit angegeben.
Alle "KB"-Angaben wurden durch das korrektere "KiB" ersetzt.

hm ... also wenn ich mir den codeunfang etc so ansehe ... da wuerd ich sagen, mit Delphi hat sich das am besten gemacht ^^

Was sagt ihr dazu ?

Zitat:

---

Original geschrieben von Ineluki
hm ... also wenn ich mir den codeunfang etc so ansehe ... da wuerd ich sagen, mit Delphi hat sich das am besten gemacht ^^

Was sagt ihr dazu ?

---

Kommt drauf an.
Mit einer anderen API, bzw. einem anderen Toolkit oder als Konsolenapp wäre die C++-Version vielleicht Delphi gefährlich geworden; allerdings hatte ich da mit der Eingabe ein paar Probleme. Vielleicht mache ich noch eine Konsolenversion, mal sehen.

bei einem so einfachen problem kannst du den quellcode auch fast 1:1 uebernehmen und mit suchen und ersetzen die syntaxunterschiede ausgleichen und es wird laufen ....

die wichtigen unterschiede der sprachen zeigen sich meist erst, bei etwas komplexeren sachen

Gut, jetzt hat jeder mal einen Einblick in die Welt der anderen Sprache bekommen^^ Womit könnte man weiter machen? Das "hallo Welt" ist wohl etwas zuuuu einfach, als dass dort große Unterschiede wären. Jemand einen Vorschlag? Sonst könnte man nochmal auf den Springenden Punk im Screen zurückgreifen.

Hier nun die Konsolenversion mit C++.
Operatoren sind + - * /, die Eingaben werden überprüft.

Das Programm läßt sich auf jedem System kompilieren, auf dem ein ISO-konformer C++-Compiler verfügbar ist.

Ich habe noch eine alternative Version geschrieben, die das mit dem Operator recht elegant mit einem switch erledigt.

Der Sourcecode:
www.rpgmaker.info/temp/code/ccalc.cxx (871 Byte)
www.rpgmaker.info/temp/code/ccalc.cxx (alternative Version; 817 Byte)

Das Programm:
www.rpgmaker.info/temp/code/ccalc.exe (415 KiB)

Code:

---

                Sprache: ISO-konformes C++

      Effektive Zeilen: 37 (alternativ: 48)
  Gesamte Zeilenanzahl: 44 (alternativ: 55)

Größe des Source in KiB: 871 Byte (alternativ: 817 Byte)
Größe der Binary in KiB: 415  KiB
        Art der Binary: Win32 Executable

                    API: keine

              Benötigt: C++-Standardheader

              Compiler: gcc version 3.3.1 (cygming special)
        Kompiliert als: gcc -mno-cygwin -o ccalc ccalc.cxx -O4

---

BTW, die Optimierung (-O4) hätte ich mir auch sparen können, hat eh nichts gebracht.

@Jeez ... also soo gefaellt mir dein Code schon viel besser ^^ .. aber haettest dui nicht while statt for(;;) verwenden koennen ? ^^

so und aus spass an der freude hab ich auch noch gleich das ganze mit dem springenden Ball im Fenster gemacht ... natuerlich alles ohne schnoerkel oder so ^^

ftp://ftp.uni-freiburg.de/incoming/delphi/ball.exe

Code:

---

unit Ball;

interface

uses
  SysUtils, Forms, Classes, Controls, StdCtrls, Graphics;

type
  TForm1 = class(TForm)
    Timer1: TTimer;
    procedure Timer1Timer(Sender: TObject);
    procedure FormCreate(Sender: TObject);
  private
    { Private-Deklarationen }
    x,y,dx,dy:integer;
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.Timer1Timer(Sender: TObject);
var nx,ny:integer;
begin
nx:=x+dx; ny:=y+dy;
if nx<=50 then begin nx:=50; dx:=-dx; end;
if nx>=form1.ClientWidth-50 then begin nx:=form1.ClientWidth-50; dx:=-dx; end;
if ny<=50 then begin ny:=50; dy:=-dy; end;
if ny>=form1.ClientHeight -50 then begin ny:=form1.ClientHeight-50; dy:=-dy; end;
form1.Canvas.Pen.Color:=form1.Color;
form1.Canvas.Ellipse(x-50,y-50,x+50,y+50);
x:=nx; y:=ny;
form1.Canvas.Pen.Color:=clblack;
form1.Canvas.Ellipse(x-50,y-50,x+50,y+50);
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
randomize;
x:=51; y:=51;
repeat
dx:=(1-random(3))*random(3);
dy:=(1-random(3))*random(3);
until (dx<>0) and (dy<>0);
end;

end.

---

Zitat:

---

Original geschrieben von Ineluki
@Jeez ... also soo gefaellt mir dein Code schon viel besser ^^ .. aber haettest dui nicht while statt for(;;) verwenden koennen

---

Ein unkonditionales while tut genau das Gleiche wie ein unkonditionales for. Es ist an sich relativ egal, was man nimmt.

Hier das Hallo Welt mal in perl

Code:

---

Sprache: perl
Effektive Zeilen: 21
Gesamte Zeilen: 23
Größe des QT: 624byte
Exe leider nicht verfügbar (Skriptsprache und keine Ahnung vom B-Modul)

---

Code:

---

#!perl

print "Hallo Welt.\n";
print "Bitte erste Zahl eingeben: ";
chomp($a = <STDIN>);
print "Bitte zweite Zahl eingeben: ";
chomp($b = <STDIN>);
do {
  print "Bitte Operation waehlen + - * / ";
  chomp($operator = <STDIN>)
} until $operator =~ /\+/ || $operator =~ /-/ || $operator =~ /\*/ || $operator =~ /\//;
if ($operator =~ /\+/) {
  $result = $a + $b
} elsif ($operator =~ /\*/) {
  $result = $a * $b
} elsif ($operator =~ /\//) {
  $result = $a / $b
} elsif ($operator =~ /\-/) {
  $result = $a - $b
}

print "$a $& $b = $result\nDanke fuer die Benutzung. Zum Beenden Enter druecken";
<STDIN>

---

[edit]Als kleines Goodie noch ein Programm, das eine Reihe von Dateien als Parameter nimmt und deren inhalt ausgibt:

Code:

---

#!perl

while (<>) {
  print
}

---

[/edit]

@Jeez .. ich weiss .. aber solche forausdruecke koennten unsere anfaenger abschrecken, weil es ueberhaupt nicht dem entspricht, wozu eigentlich eine forschleife urspruenglich da war .. naemlich etwas hochzaehlen ;)

So und hier noch ein beispiel, wo die OOP sehr schoen zur Anwendung kommt ... das Ballbeispiel als Multiball mit 5 baellen .. viel spass dabei ... ich weiss, das konzept ist nicht ganz bugfrei .. aber was solls ^^ ... die physik dahinter: beim zusammenstoss zweier kugeln tauschen sie ihre impulse, sowohl in Betrag als auch Richtung

Source: ftp://ftp.uni-freiburg.de/incoming/delphi/multiball.txt
Executable: ftp://ftp.uni-freiburg.de/incoming/delphi/multiball.exe

Gruss Ineluki

Das Ganze in Java http://www.multimediaxis.de/images/s.../old/s_009.gif:

Code:

---

                Sprache: Java

        Effektive Zeilen: 47
Größe des Source in Byte: 1328
Größe der Binary in Byte: 2038
          Art der Binary: Java Bytecode

                    API: keine

                Benötigt: java.io.IOException, java.io.InputStreamReader

                Compiler: Blackdown JDK-1.4.1
          Kompiliert als: javac Main.java

---

Code:

---

import java.io.InputStreamReader;
import java.io.IOException;

public class Main {

  public static String readLine() {
    InputStreamReader isr=new InputStreamReader(System.in);
    char c;
    String line="";

    try {
      do {
        c=(char) isr.read();
        if (c!='\n') line = line+c;
      } while (c!='\n');
    } catch (IOException ex) {
    }
    return line;
  }

  public static void main(String[] args) {
    float z1,z2;
    String op="";
    char c;

    System.out.println("Hallo Welt.");
    System.out.print("Erste Zahl eingeben: ");
    z1=Float.parseFloat(readLine());
    System.out.print("Zweite Zahl eingeben: ");
    z2=Float.parseFloat(readLine());
    System.out.println(op);
    do {
      System.out.print("Bitte Operation waehlen + - * / ");
      op=readLine();
    } while ( !(op.equals("+") || op.equals("-") || op.equals("*") || op.equals("/")) );

    switch (op.charAt(0)) {
      case '+': System.out.println(z1+" + "+z2+" = "+(z1+z2)); break;
      case '-': System.out.println(z1+" - "+z2+" = "+(z1-z2)); break;
      case '*': System.out.println(z1+" * "+z2+" = "+(z1*z2)); break;
      case '/': System.out.println(z1+" / "+z2+" = "+(z1/z2)); break;
      default: break;
    }
    System.out.println("Danke fuer die Benutzung. Zum Beenden Enter druecken.");
    readLine();
  }
}

---

Testlauf:

Code:

---

fuero@bmfh classes $ java Main
Hallo Welt.
Erste Zahl eingeben: 23
Zweite Zahl eingeben: 56

Bitte Operation waehlen + - * / +
23.0 + 56.0 = 79.0
Danke fuer die Benutzung. Zum Beenden Enter druecken.

---

und das ganze als Java Swing-GUI :)

Code:

---

                Sprache: Java

                  Zeilen: 83
Größe des Source in Byte: 2215
Größe der Binary in Byte: 2382

                    API: keine

                Benötigt: ein paar Imports aus der javax.swing. und java.awt.

                Compiler: Sun J2SDK 1.4.2
          Kompiliert als: javac SwingCalc.java

---

Das Listing dazu:

Code:

---

/** import */
import javax.swing.JFrame;
import javax.swing.JButton;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.JLabel;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.*;

public class SwingCalc extends JFrame implements ActionListener
{
  JTextField first, second;
  JLabel result;

  public SwingCalc(String s)
  {
    super(s);
               
    /** inits */
               
    this.getContentPane().setLayout(new GridLayout(1,2));
               
    /** buttons */
    JPanel buttons = new JPanel();
    buttons.setLayout(new GridLayout(2,2));
               
    JButton add = new JButton("+");
    add.addActionListener(this);
    JButton sub = new JButton("-");
    sub.addActionListener(this);
    JButton mult = new JButton("*");
    mult.addActionListener(this);
    JButton div = new JButton("/");
    div .addActionListener(this);
               
    buttons.add(add);
    buttons.add(sub);
    buttons.add(mult);
    buttons.add(div);
               
    /** input panel */
    JPanel input = new JPanel();
    input.setLayout(new GridLayout(5,1));
    input.add(new JLabel("First number:"));
    first = new JTextField();
    input.add(first);
    input.add(new JLabel("Second number:"));
    second = new JTextField();
    input.add(second);
    result = new JLabel("Result");
    input.add(result);
               
    this.getContentPane().add(input);
    this.getContentPane().add(buttons);
  }
       
  public static void main(String args[])
  {
    SwingCalc s = new SwingCalc("SwingCalc 1.0");
    s.setSize(300,150);
    s.setVisible(true);
  }
       
  public void actionPerformed(ActionEvent e)
  {
    Object o = e.getActionCommand();
    float res = 0;
    try
    {
      if(o.equals("+"))
        res = Float.parseFloat(first.getText()) + Float.parseFloat(second.getText());
      else if(o.equals("-"))
        res = Float.parseFloat(first.getText()) - Float.parseFloat(second.getText());
      else if(o.equals("*"))
        res = Float.parseFloat(first.getText()) * Float.parseFloat(second.getText());
      else if(o.equals("/"))
        res = Float.parseFloat(first.getText()) / Float.parseFloat(second.getText());
      result.setText("Result: " + res);
    }
    catch(Exception ex) { result.setText("Error calculating..."); }
  }
}

---

Ein paar Anmerkungen:
Das ganze hat auch Exception Handling und fügt die benötigten Klassen einzeln hinzu, anstatt das gesamte Package... kostet aber auch nur ein paar Zeilen mehr.

MuadDib, deine Swing-Version sprengt das Forum (bei 1152x864, normale Zeichengröße). Vielleicht solltest du ein paar Zeilen teilen oder sie weniger stark einrücken.

BTW, Swing ist eine API. ^_~

Zitat:

---

Original geschrieben von Jesus_666
MuadDib, deine Swing-Version sprengt das Forum (bei 1152x864, normale Zeichengröße). Vielleicht solltest du ein paar Zeilen teilen oder sie weniger stark einrücken.

---

besser so?
sorry, bei meiner Auflösung fällt mir das nicht auf...

Zitat:

---

BTW, Swing ist eine API. ^_~

---

Swing ist in der Standard Java-CL, ich hätte gedacht, dass nur zusätzliche Libraries angegeben werden sollten (eben wie z.B.: fulltick)

Ich hab hier noch son bisschen was schönes gemacht:

Code:

---

#!perl

print "Hallo Welt.\n";
print "Bitte erste Zahl eingeben: ";
chomp($a = <STDIN>);
print "Bitte zweite Zahl eingeben: ";
chomp($b = <STDIN>);
do {
  print "Bitte Operation waehlen + - * / ";
  $operator = <STDIN>
} until $operator =~ /[\+\-\*\/]/;

print "$a $& $b = ", eval("$a$&$b");
print "\nDanke fuer die Benutzung. Zum Beenden Enter druecken";
<STDIN>

---

Jetzt nurnoch 370bytes groß, allerdings noch ohne Features.

Noch was feines, was als "Abfallprodukt" bei der Bearbeitung rumkam (die Extremversion des HalloWelt-Rechners[260bytes], jetzt mit Tribut an die Ausmaße)

Code:

---

#!perl

print "Hallo Welt.\n";
print "Bitte eine Rechenaufgabe eingeben. "
print "Erlaubt sind + - * / () ^ sqrt()\n";
chomp($a = <STDIN>);

$b = $a;
$a =~ s/\^/**/;

print "$b = ", eval("$a");
print "\nDanke fuer die Benutzung. Zum Beenden Enter druecken";
<STDIN>

---

[edit]
Noch ein Paar Anmerkungen zu der Pascal-Version:
Ich hätte op als [1] von dem eingelesenen definiert, und dann, da das Ergebnis vom Typ char ist, nen case drübergejagt. Außerdem hätte die Schleife durch "until op in ['+', '-', '*', '/']" kürzer terminiert werden können (wobei ich nicht weiß, welches laufzeittechnisch günstiger ist), nur mal so als Vorschlag[/edit]

Zitat:

---

Original geschrieben von Reaperman
Noch ein Paar Anmerkungen zu der Pascal-Version:
Ich hätte op als [1] von dem eingelesenen definiert, und dann, da das Ergebnis vom Typ char ist, nen case drübergejagt. Außerdem hätte die Schleife durch "until op in ['+', '-', '*', '/']" kürzer terminiert werden können (wobei ich nicht weiß, welches laufzeittechnisch günstiger ist), nur mal so als Vorschlag[/edit] [/B]

---

Dann akzeptierst du auch eine Eingabe der Form "+abcd"... Ich würde sagen, laufzeittechnisch ist es ziemlich egal, um Vergleiche kommst du sowieso nicht herum...

Warum sollte ich eine Eingabe der Form "+abcde" nicht akzeptiern? Das machten meine, bis auf die Extremversion, auch. Meiner kannst du auch Fred und Barney (danke Randal L. Schwartz) als Zahlen liefern, das Ergebnis ist dann halt 0 (mit Außnahme von Divisionen). Diese Toleranz und das automatische Konvertieren von numerischen und Stringwerten finde ich einfach geil:

Code:

---

$i++
$i = "0$i" if length($i)==1

---

Ich hab hier noch was kleines zum Thema Programmiersprachen-Vergleich:

Ein simples 600x400 px großes Fenster an der Stelle 20x40, mit "Hello World" auf Position 100x100 (auf der Hello World Seite hab ich diese Beispiele nicht gefunden, allerdings ganz interessant...).

Das erste zeigt das Problem gelöst mit Standard ANSI-C. Ich habe kein Toolkit verwendet, auch keinen GUI-Ersteller, sondern from-scratch den Code reingehackt (war übrigens mein erstes C-Windows Programm) ... das ganze ist 127 Zeilen lang (wenn man bedenkt, dass man - sollte man die WINAPI wirklich auf diese Weise programmieren - für jeden Button und jedes lächerliche Objekt so ziemlich den gleichen Code nochmal braucht, ganz zu schweigen von den ganzen Resourcen, muss man froh sein, dass es Toolkits gibt).

Source

Das zweite zeigt das ganze in Java. Stellt komplett dasselbe dar, benötigt allerdings nur 23 Zeilen...

Source

das kann man noch toppen ... in delphi brauchst du dafuer gar keinen code ;) .. zumindest keinen selbstgeschriebenen ^^

Zitat:

---

Original geschrieben von Ineluki
das kann man noch toppen ... in delphi brauchst du dafuer gar keinen code ;) .. zumindest keinen selbstgeschriebenen ^^

---

zeigen :)

Zitat:

---

Original geschrieben von MuadDib
besser so?
sorry, bei meiner Auflösung fällt mir das nicht auf...

Swing ist in der Standard Java-CL, ich hätte gedacht, dass nur zusätzliche Libraries angegeben werden sollten (eben wie z.B.: fulltick)

---

1.) Yup, danke.
2.) Laut Sun ist Swing eine API. Und ich denke, daß unter "API" jegliche APIs angegeben werden sollten.
Ich gebe unter "benötigt" alles an, was (abgesehen vom Compiler) zum Kompilieren benötigt wird; die offensichtilichen Sachen (wie die C++-STL) kann man eigentlich aber auch weglassen.

Zitat:

---

Original geschrieben von Ineluki
das kann man noch toppen ... in delphi brauchst du dafuer gar keinen code ;) .. zumindest keinen selbstgeschriebenen ^^

---

Das gilt auch für Visual Basic. Moment mal, das gilt für alle IDEs!

das Rechen-dingens nochmal als perl version mit read-line support.
D.h. das die gleichungen in einem stueck angegeben werden koennen
ex: 12+44*17/9+80-20 etc...
Wird dann komplett zusammengerechnet und ausgegeben, punkt vor komma wird aber nicht beachtet.

Code:

---

Lines:              18
Size:              412 Bytes
Binary Size: 2.034.275 Bytes (PAR: http://par.perl.org/)

---

Code:

---

#!/usr/bin/perl -w

use strict;
use Term::ReadLine;

my $term = new Term::ReadLine "Input";
my $r = $term->readline("Enter Calculation: ")."+";
$r =~ s/[^0-9\+\-\*\/]//g;

my @calc;
sub AddOp($$) { push (@calc,@_); }
$r =~ s/(.*?)([\+\-\*\/]+)/&AddOp($1,$2)/ge;
pop(@calc);

my $result=$calc[0];
my $i=1;
while($i<=$#calc)
{
  $result = eval("$result$calc[$i]$calc[$i+1]");
  $i+=2;
}

print "Result: $result\n";

---

@Reaperman: bitte bitte benutz "use strict;" ;)

@Quisazaderach .. aehm ich mein Muaddib ...

Wie soll ich dir das zeigen, das man keinen Quellcode selber schreiben muss ? ... soll ich ein video davon machen ? ^^

Das ist ebend so bei visuellen RADs

Zitat:

---

Original geschrieben von Ineluki
RADs

---

Ah, das Wort fehlte mir, als ich in meinem letzten Post "IDEs" geschrieben habe.

@Ineluki
So gut das Werkzeug auch sein mag, soviel Arbeit es dir auch abnimmt bei der Codegenerierung - was dein Programm tun soll mußt du nunmal selbst schreiben.
Delphi versteckt den Aufbau des Fensters komplett vor dir, was du mit Java/Swing in den Code reinschreiben mußt schreibt Delphi in die .DFM Datei, gehört also IMHO auch zum Sourcecode.

Zitat:

---

Original geschrieben von Ineluki
Wie soll ich dir das zeigen, das man keinen Quellcode selber schreiben muss ? ... soll ich ein video davon machen ? ^^

Das ist ebend so bei visuellen RADs

---

Achso... das ganze ist also nur ein WYSIWYG-Editor der dir die ganze Code-Arbeit abnimmt..., das is ja langweilig :);)
Jetzt wird mir auch klar, warum deine Delphi-Programme so verdammt kurz sind :)

Zitat:

---

Jesus
Laut Sun ist Swing eine API. Und ich denke, daß unter "API" jegliche APIs angegeben werden sollten.
Ich gebe unter "benötigt" alles an, was (abgesehen vom Compiler) zum Kompilieren benötigt wird; die offensichtilichen Sachen (wie die C++-STL) kann man eigentlich aber auch weglassen.

---

Nun, wie auch immer... das Teil lässt sich in einer Sekunde in das Java-AWT Format konvertieren ... Swing hat nur mehr Stil :)

Zitat:

---

Original geschrieben von Master of Disaster
@Ineluki
So gut das Werkzeug auch sein mag, soviel Arbeit es dir auch abnimmt bei der Codegenerierung - was dein Programm tun soll mußt du nunmal selbst schreiben.
Delphi versteckt den Aufbau des Fensters komplett vor dir, was du mit Java/Swing in den Code reinschreiben mußt schreibt Delphi in die .DFM Datei, gehört also IMHO auch zum Sourcecode.

---

Das Gleiche gilt an sich auch für GUI-Toolkits und die C++-Standardbibliothek.

Mit FLTK und den verwendeten STL-Includes hat mein GUI-Rechner einen Codeumfang von ca. 1,5 MiB.

Zitat:

---

Original geschrieben von Jesus_666
Das Gleiche gilt an sich auch für GUI-Toolkits und die C++-Standardbibliothek.

Mit FLTK und den verwendeten STL-Includes hat mein GUI-Rechner einen Codeumfang von ca. 1,5 MiB.

---

Na, ich würde da schon einen Unterschied machen. Bei der Standard Library schreibst du ja keinen Code bzw. lässt dir keinen Code generieren, sondern schnappst einfach vorgefertigte Dinge. Fulltick oder Delphi erstellen dir den Code, sprich: nehmen dir selber Programmierarbeit ab. Wenn du fulltick nicht verwendet hättest wäre dein Source auch wesentlich länger geworden :)

Zitat:

---

Original geschrieben von Master of Disaster
@Ineluki
So gut das Werkzeug auch sein mag, soviel Arbeit es dir auch abnimmt bei der Codegenerierung - was dein Programm tun soll mußt du nunmal selbst schreiben.
Delphi versteckt den Aufbau des Fensters komplett vor dir, was du mit Java/Swing in den Code reinschreiben mußt schreibt Delphi in die .DFM Datei, gehört also IMHO auch zum Sourcecode.

---

Ich hab ja auch nie gesagt, dass das nicht zum Code gehoehrt .. ich hab immer geschrieben, dass ich keinen Code selber schreiben musste .. und das ist ein enormer unterschied ..

In diesem Thread gehts ja um den vergleich, wieviel Aufwand man mit einer Ptogrammiersprache treiben muss, um zum gleichen Ergebnis zu kommen ... und gerade, da Delphi ein RAD ist, ist es sehr geeignet um Windows Applicationen schnell erstellen zu koennen

Zudem gibt dir ja Delphi auch die moeglichkeit, von grund auf alles selber zu scripten, also auf die RAD zu verzichten .. und dann sogar noch in 2 Moeglichkeiten .. sozusagen als Plain Pascal mit WinAPI genau so, wie man es in reinem C++ machen wuerde oder aber unter benutzung der VCL, jedoch dann mit per Hand Setzen der Eigenschaften, statt mit dem ObjectInspector

@Muaddib

Zitat:

---

Achso... das ganze ist also nur ein WYSIWYG-Editor der dir die ganze Code-Arbeit abnimmt..., das is ja langweilig
Jetzt wird mir auch klar, warum deine Delphi-Programme so verdammt kurz sind

---

Na ja .. ganz so ist es ja auch nicht .. du entwirfst halt visuell das layout und belegst dann die Komponenten mit Ereignissen, schreibst also im prinzip nur noch die OnClick-Funktion ... natuerlich haben die Programme wie alle Windowsprogramme auch eine Messageloop, aber die Steckt gleich mit in den Bibliotheken drinne und die bekommst du im normalfall nie zusehen

Es gibt bei einem Programm eine Variable vom Typ TApplication und der werden dann Variablen vom Typ TForm (bzw von TForm abgeleitete Klasen) zugewiesen, welche dann unterkomponenten haben .. z.B. TLabel fuer static text oder TEdit fuer eingabefelder oder TButton ... und diese haben dann Eigenschaften, die auf methoden deiner abgeleiteten Klasse zeigen .. also z.B. TForm1.OnButtonClick ... der rest wird nur intern behandelt, so dass man sich aufs wesentliche konzentrieren kann, naemlich auf dass, was TForm1.OnButtonClick machen soll

Zitat:

---

Original geschrieben von Ineluki
@Muaddib Na ja .. ganz so ist es ja auch nicht .. du entwirfst halt visuell das layout und belegst dann die Komponenten mit Ereignissen, schreibst also im prinzip nur noch die OnClick-Funktion ... natuerlich haben die Programme wie alle Windowsprogramme auch eine Messageloop, aber die Steckt gleich mit in den Bibliotheken drinne und die bekommst du im normalfall nie zusehen

---

Exakt das, was eine RAD eben tut und exakt der Grund, warum RADs für Einsteiger so gut geeignet sind.

Zitat:

---

Es gibt bei einem Programm eine Variable vom Typ TApplication und der werden dann Variablen vom Typ TForm (bzw von TForm abgeleitete Klasen) zugewiesen, welche dann unterkomponenten haben .. z.B. TLabel fuer static text oder TEdit fuer eingabefelder oder TButton ... und diese haben dann Eigenschaften, die auf methoden deiner abgeleiteten Klasse zeigen .. also z.B. TForm1.OnButtonClick ... der rest wird nur intern behandelt, so dass man sich aufs wesentliche konzentrieren kann, naemlich auf dass, was TForm1.OnButtonClick machen soll

---

Exakt das, was auch jedes von Normalsterblichen verwendbare GUI-Toolkit etc. tut. Ehrlich - wen interessiert es, wie die Hauptschleife eines Toolkits etc. funktioniert, wenn er nur ein Fenster damit machen will?