und wieso wird bei diesem beispiel die variable b erhöht und nicht jedesmal auf 5 gesetzt:

#include <iostream>
using namespace std;
void func1() {
  static int i = 0;
  cout << ++i << " ";
}
int main() {
  for(int x = 0; x < 10; x++)
  func1();
}

danke

static Variablen hören, wenn du sie in einem Anweisungsblock deklarierst,
nicht wie "normale" Variblen auf zu existieren, sondern bleiben
weiter im Speicher.

Mal an deinem Beispiel:

#include <iostream>
using namespace std;
void func1() {
  static int i = 0;
  cout << ++i << " ";
  // i lebt weiter
}
int main() {
  for(int x = 0; x < 10; x++)
  func1();
}

Hättest du folgenden Code:

#include <iostream>
using namespace std;
void func1() {
  int i = 0;
  cout << ++i << " ";
  // i würde hier sterben
}
int main() {
  for(int x = 0; x < 10; x++)
  func1();
}

Wie du dazu kommst das i auf 5 gesetzt wird ist mir Schleierhaft,
bei mir geht i von 1 - 10.

Gruß,

Max

int j = 3;
void func1() {
  static int i = 0;
  cout << ++i << " ";
} // hier endet der Sichtbarkeitsbereich

int main()
{
   cout << i << endl; // geht hier nicht, da der Sichtbarkeitsbereich von i verlassen wurde.
   cout << j << endl; // globale Variable, Sichtbarkeit noch vorhanden
}

Das heisst, i lebt erst weiter, wenn die Funktion func1 erneut aufgerufen wird (in deinem Beispiel wird es jedoch gerade wieder mit 0 überschrieben).

Folgender Kontext könnte ein Beispiel für eine static-Anwendung sein (ist zwar ein bisschen gekünstelt, soll aber nur das Prinzip aufzeigen)

void func1(bool blub) {
  static int i;
  if (blub) i = 0;
  cout << ++i << " ";
}

int main()
{
    func1(true);
  for (short a = 0; a < 4; ++a)
    func1(false);
    func1(true);
    func1(false);
}

Bei blub == true würde die Variable i immer wieder auf 0 gesetzt, sonst wird sie weitergezählt. Das ergäbe folgende Ausgabe:
1
2
3
4
5
1
2

Ausserdem kann das Schlüsselwort static bei Klassen vorkommen, wenn es möglich sein soll, dass auf eine Klassenvariable ohne Objekt zugegriffen wird (aber ich denke nicht, dass du dies gemeint hast - nur so nebenbei).

Also, soweit ich weiß ist es ja so:

int main()
{
   // Anweisungsblock
   int i = 5;
   // neuer Anweisungsblock
   {
      int i = 10;
      cout << i << endl; // i = 10 ABER! die Variable i wird nur von
      // der anderen "überdeckt"
   } // hier stirb das "innere" i
   cout << i << endl; // das "äußere" i lebt noch, i = 5
}

Wie siehts bei static Variablen aus?

void func1() {
  static int i = 0;
  cout << ++i << " ";
}

Das

int i=0;

wird beim zweiten Aufruf der Funktion übersprungen.

Was deine Frage angeht: Ich hab deinen Code ausprobiert, die Ausgabe ist in allen 4 möglichen Fällen (innen static, aussen nicht; innen static, aussen auch; etc.)
10
5

Die innere Deklaration (egal ob static oder nicht) hat innen immer Vorrang, genauso wie diese ausserhalb des Blockes nicht mehr sichtbar ist (deshalb ist die Ausgabe aussen immer 5). Das heisst, die beiden Variabeln arbeiten jeweils in ihrem Sichtbarkeitsbereich für sich, also unabhängig vom anderen i, halt wie bei normalen Variabeln. Eben mit dem Unterschied, dass static-Variabeln "weiterleben".

Edit2: Verdammt, immer zu spät, ausserdem viel zu viel Text, um wenig zu sagen

was mich irritiert hat, war, dass jedesmal beim fkt aufruf static int I=0 gesetzt wurde. aber sow ie ich es jetzt verstanden habe, wird diese nur einmal initialisiert bei static und lebt dann weiter, wobei die definition bei jedem fkt aufruf übersprungen wird.
muss man erstmal wissen sowas.

@nexus: auf was beziehst du dich mit den 4 varianten?

er bezieht sich auf meinen Code:

int main()
{
   // Anweisungsblock
   int i = 5;
   // neuer Anweisungsblock
   {
      int i = 10;
      cout << i << endl; // i = 10 ABER! die Variable i wird nur von
      // der anderen "überdeckt"
   } // hier stirb das "innere" i
   cout << i << endl; // das "äußere" i lebt noch, i = 5
}

und meint diese Varianten (gekürzt)

// außen static
int main()
{
   static int i = 5;
   {
      int i = 10;
   }
}

