C++ Ein paar Fragen zu C++

[urki]

@TE: Hast du schon einmal versucht die Programme zu debuggen? Du scheinst mir auch noch generelle Verständnisprobleme beim Ablauf der Programme zu haben. Im Debugger könntest du Zeile für Zeile durchgehen und schauen was passiert. Wie ändern sich die Variablenwerte durch eine Zeile und was passiert, wenn ich in eine Funktion springe.

So wären vielleicht einige Fragen gar nicht erst aufgetaucht, dafür wahrscheinlich ein paar zum Debugger selber xD. Z.B. wäre das in deinem letzten Beispiel auch interessant. "Spieler1" wird erstellt, aber was steht jetzt in den Membervaiablen von Spieler drin? Dann würdest du sehen wie die Variabeln initialisiert werden und welcher Wert dann drin steht. Damit hättest du auch direkt gesehen welchen Effekt folgende Zeile hat:

Spieler1.Name[0] = '\0';

Die Bedeutung müsstest du dann immer noch wissen oder nachfragen. Wobei es sein kann, dass ein Debugger den Text in der Textdarstellung dort abschneidet und nur wenn man sich das Array direkt anguckt würde man sehen was dahinter steht.

 

[adeliiix]

sooo

ich habe ne frage

Spoiler

#include <iostream>

using namespace std;

// Klassen
//
class CRaumschiff
{
	private:

		// Membervariablen
		int   m_xPos;             // x-Position auf dem Bildschirm
		int   m_yPos;             // y-Position auf dem Bildschirm

	public:

		// Memberfunktionen
		CRaumschiff (int xPos, int yPos);
		void ZeigeDaten  ();

};

// Konstruktor
//
// Aufgabe: Werte initialisieren
//
CRaumschiff::CRaumschiff (int xPos, int yPos)
{
	cout << "Konstruktor wurde aufgerufen" << endl;

	// Startwerte des Raumschiffes festlegen
	m_xPos = xPos;
	m_yPos = yPos;

	cout << "Raumschiff wurde initialisiert" << endl;
} // Konstruktor

// ZeigeDaten
//
// Aufgabe: Daten des Raumschiffes anzeigen
//
void CRaumschiff::ZeigeDaten ()
{
	cout << "Koordinaten    : " << m_xPos << ", ";
	cout << m_yPos << endl;
} // ZeigeDaten

// Hauptprogramm
//
int main ()
{
	// Variablen
	//
	CRaumschiff Spieler (150, 200); // Ein Raumschiff für den Spieler

	cout << "\nSpielerraumschiff:" << endl;
	Spieler.ZeigeDaten ();

	return 0;
}

undzwar wie weiß die funktion ZeigeDaten das hier

CRaumschiff Spieler (150, 200);

die kordinaten angegeben werden?

 

[Nai]

Du erstellst damit zuerst ein Objekt mit dem Namen Spieler vom Typ der Klasse CRaumschiff: "CRaumschiff Spieler (150, 200);"

Ein jedes Objekt der Klasse hat einen eigenen Satz an Membervariablen. In diesem Fall wird für jedes Objekt vom Typ CRaumschiff abgespeichert: int m_xPos und int m_yPos. Durch den Konstruktor "CRaumschiff Spieler (150, 200);" weist du den beiden Variablen die Werte 150 und 200 zu.

Rufst du nun eine Funktion wie z.B. bei Spieler.ZeigeDaten (); auf einem Objekt auf, so weiß die aufgerufene Funktion, auf welchen Objekt sie aufgerufen wird (in diesem Fall auf dem Objekt mit dem Namen Spieler). Dadurch kann sie normal auf die Membervariablen zugreifen:

void CRaumschiff::ZeigeDaten ()
{
cout << "Koordinaten : " << m_xPos << ", ";
cout << m_yPos << endl;
} // ZeigeDaten

 

[adeliiix]

mich hat halt verwundert das der Konstructor der nur CRaumschiff heißt und dann CRaumschiff Spieler

 

[Nai]

Spieler ist eben der Name des Objekts. Der Sinn dahinter einen Objekt einen Namen zu geben ist, dass man ja meist mehrere Objekte von einer Klasse erstellen will, welche man auch unterschiedlich behandeln will.
zB:
CRaumschiff Spieler (150, 200);
CRaumschiff Gegner1(250, 300);
CRaumschiff Gegner2(300, 300);
CRaumschiff Boss(500, 500);

 

[adeliiix]

also kann ich nach dem Konstruktor CRaumschiff einen beliebigen namen schreiben?

 

[Nai]

