Programmierrichtlinen (Uni-Paderborn)

life

Als frische Student in der ersten Woche stolperte ich heute, beim bearbeiten der Übungsaufgaben, über folgendes Dokument:
http://wwwcs.uni-paderborn.de/cs/ag-wehrheim/vorlesungen/ws05/gp/files/Richtlinien.pdf
Auch wenn es größtenteils in Ordnung scheint, stieß mir jedoch insbesondere folgender Punkt auf:

Die Deklaration von Variablen soll nur am Anfang von Blöcken gemacht werden (nach "{"). Ausnahme: Innerhalb des Schleifen-Kopfs

Mich erinnerte dies eher an graumsame C-Zeiten als an einen moderenen (java) Stil und ist meiner Meinung nach einfach nur falsch.

Da aber nun offsichtlich nicht jeder an meiner Uni meine Meinung teilt, wollte ich nun hier mal erfragen, ob ihr das ähnlich seht oder ob derartiger Programmierstil wirklich heutzutage als guter Stil angesehen wird.

Sgt. Nukem

Teile ich nicht.

Sowas ist für PASCAL gut, wo die Compiler darauf ausgelegt sind, in einem Durchgang (schnell) alles zu übersetzen.

Die Richtlinien wurden von einer Frau erstellt?!

imhotep

no comment schrieb:

Die Richtlinien wurden von einer Frau erstellt?!

Nö wurden sie nicht

Der Name der .java-Datei muss der Bezeichnung der Klasse bzw. des Interfaces entsprechen.

Muss das nicht prinzipell so sein? Meckert der Javac nicht, wenn es nich so ist?

Die Deklaration von Variablen soll nur am Anfang von Blöcken gemacht werden (nach "{"). Ausnahme: Innerhalb des Schleifen-Kopfs

Ich find das ganz okay, erweckt bei mir immer den Anschein, als sei der Code durchdachter, als wenn irgendwo plötzlich mal was deklariert wird, weil mans grad braucht.

Sonst klingen die Richtlinien ganz vernüpftig. Wenn man später in ner Firma arbeitet, kann man ja auch nicht sagen: "Das gefällt mir nicht, dass mach ich nicht"

life

vielleicht mal ein codebeispiel dazu, dass sie hochgeladen hat

public static void main (String [] args) {

	int tag, monat, jahr;
	double preis, neuerpreis;

	tag = 9;
	monat = 11;
	jahr = 1989;

	System.out.println("Datum des Mauerfalls:");
	System.out.println(tag,monat,jahr);

	preis = 3.29;

	System.out.println("Preis einer Flasche Sekt am Tag des Mauerfalls in DM:");
	System.out.println(preis);

	neuerpreis = 2 * preis;

	System.out.println("Preis einer Flasche Sekt heute in EUR:");
	System.out.println(neuerpreis);

    }

ich würds eher so machen (verboten):

public static void main (String [] args) {

	int tag = 9;
	int monat = 11;
	int jahr = 1989;

	System.out.println("Datum des Mauerfalls:");
	System.out.println(tag,monat,jahr);

	double preis = 3.29;

	System.out.println("Preis einer Flasche Sekt am Tag des Mauerfalls in DM:");
	System.out.println(preis);

	double neuerpreis = 2 * preis;

	System.out.println("Preis einer Flasche Sekt heute in EUR:");
	System.out.println(neuerpreis);

 }

Ganz schön peinlich!

Ne, das ist schlechter Stil @life. Passt scho, was in der Richtlinie steht.

Gregor

life: Die Java Coding Conventions von Sun sehen so eine Art Mittelweg zwischen den beiden von dir gezeigten Varianten vor:

http://java.sun.com/docs/codeconv/html/CodeConventions.doc5.html#2991

One declaration per line is recommended

Try to initialize local variables where they're declared. The only reason not to initialize a variable where it's declared is if the initial value depends on some computation occurring first.

...aber wie in der Richtline eurer Uni:

Put declarations only at the beginning of blocks.

