Wie lang sollte ein Variablenname maximal sein?

[Bashar]

In einem Programm, in dem eine Temperatur vorkommt, kommen auch noch andere Temperaturen vor. Die Frage ist also überhaupt nicht, ob man die Einheit oder was auch immer in den Namen eincodiert, sondern wie man die verschiedenen Bedeutungen auseinanderhält: Temperatur, bei der die Heizung oder Kühlung ein- oder ausgeschaltet werden soll, gemessene Temperatur, geschätzte Temperatur, gewünschte Temperatur tagsüber/abends/nachts, tatsächliche/erwartete Außentemperatur, Temperatur des Leitungswassers/Kühlwassers, Abgastemperatur usw. Ich hab noch keine Temperaturregelung oder sowas programmiert. Aber ich wette, dass die in der Praxis nicht alle das Wort "Temperatur" im Variablennamen haben, und die Einheit schon gar nicht.

[pumuckl]

knivil schrieb:

Wenn ich gerade eine Funktion schreibe, die mit 6 Variablen auskommt, dann bevorzuge ich int t gegenueber int temperatur_celsius und mache es durch ein Kommentar deutlich.

Don't comment what you can code. Soll heißen: der Code ist immer richtig. Der Kommentar wandert durch die Zeilen und landet irgendwo, wo er nicht hingehört und erzählt was von "//Temperatur in Celsius", wenn schon lange auf Kelvin umgestellt wurde.

Der Anteil von Code-Lesen gegenueber Code-Schreiben ist viel groesser. (Zu)Lange Variablennamen sind da eher hinderlich.

Zu kurze erst recht. Ich sehs eher selten, dass in einem Variablennamen mehr Info als nötig ist. Und nur dann ist der Name zu lang.

Regel schrieb:

Einfache Regel: Je kleiner der Gültigkeitsbereich der Variablen, desto kürzer kann der Variablenname sein.

314159265358979 schrieb:

nehmen. Wenn ich viel mit verschiedenen Einheiten rechne, dann würde ichs im Typ festhalten.

template <int m, int kg, int s, int A, int K, int mol, int cd>

Ich würde als Template-Parameter nicht die Einheiten, sondern die Dimensionen nehmen. Bei deinem Template kriegt man z.B. mit Litern schon Schwierigkeiten.

template <int length, int mass, int time, int temperature = 0 /* mehr Dimensionen */>
class Quantity
{
  /* Speichern des Wertes in SI Grundeinheiten */
  double value;
};

using Quantity<1, 0, 0> = Length;
using Quantity<2, 0, 0> = Area;
using Quantity<3, 0, 0> = Volume;
using Quantity<1, 0, -1> = Velocity;
using Quantity<1, 1, -2> = Force;
using Quantity<2, 1, -2> = Energy;
using Quantity<0, 1, 0> = Mass;

Force operator "" Newton(double n);
Length operator "" cm(double l);
Length operator "" inch(double l);
Length operator "" miles(double l);
Velocity operator "" kmh(double 1);
Volume operator "" litres(double v);
Energy operator "" Joule(double e);
Energy operator "" eV(double e);
Energy operator "" TeV(double e);
Mass operator "" kg(double m);
/* etc. */

int main()
{
  auto mySpeed = 54.0kmh;
  auto myMass = 84.4kg;
  auto myKineticEnergy = mySpeed * myMass;

  cout << "my Kinetic Energy \n"
       << "- in Joule: " << myKineticEnergy / 1.0Joule << '\n'
       << "- in Electron Volts: " << myKineticEnergy / 1.0eV << '\n;
  cout << "my Velocity \n"
       << "- in kmh: " << mySpeed / 1.0kmh << '\n'
       << "- in inch/sec: " << mySpeed / (1.0inch * 1.0sec) << '\n';
};

[berniebutt]

Minimal ist klar = 1 gültiges Zeichen. Maximal heute (fast) beliebig.
Antwort mit mehreren möglichen Variablennamen:

int IchHabeWenigLustZumWeiterenNachdenken;         // oder IHWLZWN
int MussManSelbstWissen;                           // oder MMSW
int ChefGibtVor;                                   // oder CGV
int ProjektVerlangtEineEinheitlicheNamensgebung;   // oder PVEEN

[knivil]

Namenslänge schrieb:

Meinst du so?

typedef int celsius;
celsius messwert1;

