Dieses AUTO ist cool

Die Welt ist im Wandel

hieß schon am Beginn der Herr-der-Ringe Filme und das trifft auch auf unsere Welt(en) zu.

Während die Worte gleich bleiben ändert sich das, was damit bezeichnet wird, und schon haben wir ganz neue Möglichkeiten uns auszudrücken.

Das beste Beispiel dafür ist das Schlüsselwort auto, welches seit Urzeiten ungenutzt im C-Standard liegt und welches seit C++ 11 ein ganz neue Bedeutung erhalten hat.


In der klassischen C Welt gab bzw. gibt es 3 Formen von Datenelementen:

  • statische: das sind globale Variablen, die vom Programmbeginn an bis zum Ende an der gleichen Adresse verweilen.
  • dynamische: sie werden von der Speicherverwaltung ( malloc() ) auf Anfrage bereitgestellt und müssen auch manuell wieder freigegeben werden (free() )
  • automatische: das sind unsere lokalen Variablen und Funktionsparameter und diese werden automatisch relativ zur aktuell laufenden Funktionsparameter an einen bestimmten Ort (Stack gepackt.

Globale / statische Variablen

Für globale Variablen gibt es den Bezeichner static, vor allem wenn sie innerhalb von Funktionen deklariert werden. Außerhalb (also im globalen Namensraum) können sie auch den Bezeichner extern haben, wenn sie über Modulgrenzen hinweg (DLL/SO) sichtbar sein sollen.

/* visible global variable, accessible from everywhere */
extern int global_state = 1;

/* global variable, accessible only in current .c file */
static int internal_state = 2;

int my_function(int param)
{
	/* global variable only accessible in this function */
	static int function_state = 3;
}

Dynamische Variablen

Vereinfacht könnte sagen:

Alles, was bei seiner Erzeugung als Pointer entsteht, fällt in diese Kategorie.

Bei malloc() / free() angefangen bis hin zu nativen Funktion eines Betriebssystems bekommen wir stets einen Pointer, der auf die eigentlichen Daten zeigt.

Darauf brauchen wir hier nicht näher eingehen.

Automatische / lokale Variablen

Tja, aber die meisten Datenelemente liegen in lokalen Variablen innerhalb von Funktionen, und diese werden automatisch an einer Speicheradresse angelegt, die am Stack liegt und relativ zum aktuellen Funktionsrahmen (Stack-Frame) errechnet wird.

Und genau hier hatte der C Standard ein eigenes Schlüsselwort vorgesehen und das hieß auto.

Das C Schlüsselwort AUTO

Es war also vorgesehen, dass wir in Funktionen unseren Code in etwa so schreiben:

int get_counter()
{
	static int global_counter = 1;
	
	auto int current_count = ++global_counter;
	
	return current_count;
}

Jede lokale Variable hätte mit auto als eben solche identifiziert werden sollen.
Aber genau das ist überflüssig, denn wenn eine Variable nicht statisch ist, was sollte sie denn sonst sein?

Und so konnte man auto auch weglassen und nur
int current_count = ... schreiben um eine automatische Variable zu erhalten.

auto gelang somit in Vergessenheit bevor es noch bekannt wurde. Und ich kenne keinen verbreiteten C Code, der auto jemals eingesetzt hätte.

auto als Heilsbringer in C++

Aus genau diesem Grund erhielt auto im C++ Standard 2011 (C++11) eine neue Bedeutung:

Lässt man nach auto den Datentypen weg und es folgt der Variablennamen, so legt der Compiler automatisch den Datentypen fest.

Anstatt

int x = 42;
std::string y = my_stringstream.str();
double* z = new double();

kann man nun:

auto x = 42;
auto y = my_stringstream.str();
auto z = new double();

schreiben.

Und wie geil das für Templates ist … dazu schreib ich morgen was.


Wenn sich eine triviale Erkenntnis mit Dummheit in der Interpretation paart, dann gibt es in der Regel Kollateralschäden in der Anwendung.
frei zitiert nach A. Van der Bellen
... also dann paaren wir mal eine komplexe Erkenntnis mit Klugheit in der Interpretation!