C++ Ein paar Fragen zu C++

[adeliiix]

Moin

Ich habe mit Programmieren angefangen und mir dazu dieses buch gekauft:
http://www.amazon.de/C-f%C3%BCr-Spieleprogrammierer-Heiko-Kalista/dp/3446432167/ref=sr_1_1?ie=UTF8&qid=1389022026&sr=8-1&keywords=c%2B%2B+f%C3%BCr+spieleprogrammierer

Jetzt habe ich eine Frage:
Da war nun dieses Bespiel:

#include <iostream>

using namespace std;

int addProzent (int Wert, int Prozent);
float addProzent (float Wert, int Prozent);

// Hauptprogramm
//
int main ()
{
// Variablen
//
int Staerke;
float Geschwindigkeit;
int Steigerung;

// Abfrage der Werte
cout << "Bisherige Staerke des Charakters: ";
cin >> Staerke;

cout << "Bisherige Geschwindigkeit des Charakters: ";
cin >> Geschwindigkeit;

cout << "Steigerung in Prozent: ";
cin >> Steigerung;

// Neue Werte berechnen
Staerke = addProzent (Staerke, Steigerung);
Geschwindigkeit = addProzent (Geschwindigkeit, Steigerung);

// Ausgabe der neuen Werte
cout << "\nNeue Charakterwerte: " << endl;
cout << "Staerke: " << Staerke << endl;
cout << "Geschwindigkeit: " << Geschwindigkeit << endl;

return 0;
}

// addProzent (für Integer-Werte)
//
int addProzent (int Wert, int Prozent)
{
int neuerWert;
neuerWert = Wert + (Wert*Prozent)/100;
return neuerWert;
}

// addProzent (für float-Werte)
//
float addProzent (float Wert, int Prozent)
{
float neuerWert;
neuerWert = Wert + (Wert*Prozent)/100.0f;
return neuerWert;
}

Also meine erste frage ist nicht mit dem Bespiel verbunden:
wann schriebt man void, int, float etc vor eine Funktion?

Wie erkennt der Compiler bei diesem Beispiel das unten bei
int addProzent (int Wert, int Prozent)
{
int neuerWert;
neuerWert = Wert + (Wert*Prozent)/100;
return neuerWert;
}
dem teil die Stärke ausgerechnet wird?
und was ist mit return neuerWert gemeint? also was sagt man dem Compiler damit?

MfG

 

[powerfx]

Wenn deine Fragen nicht im Buch beantwortet werden, scheint es kein gutes zu sein.
Vor der Funktion steht der Rückgabetyp. "neuerWert" ist der Rückgabewert (eben vom Rückgabetyp, hier "int").

Wenn du

 benutzt, ist der Quelltext leichter zu lesen:
[CODE]#include <stdio.h>
#include <stdlib.h>
 
int main(void)
{
    printf("Hallo Welt!\n");
    return EXIT_SUCCESS;
} /* end main() */

 

[Sev7eNup]

Sorry, aber wenn du dir das Buch gekauft hast, solltest du damit alle von dir gestellten Fragen beantworten können.

Ein paar Tipps.

"return" gibt immer einen Wert zurück, z.B. von einer Funktion
"void" vor einer Funktion beschreibt z.B. dass die Funktion keinen Rückgabewert hat
"int" ist ein Datentyp für eine Variable, der mit Zahlen agiert.

 

[adeliiix]

ja das wird da ja erklärt nur ebend verstehe ich es da nicht
und das mit code habe ich gesucht danke

 

[Aliosy]

vor dem Funktionsnamen steht immer der Rückgabetyp. Bei VOID erfolgt kein Resultat, ansonsten je nachdem was definiert wurde FLOAT, INT, etc. Bei RETURN Anweisung wird meist der Wert auf Stack gepusht (PUSH Anweisung) bzw. über CPU Register abwickelt, das unterscheidet Compiler automatisch und je nach Optimierungsgrad.
Anhand vom Beispiel siehst du das eine Variable int neuerWert; definiert wurde und in dieser der berechnete Wert zugewiesen wird. Anschließend wird der Inhalt in Stack geschrieben und Funktion verlassen. Der Aufrufer bekommt über Stack den Wert zurück geliefert d.h. es wird vom Stack gepopt (POP Anweisung). Der aufgestapelte Stack wird wieder abgebaut.

 

