C++ Ein paar Fragen zu C++

[adeliiix]

was ist der unterschied zwischen überladenen Funktionen/konstruktoren und nicht überladenen?

 

[Tumbleweed]

Das sagt dir Google, sogar wenn du mit deutschen Suchbegriffen arbeitest. Wenn du daran etwas nicht verstehst, kannst du dich ja nochmal melden.

 

[adeliiix]

also man überläd funktionen indem man den datentyp ändert oder bei der 2. funktion eine parameter typen mehr anhängt?

 

[Tumbleweed]

Gleicher Name, unterschiedliche Parameterliste. Niemals zwei Varianten mit gleicher Signatur in einer Klasse.

 

[adeliiix]

ich habe mir das Kapitel zu speicherresservierung jetzt 2mal durchgelesen und verstehe immern och nicht was in diesem Beispiele z.B.
new macht.

Spoiler

#include <iostream>

using namespace std;

// Hauptprogramm
//
int main ()
{
	// Variablen
	//
	int *pEnergie = NULL;

	// Speicher auf dem Heap reservieren
	pEnergie = new int;

	// Wertzuweisung
	*pEnergie = 1500;

	// Ausgabe des Wertes mittels Dereferenzierung
	cout << *pEnergie << endl;

	// Speicher wieder freigeben
	delete pEnergie;
	pEnergie = NULL;

	return 0;
}

 

[urki]

Wenn du eine Variable einfach mit

int i;

anlegst wird der Speicher für diese Variable automatisch auf dem Stack reserviert. Wenn du den Gültigkeitsbereich wieder verlässt wird der Speicher auch automatisch wieder frei gegeben. Mit new reservierst du den Speicher auf dem Heap und musst dich selber um die Speicherverwaltung kümmern. Mit new holst du ihn dir, mit delete gibst du ihn wieder frei. Wenn du das nicht machst, hast du ein Speicherleck.
Z.B.:

{
  // irgendein code
  {
    int a=0;
    int *b=new int(1);
  }
  // a wurde wieder freigegeben, b nicht.
}

Vielleicht nochmal als Hinweis: Eine Variable, die du mit * erzeugst ist ein Zeiger. Diese Variable zeigt praktisch auf einen Speicherbereich und weiß durch ihren Typ, wie groß dieser bereich ist. new reserviert diesen Speicher und gibt dir die Speicheradresse zurück, die dann in der Variablen gespeichert wird. Wenn du also einen Wert setzen willst benutze wie im Beispiel gezeigt den Dereferenzierungsoperator, sonst änderst du nur die Speicheradresse und da kann dann sonst was drin stehen. Das NULL bzw. 0 wird verwendet um zu kennzeichnen, dass für diese Variable noch kein Speicher reserviert wurde.

Ansonsten gilt das, was dir schon mehrfach gesagt wurde: Sag genau was du an dem Beispiel nicht verstanden hast. Versuche vielleicht sogar mit eigenen Worten wiederzugeben, was du verstanden hast und dann dein Problem zu schildern. Dadurch merkt man meistens schon wo deine Probleme liegen. Denn was dort gemacht wird ist auch im Beispiel schon dokumentiert. Ich kann auch nur raten, was du daran jetzt nicht verstanden hast.

 

[adeliiix]

ok danke schonmal aber irgendwie verstehe ich nicht wofür das ist:

 int a=0;
int *b=new int(1);

wofür steht die 1 in der 2. zeile?

    #include <iostream>
     
    using namespace std;
     
    // Hauptprogramm
    //
    int main ()
    {
    // Variablen
    //
    int *pEnergie = NULL;
     
    // Speicher auf dem Heap reservieren
    pEnergie = new int;
     
    // Wertzuweisung
    *pEnergie = 1500;
     
    // Ausgabe des Wertes mittels Dereferenzierung
    cout << *pEnergie << endl;
     
    // Speicher wieder freigeben
    delete pEnergie;
    pEnergie = NULL;
     
    return 0;
    }

Hier: int *pEnergie = NULL; wird der speicher von der Variabeln Energie auf 0 gesetzt?
pEnergie = new int; was wird hier reserviert? für die Variabel Energie alle int werte?
*pEnergie = 1500; hier wird der Variablen Energy der Wert 1500 zugewiesen?
delete pEnergie;
pEnergie = NULL; Wozu wird hier dann wieder die Variabel Engerie auf 0 gesetzt?

 

[ice-breaker]

