was macht static?

Hi, ich wollte fragen, was das Schlüsselwort static macht.
Kann es sein, dass es bei einer Funktion oder einer globalen Variable dafür sorgt, dass man diese nur innerhalb der selben Datei nutzen kann?
Und dass es bei einer Variablen in einer Funktion einer globalen Variable gleicht?

Wenn ja, was ist besser, static oder global?

this-*gt*that

static auf globaler Ebene macht die Funktion/Variable nur in dieser Übersetzungseinheit sichtbar. Statische Variablen in einer Funktion behalten ihren Wert auch beim Verlassen der Funktion.
Variablen sollten immer so lokal wie möglich sein.

Und static Variablen sind lokal?

JimmydaMage

Ich weiß nicht, wo der Compiler sie anlegt, zumindest sind sie aber nur in der Funktion, in der sie deklariert wurden, sichtbar...

Grüße,

Martin

Undertaker

hm?? schrieb:

Und static Variablen sind lokal?

'logisch' gesehen sind sie lokal.
'praktisch' sind sie im gleichen segment wie globale variablen.

Was ist denn nun besser?

Auf welche Art und Weise ist es überhaupt besser?

am besten nix von beiden

Don06

Satic Variablen nur dann verwenden, wenn es Sinn macht! Lokale Variablen, globale Variablen, static Variablen, sie alle haben ihren begrenzten Breich, indem sie nützlich sind. Eine Schleifenzählvariable sollte lokal sein. Globale Variablen sind zwar selten nötig, aber wenn, dann um Zugriff von überall zu ermöglichen.
Satic Variablen werden nur einmal initialisiert und behalten danach ihren Wert auch nach Verlassen der Funktion. Das braucht man zB für Status-Variablen innerhalb einer Funktion.

EDIT: zu viel C++...

Gruß
Don06

Die static Variablen sind dann aber nur in der einen Funktion, in der sie deklariert worden sind, zugänglich, oder?

[Danke]

Ja, aber das kann man legal umgehen:

int *foo (void) {
    static int bad_approximation_to_pi = 3;
    return &bad_approximation_to_pi;
}

Ist es dann besser

int foo (void) {
    static int a = 3;
    return a;
}

oder

int a;
int main() {}

zu nehmen?

Don06

Beide Beispiele machen etwas unterschiedliches!
Das erste legt eine statische Variable an und gibt diese by-value zurück, d.h. sie wird kopiert. Von ausserhalb der Funktion gibt es keine Zugriffsmöglichkeit.
Du müsstest schon mit Pointer herumhantieren um das gewünschte Verhalten hinzukriegen (siehe Tims Beitrag). Dort wäre die Lösung mit der lokalen Variable sogar fehlerhaft, da ein Pointer auf eine lokale Variable zurückgegeben würde Der Pointer wäre ungültig, oder besser das worauf er zeigt.

Gruß
Don06

Undertaker

Don06 schrieb:

Du müsstest schon mit Pointer herumhantieren um das gewünschte Verhalten hinzukriegen (siehe Tims Beitrag). Dort wäre die Lösung mit der lokalen Variable sogar fehlerhaft, da ein Pointer auf eine lokale Variable zurückgegeben würde Der Pointer wäre ungültig, oder besser das worauf er zeigt.

geht trotzdem, die variable ist 'static' und bleibt erhalten.
oder habe ich dich falsch verstanden?

Don06 schrieb:

...
Du müsstest schon mit Pointer herumhantieren um das gewünschte Verhalten hinzukriegen (siehe Tims Beitrag). Dort wäre die Lösung mit der lokalen Variable sogar fehlerhaft, da ein Pointer auf eine lokale Variable zurückgegeben würde Der Pointer wäre ungültig, oder besser das worauf er zeigt.

Tim schrieb:

Ja, aber das kann man legal umgehen:

int *foo (void) {
    static int bad_approximation_to_pi = 3;
    return &bad_approximation_to_pi;
}

Dieser Pointer ist zwar lokal, er ist weil die Variable "static" ist auch ausserhalb der
Funktion gültig! Die Lösung mit der lokalen static Variable (Rückgabe als Pointere) ist fehlerfrei.
MfG

Don06

@ Undetaker: Es ist eben nicht dasselbe Verhalten wie eine globale Variable, da kein Schreibzugriff besteht (bei der Funktion von hm??)
@ balduin: ich meinte die Variante _ohne_ static.

EDIT: Vorher quatsch...

int foo (void) {
    int a = 3;
    return a;
}

geht auch, weil es nur ein int ist und der wert als kopie zurück gegeben wird. staic bewirkt, dass die variable beim nächsten aufruf wieder den wert hat, wie beim verlassen der funktion.

Beispiel

int foo (void) {
    int a = 3;
	a++;
    return a;
}

int fooStatic (void) {
    static int a = 3;
	a++;
    return a;
}

int a = 3;

int fooGlobal (void) {
	a++;
    return a;
}

int main() {
	printf("%d\n",foo());
	printf("%d\n",foo());
	printf("%d\n",foo());
	printf("\n");

	printf("%d\n",fooStatic());
	printf("%d\n",fooStatic());
	printf("%d\n",fooStatic());
	printf("\n");

	printf("%d\n",fooGlobal());
	printf("%d\n",fooGlobal());
	a=200;
	printf("%d\n",fooGlobal());
	printf("\n");
}

Ausgabe

4
4
4

4
5
6

4
5
201

Don06

Ich bezog mich auf sowas:

int * foo(void)
{
    int a = 3;
    return &a;
}

Das kompiliert, liefert aber undefiniertes Verhalten. Hier ist static notwendig, wobei es dann aber nur eine interne Variable gibt.

Ohne Pointer liefert die Funktion ja eine Kopie des internen Objektes zurück.

Ausserdem wollte ich deutlich machen, dass es nicht darum geht, was schneller oder besser ist, da static-, auto- und globale Variablen unterschiedliche Einsatzgebiete haben. Sie haben in den verschidenen Funktionen andere Wirkungen.

Gruß
Don06