[Hancock]

@Aliosy: Warum erwähnst du nicht SSE und den FP-Stack auch noch?

In deinen Programmen verwendest du bspw. die Funktion sin (Sinusfunktion).

Du nutzt sie so

minuseins=sin(0.5*PI)*-1;

"sin nimmt eine Zahl und da kommt ne Zahl raus"

Allgemein kannst du auch andere Funktionen deklarieren und definieren (z.B. double div(numerator,denominator)
Die sin Funktion sieht bspw. so aus

double sin(double x);//Deklaration, noch ist nicht klar, wie es funktioniert, aber du kannst die Funktion schon verwenden

double sin(double x){//Definition, jetzt musst du sagen, was du eigentlich machst
double erg;
erg=x-1/6.0*x*x*x;//Taylorentwicklung
return erg;//Das kommt beim Sinus raus (Näherungsweise)
}

Wenn eine Funktion definierst, wird sie auch gleich deklariert (Deklaration ist optional). Die Funktion darf beliebig komplex sein (sie darf sogar sich selbst aufrufen).

 

[asdfman]

Du bist ja echt ein Held. Der kommt her, weil er nicht versteht, wofür return da ist und du kommst mit Stack und POP und so. Na großartige Leistung, damit sollte ja für ihn alles klar sein!

Das ist in etwa so, als wenn dich einer fragt, was die Feuerwehr macht und du fängst an mit Thermodynamik und Redoxreaktionen.

 

[adeliiix]

@Hancock

ja aber wie weiß der compiler das er in diesem Bespiel im unteren teil für wert die stärke von oben einsetzen muss?

 

[powerfx]

Du rufst die Funktion ("addProzent") auf und übergibst ihr Argumente (das, was in Klammern steht):

// Neue Werte berechnen
Staerke = addProzent (Staerke, Steigerung);
Geschwindigkeit = addProzent (Geschwindigkeit, Steigerung);

 

[adeliiix]

Aber müsste dort dann nicht return Staerke oder os stehen?
weil es wird ja der neue wert für die staerke ausgerechent
und dieser dan an staerke oder so zurückgeschickt

 

[powerfx]

Ja, deswegen steht da ja auch

Staerke = ...

D.h. der Varianle Staerke wird ein neuer Wert zugewiesen (und zwar der, der durch die entsprechende Funktion berechnet wird).

 

[adeliiix]

also wird mit return neuerWert; angegeben das der Wert neuerWert zurückgegeben wird und nicht wohin der zurückgegeben wird?

 

[asdfman]

Ja. Wenn man sagen müsste, wo der Wert landen muss, hätten Funktionen überhaupt keinen Sinn.

 

[Aliosy]

@asdfman & @hancock
Ich habe nichts gegen Kritik, aber das Problem ist doch, dass wenn man nicht einmal die Basics der PC Architektur kennt, wie hochqualitativ kann dann die Software werden?
Ich sehe es doch selbst, Informatik Abschluss, aber Null Verständnis und dazu auch keine Erfahrung. Dann muss man sich nicht wundern wieso die gekaufte Software so schlecht ist.
Wenn der gute @adeliix schon Probleme mit dem einfachen Befehl RETURN hat, wie wird es dann bei Pointern aussehen? Ich möchte gar nicht erst Doppelverpointerung erwähnen.
C++ ist noch dazu Objektorientiert, das wird als eine Katastrophe und Frustration enden, und das soll es keines Falls!

@ adellix
Meine Empfehlung für dich, versuch erstmal mit Basics wie Assembler. Keiner sagt, dass du das auswendig kennen muss, aber du lernst schon mal wie eine CPU aufgebaut ist und die Kommunikation zwischen Peripherie abläuft. Zumindest das Zusammenspiel zwischen ALU, RAM, Daten- und Adress- Registern, naja und dem Programcounter. Dann wirst du schon verstehen wie das mit dem RETURN abläuft.
Hier musst du nicht viel Zeit investieren, höchstes paar Tage. Bei viel Interesse auch noch viel schneller
Ansonsten würde ich dir, wie schon vorgeschlagen nach einem neuen Buch umzusehen. Es gibt viele Bücher, aber das meiste davon ist nur Papierverschwendung. Ich kann mich auch an ein C++ Buch erinnern, für Anfänger hieß es. Von wegen, ab einem viertel habe ich nichts mehr verstanden.
Ein sehr gutes Buch (wie ich finde) ist dieses hier -> „C: Programmieren von Anfang an“
Oder „C++: Objektorientiertes Programmieren von Anfang an“
Kosten beide nicht die Welt und sind sehr einfach aufgebaut.

Zu deinem Verständnisproblem mit Return, es ist etwa so:
Eine übergeordnete Abteilung (MAIN: Funktion) übergibt an die untergeordnete Abteilung( ADDPROZENT) eine Aufgabe für die Berechnung der Prozenten in Form von Zetteln (int Wert, int Prozent). Diese Untergeordnete Abteilung rechnet es auf dem neuen Zettel mit dem Name „NeuerWert“ aus und letztendlich übergibt genau diesen Zettel an die übergeordnete Abteilung „MAIN“ zurück. Das Ergebnis wird übernommen auf eigenen Zettel „Staerke“ und/oder „Geschwindigkeit“ und danach ist der Zettel „NeuerWert“ nicht mehr interessant und wird vernichtet.

 

[powerfx]

Wenn der gute @adeliix schon Probleme mit dem einfachen Befehl RETURN hat, wie wird es dann bei Pointern aussehen? Ich möchte gar nicht erst Doppelverpointerung erwähnen.

Das stimmt natürlich.
Oder wenn man dann später am Linux-Kernel arbeitet und einfachste Datentypen nicht kennt. Oder dann als leitender Entwickler bei Red Hat ohne Funktionsaufrufe zu verstehen.

Bevor man überhaupt eine Sprache lernt, sollte man dafür mindestens einen eigenen Compiler in Assembler bauen, besser natürlich auch eine eigene Hardware-Architektur, statt ständig Von-Neumann weiterzuverwenden.

 

[Hancock]

@powerfx: Les ich da Ironie?

@Aliosy: Dir ist klar, dass alles, was du da blubberst, reine Implementierungdetails sind? Das hat weder mit C noch mit C++ oder Assembler was zu tun. Und von dieser Zettelwirtschaft halt ich nicht so viel (hast du so in der Schule auch Funktionen eingeführt bekommen).

@TE:
Du musst dir klar machen, welche Variablen von wo aus sichtbar sind und was eine Funktion ist (mathematisch und erst später mit Daten).

Funktionen, die du implementieren könntest (das hilft deinem Verständnis):
- Quadratische Funktion ( z.B. f(x)=2*x*x-12+x+3 ) + ein kleines Programm, welches Zahlen von der Tastatur einließt und die Funktion ausrechnet
- Heaviside-Funktion Θ_0,5
- Signumsfunktion (Unter Verwendung der gerade programmierten Heaviside-Funktion)
- even bzw. odd (gerade ungerade)
- Fakultät
- Fibonacci

Das sind mathematische Funktionen, alle benötigen ein (oder mehrere) Return in der Implementierung.

 

[Hancock]

...und du machst es besser. Der TE will wissen, wie Funktionen funktionieren. Ich hab Funktionen immer wie in der Mathematik betrachtet (mit Einschränkungen bzw. Erweiterungen), das hat meinem Verständnis gut getan.
Als ich schon Programmieren konnte, hab ich mir dann mal Assembler angeschaut (und Calling-Convention und co.) und fand die Lösungen echt elegant, aber das heißt noch lange nicht, dass sie das Verständnis für das Konzept von Funktionen vereinfachen.
Und das Forum hier ist nicht ein Runterbeten von Definitionen, das kann der TE auch einfach auf Wikipedia nachlesen, ich will ihn drauf hinweisen, wie er möglicherweise eine Lösung findet, bei der er auch verständnistechnisch was dazu lernt.

@TE:
Die Diskussion hier wird nichts mehr bringen. falls du Fragen hast, such im Internet danach, Wikipedia/wikibooks ist für den Anfang keine schlechte Anlaufstelle, für C++ ist stackoverflow sehr gut. Dein Problem ist rein verständnistechnisch und daher im Forum nicht eifnach zu diskutieren, da musst du lesen und probieren, vor allem probieren.

 

[1337hAx']

Also ich arbeite selbst nach dem Buch, bin in Kapitel 8 und finde es eigentlich ziemlich gut geschrieben. Bisher habe ich 3 Bücher ausprobiert, 2 waren ziemlich akademisch, ohne Beispiele, trostlos und sehr unverständlich. Aber das hier ist eigentlich relativ einfach geschrieben. Kann der TE mir verraten, in welchem Kapitel er ist? Bei Funktionen hatte ich auch anfangs meine Probleme, aber lies doch einfach mal ganz dreist weiter und komm später wieder auf das Thema zurück. Wenn du gar nichts mehr kapierst, mal kurz drüberlesen und später nochmal nachschlagen!

 

[SaimenD]

Wurden deine fragen jetzte eigentlich beantwortet ??? das is in der diskussion wegen den grundlagen ziemlich untergegangen.

 

[adeliiix]

Also ich arbeite selbst nach dem Buch, bin in Kapitel 8 und finde es eigentlich ziemlich gut geschrieben. Bisher habe ich 3 Bücher ausprobiert, 2 waren ziemlich akademisch, ohne Beispiele, trostlos und sehr unverständlich. Aber das hier ist eigentlich relativ einfach geschrieben. Kann der TE mir verraten, in welchem Kapitel er ist? Bei Funktionen hatte ich auch anfangs meine Probleme, aber lies doch einfach mal ganz dreist weiter und komm später wieder auf das Thema zurück. Wenn du gar nichts mehr kapierst, mal kurz drüberlesen und später nochmal nachschlagen!

bin im mom mit kapittel 5 fast fertig wo es um arrays geht.

Ich dachte eigentlich das es sich geklärt hatte da ich es verstanden habe habe es nur leider anscheind nicht vernünftig mitgeteilt.
Allerdings das mit dem weiterlesen 1337hAx habe ich auch gemacht obwohl ich die aufgabenstellungen nicht ganz verstanden habe wie man diese Programmiert.
Habe mir die Lösungen angeschaut und habe auch verstanden wie es Funktioniert.

bin Jetzt bei der Aufgabenstellung in Kap.5 wo ich dieses Programmprogrammieren soll:

Spoiler

#include <iostream>

using namespace std;

// Strukturen
//
struct S_FeldInfo
{
	bool Besetzt;
	char Name[30];
};

// Variablen und Konstanten
//
const int Breite = 5;
const int Hoehe = 5;
S_FeldInfo Spielfeld[Breite][Hoehe];

// Prototypen
//
void LoescheSpielfeld ();
void ZeigeSpielfeld ();
void ZeigeFelddaten ();
void BesetzeFeld ();

// Hauptprogramm
//
int main ()
{
	int Auswahl = 0;

	LoescheSpielfeld (); // Spielfeld initialisieren

	// Menü anzeigen und Eingabe bearbeiten
	do
	{
		cout << endl;
		cout << "1 - Spielfeld anzeigen" << endl;
		cout << "2 - Feld besetzen" << endl;
		cout << "3 - Felddaten anzeigen" << endl;
		cout << "4 - Spielfeld loeschen" << endl;
		cout << "5 - Programm beenden" << endl;
		cout << "Auswahl: ";
		cin >> Auswahl;

		switch (Auswahl)
		{
			// Spielfeld anzeigen?
			case (1):
			{
				ZeigeSpielfeld ();
			} break;

			// Feld besetzen?
			case (2):
			{
				BesetzeFeld ();
			} break;

			// Felddaten anzeigen?
			case (3):
			{
				ZeigeFelddaten ();
			} break;

			// Spielfeld löschen?
			case (4):
			{
				LoescheSpielfeld ();
				cout << "Spielfeld wurde geloescht!" << endl;
			} break;

			// Programm beenden?
			case (5):
			{
				cout << "Programm beendet." << endl;
			} break;

			// Falsche Eingabe?
			default:
			{
				cout << "Ungueltiger Menuepunkt!" << endl;
			}
		}

	} while (Auswahl != 5);

	return 0;
}

// LoescheSpielfeld
//
// Aufgabe: Spielfeld löschen
//
void LoescheSpielfeld ()
{
	for (int y=0; y<Hoehe; y++)
	{
		for (int x=0; x<Breite; x++)
		{
			Spielfeld[x][y].Besetzt = false;
		}
	}

} // LoescheSpielfeld

// ZeigeSpielfeld ()
//
// Aufgabe: Spielfeld anzeigen
//
void ZeigeSpielfeld ()
{
	cout << endl;

	for (int y=0; y<Hoehe; y++)
	{
		for (int x=0; x<Breite; x++)
		{
			// Wenn das Feld besetzt ist, ein X zeichnen,
			// ansonsten einen Punkt
			if (Spielfeld[x][y].Besetzt == true)
				cout << "X";
			else
				cout << ".";
		}

		cout << endl;
	}
} // ZeigeSpielfeld

// BesetzeFeld
//
// Ein Feld an bestimmten Koordinaten besetzen
//
void BesetzeFeld ()
{
	int x = 0;
	int y = 0;

	// Koordinaten abfragen
	do
	{
		cout << "x-Position (1-" << Breite << "): ";
		cin >> x;
	} while (x<1 || x>Breite);

	do
	{
		cout << "y-Position (1-" << Hoehe << "): ";
		cin >> y;
	} while (y<1 || y>Breite);

	// Name abfragen und Felddaten füllen
	cout << "Name: ";
	cin.ignore ();
	cin.get (Spielfeld[x-1][y-1].Name, 29);
	Spielfeld[x-1][y-1].Besetzt = true;

} // BesetzeFeld

// ZeigeFelddaten
//
// Aufgabe: Felddaten an bestimmten Koordinaten anzeigen
//
void ZeigeFelddaten ()
{
	int x = 0;
	int y = 0;

	// Koordinaten abfragen
	do
	{
		cout << "x-Position (1-" << Breite << "): ";
		cin >> x;
	} while (x<1 || x>Breite);

	do
	{
		cout << "y-Position (1-" << Hoehe << "): ";
		cin >> y;
	} while (y<1 || y>Breite);

	// Felddaten ausgeben
	if (Spielfeld[x-1][y-1].Besetzt == false)
	{
		cout << "Dieses Feld ist noch nicht besetzt." << endl;
	}
	else
	{
		cout << "Feld ist besetzt von: ";
		cout << Spielfeld[x-1][y-1].Name << endl;
	}

} // ZeigeFelddaten

Wenn ich mir die aufgabe durchlese habe ich keine ahnung wie ich das Programmieren sollte.
Wenn ich die Lösung lese weiß ich wie es funktioniert und finde das auch logisch so etc.
Also mit dem Verständnis wie es funktionier habe ich jetzt nicht mehr so ein Programmieren von selbst kommt oder
sollte ich nochmal von vorne anfangen? aber verstehen tue ich es ja^^