// beides static
int main()
{
   static int i = 5;
   {
      static int i = 10;
   }
}

// innen static
int main()
{
   int i = 5;
   {
      static int i = 10;
   }
}

// kein static
int main()
{
   int i = 5;
   {
      int i = 10;
   }
}

kommt immer aufs gleiche raus.

mhh

mal ne andere frage wenns erlaubt ist:

while(i<5){
int *p=new int;
p=&i;
i++;
cout << *p;
}

?

hier benutze ich jedesmal den zeiger p um auf dem heap neuen platz zu reservieren.
wieso klappt das nicht wenn ich es so schreibe?

int main(){
int *p=new int(123);
int *p=new int(321);
return 0;
}

oben wird er doch auch mehrfach benutzt

int *p=new int(123); 
 *p=321;
 std::cout<<*p<<std::endl;

Ausgabe: 321

p=&i;

Dies verhält sich wie normale, nicht dynamisch definierte Datentypen:

int i = 0;
int i = 3;

wird nicht funktionieren wegen doppelter Deklaration (Variable i besteht bereits).

int i = 0;
i = 3;

geht. Hier wird i nur ein Mal deklariert.

ich habe den typ und den namen der variablen, sehe da keinen unterschied. das muss doch was mit der while schleife zu tun haben oder?

naja hab hier noch eine andere frage:

was bewirkt das const bei dem parameter:

Ratio& Ratio::plusGleich(const Ratio &x)

[cpp]

while(i<5)
{    // Block beginnt bei jedem Durchgang neu; *p noch undeklariert
  int *p=new int;
  // ab hier ist *p deklariert
  // ...
}    // Block ist hier beendet, Sichtbarkeit auf *p geht verloren.

Das const bewirkt, dass der Parameter, der als Referenz übergeben wird (&x), konstant übergeben wird. Das bedeutet, er kann von der Funktion nicht verändert werden. Im Gegensatz zu einer Wertübergabe, bei der der Parameter auch nicht verändert werden kann, bringt eine Referenzübergabe oft Performancevorteile, da die Variable so nicht kopiert, sondern nur auf sie verwiesen wird.

Ich hoffe, ich habe mich einigermassen klar ausgedrückt, sonst einfach nachfragen

wenn der wert eh nicht verändert werden kann, dann hätte ich doch direkt eine wertübergabe machen können und bräuchte keine referenz, wie du es sagst. da war mir gerade die logik nicht klar...

achja da fällt mir ein:

int const i=3;
const int i=3;

wo ist der unterschied wenn es einen gibt?

Übrigens, bin da jetzt auch nicht so der Profi
auf dem Zeigergebiet, aber sollte man nicht eigentlich
Speicher den man mit new angefordert hat auch wieder
mit free freigeben? Oder wird auch der Speicher wenn der
Zeiger stirbt wieder freigegeben?
Ich kenns nur von C

while(i<5)
{  int *p=new int;
   // ...
   delete p;
}

Wie blub² bereits sagte, ist const int i mit int const i identisch. const int i ist allerdings die gebräuchlichere Schreibweise.

Beim Beenden des Programms (v.a. nach längerer Laufzeit) ist der Computer dann langsamer.

Beim Beenden des Programms sind alle Memory Leaks hinfällig. Das Betrienssystem kratzt das nicht die Bohne. Übrigens, einen einzelnen "int" mit new anzulegen ist wohl arg übertrieben, aber sollte bestimmt nur ein Beispiel sein.

gruß

Nexus schrieb:

Beim Beenden des Programms (v.a. nach längerer Laufzeit) ist der Computer dann langsamer.

Beim Beenden des Programms sind alle Memory Leaks hinfällig. Das Betrienssystem kratzt das nicht die Bohne. [...]

Da bin ich aber anderer Meinung, zumal der Arbeitspeicher auch Zeit braucht, bis er aufgeräumt ist. Ich hab mal ein kleines Spiel programmiert, da konnte man nach dem Beenden eine Minute lang warten, bis man den Computer wieder benutzen konnte. Nachdem ich überall delete und SDL_FreeSurface (eine Grafikfunktion, die einen Zeiger freigibt, also wie delete) hinzugefügt hatte, war das Problem beseitigt.
Wenn du es nicht glaubst, mach doch mal eine Schleife, die in jedem Durchgang Speicher alloziert und sehr viele Durchgänge hat (halt soviele bis es dein PC nicht mehr verkraftet :D).

Warum geht eigentlich folgendes nicht? Nur wegen dem Variabelnnamen? Der Speicher ist ja eigentlich freigegeben...

int *p = new int(4);
delete p;
int *p = new int(2); // oder anderer Datentyp

int *p = new int(4);
delete p;
p = new int(2);
//...
delete p;

nicht zweimal im selben scope eine variable mit demselben namen definieren.

So funktionierts nämlich nicht:

int *p = new int(4);
delete p;
int *p = new float(2.5f);