Nein! Ich rede hier von 'Dimensional Analysis in C++' wie sie in boost::mpl zu finden ist.

Da hätte sich mein Physiklehrer die Haare gerauft.
Vgl. "Die Voltzahl ist 55" ggü. "Die Spannung ist 55 Volt"

Schlechter Vergleich zwischen Deutsch und C++. Oder redest du so, wie du Quelltext schreibst?

[ansiskrien]

berniebutt schrieb:

Maximal heute (fast) beliebig.

Mehr als eine Bildschirmgrösse (nach ISO/ANSI 80 Zeichen breit) sollte es dann doch nicht sein.

[volkard]

Wer Mist redet, der programmiert auch Mist. :xmas2:

[knivil]

Und die andere Richtung?

[Namenslänge]

Bashar schrieb:

In einem Programm, in dem eine Temperatur vorkommt, kommen auch noch andere Temperaturen vor. Die Frage ist also überhaupt nicht, ob man die Einheit oder was auch immer in den Namen eincodiert, sondern wie man die verschiedenen Bedeutungen auseinanderhält: Temperatur, bei der die Heizung oder Kühlung ein- oder ausgeschaltet werden soll, gemessene Temperatur, geschätzte Temperatur, gewünschte Temperatur tagsüber/abends/nachts, tatsächliche/erwartete Außentemperatur, Temperatur des Leitungswassers/Kühlwassers, Abgastemperatur usw. Ich hab noch keine Temperaturregelung oder sowas programmiert. Aber ich wette, dass die in der Praxis nicht alle das Wort "Temperatur" im Variablennamen haben, und die Einheit schon gar nicht.

Okay, nehmen wir mal an, wie schreiben ne Software für ne Haussteuerung, bei der einfach alles gesteuert wird.
Also der Status der Rollläden 1-25 in Prozent, also wie weit sie geschlossen sind.
Dann die Luftfeuchtigkeit in den verschiedenen Räumen, die ganze Steuerung zu der Beleuchtung, wobei man hier auch berücksichtigen muß, das nicht alle Lichter nur ein und aus kennen, sondern es auch Lampen gibt, die man schwächer runterregeln kann, hier ist also wieder ein Status in Prozent notwendig.
Oder man hat überall Lichtsensoren die in Candela messen.
usw.

Auf jedenfall reicht es dann nicht mehr, die Variable wie du sagst, einfach Messwert_von_Esszimmer zu nennen, denn dann muß man schon schreiben Temperaturmesswert_von_Esszimmer oder so ähnlich.

[Bashar]

Namenslänge schrieb:

Auf jedenfall reicht es dann nicht mehr, die Variable wie du sagst, einfach Messwert_von_Esszimmer zu nennen

Das hab ich doch gar nicht gesagt.

[asc]

Ein Variablenname sollte so lang sein, das sich der Sinn der Variable auch für die erschließt, die sich neu in eine Software einarbeiten.

Im Zweifel halte ich meine Namen lieber etwas zu lang, falls ich aber eine verständliche, kürzere Form finde, wähle ich diese. So kann es durchaus mal sein das in der ersten Niederschrift eine Variable auch mal 30 Zeichen lang ist, aber vielleicht später ein wesentlich kürzerer lesbarer Name einfällt.

Falls es z.B. wichtig ist darauf hinzuweisen das die Temperatur in Celsius gemeint ist, würde ich wohl mit temperaturCelcius anfangen; falls im gesamten Programm einheitlich mit einer Einheit gearbeitet wird, würde ich wohl auf das Celsius verzichten.

[hustbaer]

pumuckl schrieb:

314159265358979 schrieb:

nehmen. Wenn ich viel mit verschiedenen Einheiten rechne, dann würde ichs im Typ festhalten.

template <int m, int kg, int s, int A, int K, int mol, int cd>

Ich würde als Template-Parameter nicht die Einheiten, sondern die Dimensionen nehmen. Bei deinem Template kriegt man z.B. mit Litern schon Schwierigkeiten.

template <int length, int mass, int time, int temperature = 0 /* mehr Dimensionen */>
class Quantity
{
  /* Speichern des Wertes in SI Grundeinheiten */
  double value;
};

Ist doch genau das selbe wie Pi macht, nur dass du deine Template-Parameter anders nennst

