Juergen G. schrieb:
> ich hab C vor vielen Jahren mit
>
> for( int i=0; i < 256; i++ )
>
> gelernt.
Da hattest du einen neueren Compiler
> Dann musste ich es irgenwann verwerfen weil die Compiler es
> immer angemeckert haben.
Ältere Compiler.
> Jetzt hab ich mich daran gewoehnt und schon geht es "back to the roots"
> ?
Anders rum.
Am Anfang der Zeit galt die Regel:
Variablendefinitionen werden an den Funktionsanfang zusammengezogen.
Diese Regel wurde irgendwann gelockert zu: Variablendefinitionen können
auch innerhalb von Blöcken passieren und werden an den Blockanfang
zusammengezogen
Danach konnte man die Variablendefinitionen an die Stelle verschieben,
an die die Variable das erste mal tatsächlich benutzt wird.
Der Weg geht also hin zu: Variablendefinitionen sollen so eng wie
möglich und so kurz wie möglich vor der verwendenden Stelle passieren.
Das Ziel ist es, den Scope von Variablen möglichst einzuschränken und
die Scopegrenzen möglichst eng um die verwendende Stelle legen zu
können.
Mit etwas Phantasie könnte man sagen: Die logische Fortsetzung der
Doktrin globale Variablen sind böse. Und so wie funktionslokale
Variablen einen Ausweg aus globalen Variablen darstellen, so sind
blocklokale Variablen der Ausweg aus funkions-'globalen' Variablen. Wenn
man jetzt noch definiert, dass ein for sich in dieser Beziehung wie ein
Block verhält, dann sind wir genau bei der jetzigen Situation.
for( int i = 0; i < 10; i++ ) {
...
}
.... (A)
for( int i = 0; i < 10; i++ ) {
...
}
das sind 2 verschiedene Variablen i. Im Code dazwischen (A) existiert
keine Variable i, ein Zugriff darauf ist an dieser Stelle daher illegal.
C++ hatte da einen großen Einfluss auf diesen Weg, weil dort die
Objektkonstruktion mittels Konstruktor unter Umständen eine teure
Operation ist.
void foo()
{
MeineKlasse xyz;
if( Operation_gültig )
xyz.Machwas();
}
hat das 'Problem', dass xyz auf jeden Fall konstruiert werden muss,
selbst wenn es danach überhaupt nicht benutzt wird. Zieh ich das aber in
einen Block rein
void foo()
{
if( Operation_gültig ) {
MeineKlasse xyz;
xyz.Machwas();
}
}
dann spare ich diese Konstruktionskosten im Fall, dass überhaupt nichts
mit dem Objekt gemacht wird.
In weiterer Folge hat sich dann herausgestellt, dass diese
Vorgehensweise softwaretechnisch nicht schlecht ist und zu einer
positiven Codequalität beiträgt. C hat das dann von C++ abgekupfert
(genauso wie const).