ja kannst du, du musst halt mit dem entsprechenden Namen verwenden, wenn du etwas mit dem Objekt machen willst. z.B. um an das obige Beispiel anzuknüpfen:

Gegner1.ZeigeDaten (); // gibt 250 und 300 aus
Boss.ZeigeDaten (); // gibt 500 und 500 aus

 

[adeliiix]

ok danke

 

[daemon777]

Eine Klasse ist ein Datentyp (hier CRaumschiff). Von einem Datentyp kannst du dann Instanzen anlegen und die kannst du bennen, wie du willst.

Bisher hast du das auch schon öfter gemacht. Schau dir zum Beispiel nochmal den Integer-Datentyp an. Da haben wir auch immer wieder Instanzen angelegt und diese beliebig benannt und benutzt. Wie dieser Datentyp intern aufgebaut ist war uns hierbei total egal.
Das Einzige was mir wissen müssen ist, welche Operatoren ich anwenden kann (so etwas wie + oder -) und welche Methoden das Teil besitzt (so etwas wie Spieler.ZeigeDaten() ).

 

[urki]

Ich denke immer noch, dass du so ein Programm mal debuggen solltest .
Schau dir mal die Grafik an. Du kannst Breakpoints setzen, an denen das Programm anhält. In der Grafik erkennst du den Breakpoint an dem roten Punkte neben Zeile 54. Normalerweise kannst du dir dann ein Fenster aufmachen in dem du die Variablenwerte anschauen kannst (in der Grafik rechts). Du kannst nun Zeile für Zeile durch dein Programm gehen oder an anderen stellen wieder Breakpoints setzen um dort wieder anhalten zu können. Ich bin z.b. eine Zeile weiter (in den meisten Anwendungen wohl F10) gegangen und stehe zum Zeitpunkt des Screeenshots auf Zeile 56 (gelber Pfeil). Dadurch siehst du auch, dass die beiden Integer Werte 150 bzw 200 belegt sind. Das waren sie zum Zeitpunkt des Breakpointes noch nicht. Die veränderungen werden hier auch noch Rot hervorgehoben.

In dem Variablenfenster siehst du außerdem den Typ der Variablen. Du hast eine Variable Spieler vom Typ CRaumschiff. Diese Variable/Objekt enthält 2 Membervariablen vom Typ Int. Sie gehören zu diesem Objekt, weshalb diese auch leicht eingerückt sind.

Desweiteren kannst du z.B. auch in eine Funktion reinspringen (in den meisten Programmen wohl F11). Also z.B. wenn du in Zeile 57 bist und dann sagst, dass du in die Funktion reinspringen willst, landest du in Zeile 44. Jetzt wärst du in einer Funktion die zu einer Klasse gehört. Im Variablenfenster würdest du nun eine Variable namens "this" finden. Diese Variable ist vom Typ CRaumschiff und zeigt auf das Objekt in dem du dich gerade befindest. Du wirst hier dann ebenfalls deine 2 Membervariablen vom Typ Int finden. Wenn bei der Funktion noch Werte übergeben werden, würdest du diese ebenfalls im Variablenfenster sehen.

Somit kannst du auch ein wenig am Programm verändern und dann direkt sehen welche Auswirkungen das hat. Am Anfang hab ich den Debugger auch gemieden und immer einfach Debug Ausgaben gemacht, aber zusätzlich zu einem Buch kann er imho gut zum Verständnis eines Programmes helfen. Der Debugger ist nicht so schwer. Einfach mal ausprobieren und du wirst sehen, dass es ganz einfach ist. Die beschriebenen Mittel reichen für dich zum Debuggen auch erstmal aus. Der kann noch mehr, aber das ist für dich und diese kleinen Programme erstmal nicht interessant.

 

[adeliiix]

wie machei ch das denn beim vs express?
oder ist das ein eigenes programm?

 

[asdfman]

Der Debugger ist in die IDE integriert. Wenn er bei der Express-Edition fehlt: Microsoft bietet billige Visual Studio Lizenzen für Schüler und andere manipulierbare Personenkreise zum früh anfixen an.

 

[powerfx]

Im Grunde fehlen den Express-Editionen Werkzeuge zur Team-Arbeit (etwa Versionsverwaltung etc.) und tatsächlich auch Remote-Debugging, also alles, was "Enterprise" ist. Der normale, lokale Debugger ist aber natürlich vorhanden.

 

[urki]

Ich glaube die Express ist auch bei den Erweiterungen irgendwie beschränkt, aber der Debugger ist auf jeden Fall mit dabei.

Tutorialvideo