Ich muss sagen, dass ich mich auch nicht unbedingt an diese letzte Regel halte. Ich bin dafür, dass Variablen so lokal wie möglich gehalten werden. Sie sollen einen möglichst kleinen Gültigkeitsbereich haben. Wenn ich mal ne ganz lange Methode mit 20 Zeilen habe und eine Variable erst am Schluss benötige, halte ich es für Unsinn, diese Variable ganz am Anfang zu deklarieren. ...abgesehen davon sollte man natürlich eher kürzere Methoden anstreben.

PS: Im Zweifelsfall kannst du ja einfach Extrablöcke einfügen. Dann ist jeder zufrieden, auch wenn der Code dann scheiße aussieht:

public static void main (String [] args) {
   int tag = 9;
   int monat = 11;
   int jahr = 1989;

   System.out.println("Datum des Mauerfalls:");
   System.out.println(tag,monat,jahr);

   {
      double preis = 3.29;

      System.out.println("Preis einer Flasche Sekt am Tag des Mauerfalls in DM:");
      System.out.println(preis);
      {
         double neuerpreis = 2 * preis;

         System.out.println("Preis einer Flasche Sekt heute in EUR:");
         System.out.println(neuerpreis);
      }
   }
}

life

Gregor schrieb:

PS: Im Zweifelsfall kannst du ja einfach Extrablöcke einfügen. Dann ist jeder zufrieden, auch wenn der Code dann scheiße aussieht:

Das hat ich mir auch schon überlegt

Ich deklariere normalerweise alle Variablen am Anfang des Blockes. Erstens gehts ja in C nicht anders und zweitens finde ich es ehrlich gesagt auch übersichtlicher, als wenn man die Variablen quer durch die Funktion definiert. Hat man einen grossen Block und überfliegt diesen, dann wundert man sich öfters wo denn jetzt Variable Xy auf einmal herkommt und was das sein soll. Wenn alles am Anfang deklariert ist, kann man schneller nachgucken. Lediglich bei so Kleinigkeiten wie for Schleifen etc. sehe ich es als nützlich an.

life

Gregorianer schrieb:

Wenn alles am Anfang deklariert ist, kann man schneller nachgucken.

wenn es direkt beim gebraucht definiert ist muss man aber garnicht nachgucken

Ponto

life schrieb:

Gregorianer schrieb:

Wenn alles am Anfang deklariert ist, kann man schneller nachgucken.

wenn es direkt beim gebraucht definiert ist muss man aber garnicht nachgucken

Und es spart Codezeilen, wenn man dort definiert, wo auch gebraucht wird. In Java hat es wohl anders als in C++ keinen Overhead, wenn man alles am Anfang definiert. Man arbeitet ja nur mit Zeigern.

otze

Ponto schrieb:

life schrieb:

Gregorianer schrieb:

Wenn alles am Anfang deklariert ist, kann man schneller nachgucken.

wenn es direkt beim gebraucht definiert ist muss man aber garnicht nachgucken

Und es spart Codezeilen, wenn man dort definiert, wo auch gebraucht wird. In Java hat es wohl anders als in C++ keinen Overhead, wenn man alles am Anfang definiert. Man arbeitet ja nur mit Zeigern.

hats in C++ auch nicht. Die Compiler sind da schon intelligent genug

Ponto

otze schrieb:

hats in C++ auch nicht. Die Compiler sind da schon intelligent genug

Das glaube ich nicht:

class Obj {
public:
   Obj() { sock.open("127.0.0.1"); }
   ~Obj() { sock.close(); }
   void write(char const * str) { sock.write(str); }
private:
   SocketObj sock;
};

void func(int value) {
  Obj ob;

  if (value > 10) return;

  ob.write(value);
}

Der Grund dafür das man Variablen in C++ nicht alle blockweise definiert ist
doch ganz einfach und logisch nachvollziehbar.
Man verbindet bei Objekten sehr häufig die Definition mit der Initialisierung.
Da die Initailisierung sehr teuer werden kann "erstellt" man die Variablen
natürlich erst dann wenn sie wirklich benötigt werden.
Das ganze hat also wirklich mehr als nur formale Aspekte.