Ließ dich in Zeiger/Pointer in C(++) ein, dazu gehört die Speicherverwaltung und das ganze ist die komplexeste Geschichte an C(++) - weshalb es eben Sprachen gibt, die darauf verzichten, um es dem Entwickler zu erleichtern.
Das ganze dir hier zu erklären benötigt Unmengen Zeit, die vermutlich niemand haben wird.

Und: NULL != 0

 

[adeliiix]

ich habe ja das Kapitel zeiger gelesen und eigentlich auch verstanden...
und ebend weil es schwer ist haben ich halt Probleme damit

 

[antred]

Und: NULL != 0

In C++ ist NULL sehr wohl exakt das gleiche wie 0. In C wäre dein Einwand berechtigt.

P.S. In C++11 empfiehlt sich aber ohnehin eher der Einsatz von nullptr.

 

[ice-breaker]

ich habe ja das Kapitel zeiger gelesen und eigentlich auch verstanden...
und ebend weil es schwer ist haben ich halt Probleme damit

mag jemand vllt ihm mal ne gute Einleitung dazu im Netz verlinken?

In C++ ist NULL sehr wohl exakt das gleiche wie 0. In C wäre dein Einwand berechtigt.

Sry, wusste ich nicht. Habe nur mit C gearbeitet, C++ ist auf vielen Embedded-Plattformen praktisch nicht vorhanden. Das heisst ich kann auch NULL + 42 rechnen? oO

 

[antred]

Sry, wusste ich nicht. Habe nur mit C gearbeitet, C++ ist auf vielen Embedded-Plattformen praktisch nicht vorhanden.

Stimmt leider, aber auf einigen schon. In meinem alten Projekt wurde Firmware-Code für Inverter (ARM und MIPS-Prozessoren) überwiegend in C++ geschrieben.

Das heisst ich kann auch NULL + 42 rechnen? oO

Ja. Aber in C++11 wurde die nullptr-Konstante eingeführt, mit der solcher Schabernack nicht mehr möglich ist.

 

[urki]

mag jemand vllt ihm mal ne gute Einleitung dazu im Netz verlinken?

Tja , ich hab mal fix gesucht. Auf deutsch hab ich nicht so viel gefunden was mir gefallen hat oder wirklich verständlich war. Das hier ist sehr kurz und auch nicht soooo prall, aber dort ist etwas veranschaulicht was im Speicher abläuft ...

http://www.c-howto.de/tutorial-zeiger.html

Ansonsten z.B. hier auf englisch:

http://www.cplusplus.com/doc/tutorial/pointers/

wofür steht die 1 in der 2. zeile?

Naja, das initialisiert die Variable gleich mit einem Wert. Das ist das gleiche wie:

int *b = new int;
*b = 1;

Hier: int *pEnergie = NULL; wird der speicher von der Variabeln Energie auf 0 gesetzt?

Um es mit den Worten aus der Feuerzangenbowle zu sagen: "Da stelle mer uns janz dumm. Und da sage mer so: En Zeiger, dat is ene Zahl ähnlich wie ein Int und diese Zahl gibt an wo im Speicher meine Variable steht. Und wie groß die Zahl sein kann, 32-bit bla, dat krieje mer später." Der Speicher ist in Adressen unterteilt, ganz Abstrakt gesehen kannst du dir das vielleicht wie eine Hausnummer vorstellen. So ein Zeiger speichert dann genau so eine Speicheradresse/Hausnummer. Im obigen Fall 0. 0 ist toll, weil wir damit wissen das die Variable praktisch noch nicht benutzt wird. Wenn du nicht 0 zuweise würdest, dann würde die Variable zufällig initialisiert, ähnlich wie ein Integer. Also hätte sie eine zufällige Speicheradresse gespeichert, du weißt aber nicht was dort steht und wenn du dann darauf zugreifen willst kann das böse enden.

pEnergie = new int; was wird hier reserviert? für die Variabel Energie alle int werte?

Mit dem Keyword "new" reservierst du dir Speicher. Wieviel hängt vom typ ab. In diesem Fall die größe vom typ int, was auf einem 32-bit System 4byte sind. Wenn du eine eigenen Klasse geschrieben hast und für die mit new Speicher reservierst können das auch 42byte sein. Wie auch immer. Das new gibt dir die oben beschriebene Speicheradresse zurück, wo dein Speicher anfängt. Somit hast du nun in der pEnergie nicht mehr 0 drin stehen sondern irgendeine Speicheradresse. Da steht aber nur drin wo dein Speicher anfängt, wo er endet weißt du über den typ.