Das Video habe ich nur überflogen, aber dort scheint das Grundlegende erklärt zu werden. Guck einfach selber mal was du davon gebrauchen kannst. Es ist auch auf Englisch, allerdings wirst du sicherlich auch welche auf Deutsch finden, wenn du mal suchst.

Nur nochmal als kleine Hinweise: Wie schon beschrieben setzt du einfach irgendwo einen Haltepunkt/Breakpoint (shortcut: F9) im Editor. Das siehst du dann an dem roten Punkte neben der Zeile. Wenn das Programm zu dieser Stelle kommt hält es an und du kannst dir die Variablen, die Aufrufliste usw. angucken. Entweder in einem Extra Fenster oder in dem du mit der Maus z.B. über eine Variable fährst, dann kommt ein Tooltip. Während des Debuggings verändert sich auch die Oberfläche von Visual Studio. Falls dir Fenster fehlen wirst du sie im Menu unter Ansicht oder Debug finden und einblenden können.
Das Programm solltest du in der Debug Version übersetzen. Wenn es übersetzt ist kannst du das Debugging mit F5 oder "Debug->Start Debugging" starten und das Programm läuft bis zu deinem ersten Haltepunkt und pausiert bis du es mit F5 weiterlaufen lässt, mit F10 eine Zeile weiter gehst oder mit F11 in eine Funktion oder ähnliches springst.

 

[adeliiix]

Das Programm solltest du in der Debug Version übersetzen.

wie mache ich das?
also den breakpoint habe ich gesetzt und dann debugging starten geklickt.
aber irgendiwe passiert nichts auser vs einbischen rot geworden ist an manchen stellen und wenn ich wieder auf debbugging klicke steht das weiter, stop etc

 

[asdfman]

http://msdn.microsoft.com/de-de/library/sc65sadd.aspx

 

[urki]

In dem Video von meinem letzten Post siehst du wo du die Konfiguration direkt über die Toolbar auf Debug stellen kannst Bei ca 2:15 ist er mit der Maus drüber. Möglicherweise steht da bei dir sogar Release drin. Alternativ findest du das auch alles in dem Link den dir asdfman geschrieben hat. Genauer sogar hier:

http://msdn.microsoft.com/de-de/library/tdb6bs3y.aspx

Dort steht das unter: "So richten Sie eine Debugkonfiguration manuell ein".

Hier auch gleich nochmal ein etwas direkterer Link wo erklärt wird wie man debugged:

http://msdn.microsoft.com/de-de/library/y740d9d3.aspx

Es könnte aber sein das du schon mehr oder weniger erfolgreich beim Debuggen warst. Es hört sich zumindest so an, dass du das Programm erfolgreich übersetzen konntest. Danach bin ich mit nicht sicher ob ich dich richtig verstanden habe.

aber irgendiwe passiert nichts auser vs einbischen rot geworden ist an manchen stellen und wenn ich wieder auf debbugging klicke steht das weiter, stop etc

Wenn das "weiter" nicht ausgegraut ist und du drauf klicken kannst, dann hat er an deinem Breakpoint angehalten. Das würdest du unter anderem an dem gelben Pfeil neben der Zeile sehen. Wenn du dann mal F10 drückst sollte der Pfeil jeweils eine Zeile (zur nächsten ausführbaren Zeile) weiter springen. Dann kannst du schon wie beschrieben dir Variablenwerte angucken.

 

[adeliiix]

http://msdn.microsoft.com/de-de/library/tdb6bs3y.aspx
hier ist das Problem, dass das doch nur für win-32 Projekte gilt?
bis jetzt habe ich immer konsolenanwendungen gemacht

Ergänzung (1. Februar 2014)

ich habe einen breakpoint gesetzt und dann bei debugging auf debugging starten geklickt.

hier wird abern ichts angezeigt...
oder startet man das debugging anders?

 

[asdfman]

Eine Konsolenanwendung IST eine Win32-Anwendung. Wenn du kein .NET-Framework benutzt, wird jede Anwendung im Win32-Subsystem ausgeführt. Es gibt Ausnahmen, aber wenn so eine zuträfe, wüsstest du es DEFINITIV.

€: Deine Anwendung wird an der Stelle angehalten, wo der Breakpoint ist. Wenn du vorher noch nichts ausgibst, dann landet natürlich auch nichts im fenster. Single-steppe durch dein Programm, bis du an ein cout kommst. DANN kommt etwas an der Konsole raus.

Junge, Junge. Sind wir hier dein persönlicher Erklärbär für alles? Ein minimum an selbststudium tut wirklich not bei dir.

 

[adeliiix]

ja ich habe den breakpoint auhc einfmal am ende ausgegenen und auch dort war das fenster lehr..

Edit:
habs jz hinbekommen