Helium

otze schrieb:

Ponto schrieb:

life schrieb:

Gregorianer schrieb:

Wenn alles am Anfang deklariert ist, kann man schneller nachgucken.

wenn es direkt beim gebraucht definiert ist muss man aber garnicht nachgucken

Und es spart Codezeilen, wenn man dort definiert, wo auch gebraucht wird. In Java hat es wohl anders als in C++ keinen Overhead, wenn man alles am Anfang definiert. Man arbeitet ja nur mit Zeigern.

hats in C++ auch nicht. Die Compiler sind da schon intelligent genug

Dann ist dein Compiler kaputt. Er sollte schon das machen, was du ihm sagst.

{
   Foo foo;  // Default-C'tor
   ...
   foo = bar;  // Zuweisung
}

{
   ...
   Foo foo (bar);  // spezieller C'tor
}

Das gilt zwar für Java nicht. Dennoch wird bei mir alles da definiert, wo ich es brauche. Nach oben Springen 'ne Definition einfügen, wieder nach unten und weiterschreiben, wider nach oben, ... was für 'ne Arbeitsweise.

Daniel E.

Helium schrieb:

Dennoch wird bei mir alles da definiert, wo ich es brauche. Nach oben Springen 'ne Definition einfügen, wieder nach unten und weiterschreiben, wider nach oben, ... was für 'ne Arbeitsweise.

Man hat ja gewöhnlich einen Plan der Funktion im Kopf und schreibst sie dann eben kochrezeptartig hin: Oben die Zutaten und unten, was damit passiert.

Gregor

Daniel E. schrieb:

Man hat ja gewöhnlich einen Plan der Funktion im Kopf und schreibst sie dann eben kochrezeptartig hin: Oben die Zutaten und unten, was damit passiert.

Ist bei mir nicht so. Bei mir ergibt sich oft erst beim Schreiben eines konkreten Codesegments, was ich dazu eigentlich noch für Hilfsvariablen und so brauche.

Walli

Ponto: Was soll der Compiler denn deiner Meinung nach sonst machen? Ist doch klar, dass er den Konstruktoraufruf nicht einfach ignorieren kann. Das "Problem" hat man in Java auch, wenn man sich eine Instanz erstellt lange bevor sie gebraucht wird.

Ponto

Walli schrieb:

Ponto: Was soll der Compiler denn deiner Meinung nach sonst machen? Ist doch klar, dass er den Konstruktoraufruf nicht einfach ignorieren kann. Das "Problem" hat man in Java auch, wenn man sich eine Instanz erstellt lange bevor sie gebraucht wird.

In Java ist es aber üblich ständig mit Zeigern zu arbeiten:

Obj ob;

... ganz viel Code ...

ob = new Obj();

Da kostet es halt nichts vorher das ob anzulegen. Sowas kann man in C++ mit Zeigern ja genauso machen und dann gehe ich davon aus, dass der Compiler mir da nicht sofort Stackspeicher für alloziert, wenn es nicht notwendig ist.

In C++ ist es aber eher unüblich mit Zeigern zu arbeiten und die Objekte werden direkt erstellt. Wenn man dann alle Variablen direkt definiert hat man das gleiche Problem, wie wenn man unter Java sofort instanziert.

Walli

Ja, aber da vergleichst du ja trotzdem Äpfel mit Birnen. Ich sehe nicht wo C++ da einen unnötigen Overhead haben sollte. In C++ ist es hier nicht üblich wie in Java mit Zeigern zu arbeiten, aber die Objekte zu früh zu instanziieren ist ja auch nicht üblich. Ich vermute die Compiler sind schon intelligent genug die Instanziierungen zur rechten Zeit zu machen, aber nur, wenn dadurch der Programmablauf nicht verändert wird. Ich denke bei PODs und builtins sollte es hier kein Problem geben.