static variablen

wanderameise

ja aber am anfang der while schleife wird es doch auch jedesmal 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]

Nexus

Der Unterschied ist, dass die While-Schleife einen Block impliziert - das ist alles innerhalb der Klammern {} - und der Sichtbarkeitsbereich am Ende des Blockes (d.h. mit der schliessenden Klammer }) verloren geht. Somit ist bei einem neuen Schleifendurchgang die Variable *p noch undeklariert, wodurch eine Deklaration erlaubt ist.

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

wanderameise

jup habe es verstanden, danke sehr.

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?

blub* 0

Soweit ich weiß keiner.

Ü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

Nexus

Genau, hab ich vergessen zu schreiben:
Den Speicher für Variabeln, die du dynamisch (das heisst mit new) deklarierst, solltest du wieder mit delete freigeben, da ansonsten der Speicherplatz nicht mehr genutzt werden kann, was bei Schleifen allmählich den Arbeitsspeicher füllt. Beim Beenden des Programms (v.a. nach längerer Laufzeit) ist der Computer dann langsamer.

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.

funky cat

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. Übrigens, einen einzelnen "int" mit new anzulegen ist wohl arg übertrieben, aber sollte bestimmt nur ein Beispiel sein.

danke jungs,ihr habt mir sehr geholfen!!

gruß

Nexus

funky cat schrieb:

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).

funky cat

Natürlich braucht es Zeit, aber der Effekt ist der Gleiche wenn du unheimlich viel Speicher allozierst und dann auf einen Schlag freigibst.

Nexus

Genau.

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

queer_boy

ja. korrekt wäre es so:

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

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

Nexus

Ist es auch möglich, einem Variabelnnamen verschiedene Typen im gleichen Scope zuzuordnen (darauf hat sich auch mein "// oder anderer Datentyp" im letzten Beitrag bezogen)?

So funktionierts nämlich nicht:

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

drakon

Nein, das verletzt die ODR ebenfalls. Egal, welchen Datentypen du angibst. Ein Name darf in dem gleichen Scope nur 1 mal definiert werden.

funky cat

Nexus schrieb:

So funktionierts nämlich nicht:
int *p = new int(4);
delete p;
int *p = new float(2.5f);

Nein, weil p schon definiert ist. Warum machst du es nicht so?

int *p = new int(4);
// ... Mach was mit p
delete p;
// Neues p anlegen
p = (int*)new float(2.5f);