In beiden Fällen entsprechen die Template-Parameter den Exponenten der SI-Basiseinheiten. Und der Wert wird immer ohne "scale" abgespeichert, also ein Liter ist dann eine Quantity<3, 0, 0, ...> mit value = 0.001.

[Wutz]

Namenslänge schrieb:

Aber welche Variablennamenlänge sollte man als Richtwert überhaupt wählen?
< 12 Zeichen, < 20 Zeichen oder gar größer?

Größer aber bei ANSI C nur bis max. 31 Zeichen für interne Namen, 6 bei externen.
Nur hierfür garantiert der Standard/Compiler die Signifikanz.

[Shiba]

Regel schrieb:

Einfache Regel: Je kleiner der Gültigkeitsbereich der Variablen, desto kürzer kann der Variablenname sein.

Guter Witz
Hier
http://mindprod.com/jgloss/unmainnaming.html
gibts noch mehr gute Handreichungen, wie man Variablen benennen soll.

Ansonsten sollte der Name der Variable deutlich sagen, wozu die da ist.
Und da stimme ich mit Bashar überein, dass eine Benennung nach Einheit nicht unbedingt sinnvoll ist.
Namensbegründungen, wie ist zu lang oder ich weiß, doch was t bedeutet, sind nett. Besonders fein sind Variablennamen wie lfz1 (erste Laufzeit) und lfzl (Laufzeit lang) zusammen in einer Funktion/einem Block.

Falls so etwas in größeren, langfristigen Projekten stattfindet, sollte der Entwickler Adresse und Telefonnummer für den nachfolgenden Maintainer hinterlassen. Dann kann dieser seine Freude über wundervollen Code direkt dem Schöpfer bekunden.

[hustbaer]

Wutz schrieb:

Namenslänge schrieb:

Aber welche Variablennamenlänge sollte man als Richtwert überhaupt wählen?
< 12 Zeichen, < 20 Zeichen oder gar größer?

Größer aber bei ANSI C nur bis max. 31 Zeichen für interne Namen, 6 bei externen.
Nur hierfür garantiert der Standard/Compiler die Signifikanz.

Und deswegen sollte man bei C jetzt seine Namen kastrieren?
Also ne, sicher nicht.
Reale Compiler fressen wesentich längere Namen, ich sehe also keinen Grund in realen Programmen nicht auch längere Namen zu verwenden.

[muemmel]

Hi,

ansiskrien schrieb:

berniebutt schrieb:

Maximal heute (fast) beliebig.

Mehr als eine Bildschirmgrösse (nach ISO/ANSI 80 Zeichen breit) sollte es dann doch nicht sein.

Also auf meinem Bildschirm sehe ich 225 Zeichen, glaube aber, dass das für einen Variablennamen ein kleines bisschen lang ist. :xmas1:

Allgemein kann man wohl sagen, dass all die Variablennamen bei denen man alle Vorkommen (Definition und Verwendung) innerhalb einer Bildschirmseite im Blick hat kürzer sein können als die auf die das nicht zutrifft.
Kommentare sollten besser nicht angeben, was damit gemeint ist, sondern eher warum die Variable gebraucht wird und welche sonstigen Bezüge sie hat.

Im Fall der Temperatur ist es aber doch nicht so einfach. Überall wo es mehr um physikalische Probleme geht, oder sonst wie °C und °F auftreten können würde ich eine Klasse verwenden, die C und F entsprechend verarbeitet und für Differenzen oder Veränderungen Grad nimmt.

Als einfache Laufwariablen oder Schleifenvariablen in kurzen Schleifen, wo sich das aus der Sache selbst erklärt nehme ich aber aus alter Fortran-Gewöhnung auch heute noch gerne i, j, k, l, m, n. Da weis ich dann aus dem Namen heraus schon, dass das einfach nur zum hochzählen da ist. :xmas2:

Gruß Mümmel

[muemmel]

Hi,

hustbaer schrieb:

Wutz schrieb:

Größer aber bei ANSI C nur bis max. 31 Zeichen für interne Namen, 6 bei externen.

Und deswegen sollte man bei C jetzt seine Namen kastrieren?
Also ne, sicher nicht.
Reale Compiler fressen wesentich längere Namen, ich sehe also keinen Grund in realen Programmen nicht auch längere Namen zu verwenden.

