Bezeichner, Bindungen, Bereiche

vereinfacht: Variable bezeichnet eine (logische) Speicherzelle

genauer: Variable besitzt Attribute

Name
Adresse
Wert
Typ
Lebensdauer
Sichtbarkeitsbereich

Bindungen dieser Attribute statisch oder dynamisch

ein Name bezeichnet einen unveränderlichen Wert
e = $\displaystyle \sum_{{n\ge 0}}^{}$ $\displaystyle {\frac{{1}}{{n!}}}$ , sin = (x $\displaystyle \mapsto$ $\displaystyle \sum_{{n\ge 0}}^{}$ (- 1)ⁿ $\displaystyle {\frac{{x^{2n+1}}}{{(2n+1)!}}}$ )
auch n und x sind dabei lokale Konstanten (werden aber gern „Variablen`` genannt)
auch die „Variablen`` in Gleichungssystemen sind (unbekannte) Konstanten {x + y = 1∧2x + y = 1}

in der Programmierung:

Variable ist Name für Speicherstelle (= konstanter Zeiger)
implizite Dereferenzierung beim Lesen und Schreiben
Konstante: Zeiger auf schreibgeschützte Speicherstelle

welche Buchstaben/Zeichen sind erlaubt?
reservierte Bezeichner?
Groß/Kleinschreibung?
Konvention: long_name oder longName (camel-case)
(Fortran: long name)
im Zweifelsfall: Konvention der Umgebung einhalten
Konvention: Typ im Namen (schlecht, weil so Implementierungsdetails verraten werden)
schlecht: myStack = ...
besser: Stack<Ding> rest_of_input = ...

dynamisch (Wert hat Typ)
statisch (Name hat Typ)
- deklariert (durch Programmierer)
- inferiert (durch Übersetzer)
  z. B. var in C#3

Vor/Nachteile: Lesbarkeit, Sicherheit, Kosten

Daten sind typisiert, Namen sind nicht typisiert.

LISP, Clojure, PHP, Python, Perl, Javascript, ...

<html><body><script type="text/javascript">
var bar = true;
var foo = 
  bar ? [1,2] : function(x) {return 3*x;};
document.write (foo[0]);
</script></body></html>

Daten sind typisiert, Namen sind typisiert

Programmierer muß Typen von Namen deklarieren:
C, Java, ...
Compiler inferiert Typen von Namen:
ML, F#, Haskell, C# (var)

public class infer {
    public static void Main (string [] argv) {
        var arg = argv[0];
        var len = arg.Length;
        System.Console.WriteLine (len);
    }
}

Beachte: das var in C# ist nicht das var aus Javascript.

im einfachsten Fall (Java, C#):

Typname Variablenname [ = Initialisierung ] ;
int []  a = { 1, 2, 3 };
Func<double,double> f = (x => sin(x));

gern auch komplizierter (C): dort gibt es keine Syntax für Typen, sondern nur für Deklarationen von Namen.

double f (double x) { return sin(x); }
int * p;
double ( * a [2]) (double) ;

Beachte: * und [] werden „von außen nach innen `` angewendet

Ü: Syntaxbäume zeichnen, a benutzen

= Variablen, an die genau einmal zugewiesen wird

C: const (ist Attribut für Typ)
Java: final (ist Attribut für Variable)

Vorsicht:

class C { int foo; }
static void g (final C x) { x.foo ++; }

Merksatz: alle Deklarationen so lokal und so konstant wie möglich!

(D. h. Attribute immutable usw.)

statisch (global, aber auch lokal:)

int f (int x) {
    static int y = 3; y++; return x+y;
}

dynamisch
- Stack { int x = ... }
- Heap
  - explizit (new/delete, malloc/free)
  - implizit

= Bereich der Anweisungen/Deklarationen, in denen ein Name benutzt werden kann.

global
lokal: Block (und Unterblöcke)

Üblich ist: Sichtbarkeit beginnt nach Deklaration und endet am Ende des umgebenden Blockes

Namen sind auch in inneren Blöcken sichtbar:

int x;
while (..) {
  int y;
  ... x + y ... 
}

innere Deklarationen verdecken äußere:

int x;
while (..) {
  int x;
  ... x ... 
}

...stimmen nicht immer überein:

static-Variablen in C-Funktionen
sichtbar: in Funktion, Leben: Programm
lokale Variablen in Unterprogrammen
sichtbar: innere Blöcke, Leben: bis Ende Unterpr.

2015-08-17