*pEnergie = 1500; hier wird der Variablen Energy der Wert 1500 zugewiesen?

Genauer gesagt schreibst du den Integer Wert 1500 an die Stelle des Speichers auf die pEnergie zeigt. Das erreichst du durch den Dereferenzierungsoperator "*". Ohne den "*" hättest du die Adresse des Zeigers geändert und wüsstest du wieder nicht und das ist wieder sehr gefährlich .

delete pEnergie;

Hiermit gibst du den Speicher wieder frei. Wenn du das vergisst und über so eine Stelle immer wieder drüber kommst holt sich dein Programm im Laufe der Zeit immer mehr Speicher ohne ihn wieder frei zu geben. Das kann nur unschön sein und lange unbemerkt bleiben, aber auch zum Absturz führen. Also IMMER den Speicher wieder frei geben.

pEnergie = NULL; Wozu wird hier dann wieder die Variabel Engerie auf 0 gesetzt?

In deinem Beispiel ist das völlig egal. Aber wie oben schon einmal erwähnt kann dir das anzeigen ob du die Variable benutzt. Ach ganz nebenbei, versuche nie auf einen Zeiger zuzugreifen der 0 ist. Instant Programmabsturz.

pEnergie = NULL;
int foo = *pEnergie; // Schuss ins Knie

if (pEnergie==NULL) {
  pEnergie = new int(1);
}

int foo = *pEnergie; // Jetzt würde es gehen.

Zeiger kannst du auch natürlich auch verwenden ohne das du dir den Speicher selber holst und wieder frei gibst. Z.B.:

int kinetischeEnergie = 1;

int *pEnergie = NULL;

pEnergie = &kinetischeEnergie; // Hier wird pEnergie die Speicheradresse von kinetischeEnergie zugewiesen (mit dem &). Dort steht die 1, also hätte *pEnergie auch die 1. Du hast dir keinen Speicher manuell geholt, also musst du auch keinen wieder frei geben.

kinetischeEnergie = 42; // Da pEnergie auf die gleiche Speicheradresse zeigt ist nun auch *pEnergie == 42

int bla = *pEnergie; // bla wird der Wert 42 zugewiesen.

*hust* Im Debugger siehst du bei Zeigern auch die Speicheradresse zusätzlich zum Wert. Einfach mal ein wenig ausprobieren und vielleicht auch mal ein paar Beispiele debuggen und ganz genau drauf achten, was sich ändert . Eigentlich ist das alles nicht so schwer.

 

[adeliiix]

Im letzten Bespiel ist:
wenn da *pEnergie = 42 ist
wäre eine variable die ich Energie nennen würde auch 42 oder?

if (pEnergie==NULL) 
{
pEnergie = new int(1);
}

was heißt die 1 in den klammern?

Das beispiel heißt:
wenn pEnergie gleich 0 ist, ist wird für pEnergie 1 platz gespeichert?

 

[Nai]

nein.
Das heißt, wenn pEnergie der Nullzeiger ist ("if (pEnergie==NULL)" ), so wird auf dem Heap ein Integer ("new int") alloziert. Zudem wird der eben neu allozierte Integer per Konstruktor auf 1 gesetzt ("int(1)") und der Wert des Zeigers wird auf die Addresse des neu allozierten Integers gesetzt ( pEnergie = . . . .);

 

[adeliiix]

mal eine andere frage.
Ich wolte mal etwas testen aber immer wenn ich das Programm mit strg f5 ausführen möchte kommt dieser fehler:


Wenn ich code beispiele aus meinem buch einfüge geht es.
Habe ich irgendwas falsch gemacht?

 

[asdfman]

Habe ich irgendwas falsch gemacht?

Ja. Dein Debugger hilft dir, herauszufinden, was.

 

[Nai]

Könnte daran liegen, dass du PEnergie mit * beim cout dereferenzierst, obwohl er NULL ist.
Lösung:
pEnergie = new int(1);
Was mich etwas überrascht ist , dass der Debugger dabei nicht herumjammert, sondern du eine Windowsfehlermeldung bekommst.

 

[adeliiix]

liegt es vlt auch daran das ich return 0; vergessen habe? ist mir gerade noch eingefallen

 

[antred]

Was mich etwas überrascht ist , dass der Debugger dabei nicht herumjammert, sondern du eine Windowsfehlermeldung bekommst.

Strg + F5 führt das Programm ohne Debuggerunterstützung aus.