wenn einem 31 Zeichen nicht reichen, sollte man ggf mal über seinen Programmierstil nachdenken.
Mit Namen die sihc erst nach der 31. Stelle unterscheiden und vom Compiler her als gleich angesehen werden, erzeugt man sich wunderschöne unerklärliche Effekte, an denen man sich unter Umständen einen Wolf sucht.
Man definiert in einer Funktion eine Variable, die sich von einer externen Variable unterscheidet. Auf Grund der Länge übedeckt diese jedoch die externe Variable, so dass alle Zugriffe immer bei der lokalen Variable landen.
Da daraus ein für den Menschen völlig korrektes Programm entsteht, das auch für den Compiler völlig korrekt ist, nur von beiden unterschiedlich verstanden wir, ist da Chaos und Überstunden vorbereitet.

Gruß Mümmel

[volkard]

muemmel schrieb:

wenn einem 31 Zeichen nicht reichen, sollte man ggf mal über seinen Programmierstil nachdenken.

Kommt vor. Und durch Nachdenken bin ich dazu gekommen, daß lange Namen manchmal gut sind.

[Wutz]

hustbaer schrieb:

Wutz schrieb:

Namenslänge schrieb:

Aber welche Variablennamenlänge sollte man als Richtwert überhaupt wählen?
< 12 Zeichen, < 20 Zeichen oder gar größer?

Größer aber bei ANSI C nur bis max. 31 Zeichen für interne Namen, 6 bei externen.
Nur hierfür garantiert der Standard/Compiler die Signifikanz.

Und deswegen sollte man bei C jetzt seine Namen kastrieren?
Also ne, sicher nicht.
Reale Compiler fressen wesentich längere Namen, ich sehe also keinen Grund in realen Programmen nicht auch längere Namen zu verwenden.

Ich habe nicht gesagt, dass du deine Variablen auf max. 31 Zeichen kürzen sollst, ich habe gesagt, dass (nur) die ersten 31 Zeichen gemäß Standard signifikant sind, du kannst die dann beliebig erweitern und eine dir genehme Beschreibung in den Variablennamen einfließen lassen.
Das nächste Limit liegt dann bei 509 Zeichen, wie auch für Stringliterale.

[Idee]

muemmel schrieb:

Hi,

hustbaer schrieb:

Wutz schrieb:

Größer aber bei ANSI C nur bis max. 31 Zeichen für interne Namen, 6 bei externen.

Und deswegen sollte man bei C jetzt seine Namen kastrieren?
Also ne, sicher nicht.
Reale Compiler fressen wesentich längere Namen, ich sehe also keinen Grund in realen Programmen nicht auch längere Namen zu verwenden.

wenn einem 31 Zeichen nicht reichen, sollte man ggf mal über seinen Programmierstil nachdenken.
Mit Namen die sihc erst nach der 31. Stelle unterscheiden und vom Compiler her als gleich angesehen werden, erzeugt man sich wunderschöne unerklärliche Effekte, an denen man sich unter Umständen einen Wolf sucht.
Man definiert in einer Funktion eine Variable, die sich von einer externen Variable unterscheidet. Auf Grund der Länge übedeckt diese jedoch die externe Variable, so dass alle Zugriffe immer bei der lokalen Variable landen.
Da daraus ein für den Menschen völlig korrektes Programm entsteht, das auch für den Compiler völlig korrekt ist, nur von beiden unterschiedlich verstanden wir, ist da Chaos und Überstunden vorbereitet.

Gruß Mümmel

Vielleicht sollte man besser die Compiler ausgrenzen, die mehr als 31 Zeichen nicht beherrschen.
Dadurch erspart man sich das Wolf suchen.

[Regel]

Guter Witz

War kein Witz!

Die Regel funktioniert erstaunlich gut. Ich muss zugeben, ich programmiere in letzter Zeit fast nur noch in Haskell, wo sehr kurze Funktionen (und damit ein sehr beschränker Gültigkeitsbereich) keine Seltenheit sind.
Aber auch in imperativen Sprachen funktioniert das gut. Z.B. sehe ich keinen Grund in hustbaers Beispiel so lange Variablennamen zu wählen. Klar, in dem Beispiel ging es eher um die Templategeschichte, aber ansonsten würde ich (für dieses Beispiel) wahrscheinlich statt

auto mySpeed = 54.0kmh;
  auto myMass = 84.4kg;
  auto myKineticEnergy = mySpeed * myMass;

das hier schreiben:

auto v = 54.0kmh;
  auto m = 84.4kg;
  auto e_kin = v * m;