Kann ich überhaupt programmieren lernen?

[Chris_XY]

Ganz allgemein kann man sagen: Wenn man etwas zum ersten Mal tut, stellt man sich immer ziemlich blöd an. 6 Wochen sind zwar schon relativ viel, aber zum Programmieren Lernen ist es ziemlich wenig.

Es dauert lange. Wirklich.

 

[Indi]

Ganz allgemein kann man sagen: Wenn man etwas zum ersten Mal tut, stellt man sich immer ziemlich blöd an. 6 Wochen sind zwar schon relativ viel, aber zum Programmieren Lernen ist es ziemlich wenig.

Es dauert lange. Wirklich.

Also für mich ist das auch kein Prozess der jemals abgeschlossen sein wird. Ich programmiere jetzt seit gut 15 Jahren und kann doch immer wieder etwas lernen. Wenn das nicht der Fall wäre, würde es mir auch bei weitem nicht so viel Spaß machen.

 

[beavisbee]

Du schlägst vor eine Sprache zu lernen. Aber nicht programmieren.

nein, er schlägt vor, grundsätzliche und überaus wichtige Grundlagen sich von Anfang an anzueignen und sich nicht durch Sprachen, die einem alles abnehmen, dreckigen Programmier-Stil anzueignen...

Wer Anfangs mit C / C++ "gequält" wurde oder wer zudem sich vielleicht sogar damit herum schlagen musste, wie Variablen im Speicher abgelegt werden (also wir mussten im 1. Semester in Info z.B. in der schriftlichen Prüfung auf Papier erklären, wie eine gegebene Float-Zahl im Speicher liegt...), kapiert wesentlich schneller, warum eben z.B. in PHP

<?php
$erg = floor((0.1+0.7) * 10);
?>

7 ergibt statt der eigentlich erwarteten 8...
(Stichwort Ungenauigkeit von Fließkommazahlen)

Genauso wird es wesentlich selbstverständlicher, Daten, bevor man sie z.B. in eine SQL-Query übernimmt, auf Datentypen zu überprüfen oder zu casten oder prepaired Statements zu verwenden,...

oder wer weiß, dass man Variablen auch initialisieren kann, erkennt viel schneller sicherheits-kritische Konstrukte in PHP-Scripten und weiß, diese zu vermeiden...

 

[xrayn]

nein, er schlägt vor, grundsätzliche und überaus wichtige Grundlagen sich von Anfang an anzueignen und sich nicht durch Sprachen, die einem alles abnehmen, dreckigen Programmier-Stil anzueignen...

Ein guter Programmierstil zeichnet sich meiner Meinung nach vor allem dadurch aus, dass man effizienten* Code schreibt, der trotzdem lesbar ist. Und das ist selbst mit python/scheme oder bash machbar.

* = effiziente Algorithmen & Strukturen - ich denke du weißt auch, dass bubblesort in Assembler trotzdem langsamer ist als Heapsort in java oder einer anderen Sprache, die interpretiert wird

Wer Anfangs mit C / C++ "gequält" wurde oder wer zudem sich vielleicht sogar damit herum schlagen musste, wie Variablen im Speicher abgelegt werden (also wir mussten im 1. Semester in Info z.B. in der schriftlichen Prüfung auf Papier erklären, wie eine gegebene Float-Zahl im Speicher liegt...), kapiert wesentlich schneller, warum eben z.B. in PHP

<?php
$erg = floor((0.1+0.7) * 10);
?>

7 ergibt statt der eigentlich erwarteten 8...
(Stichwort Ungenauigkeit von Fließkommazahlen)

Ich habe für ieee754 in MIPS-Asm sämtliche Algorithmen, die man in zum Rechnen normalerweise in Hardware implementiert, als asm geschrieben. Ich würde im nach hinein nicht behaupten, dass das meinen Programmierstil geprägt hat. Ich habe auch schon Bitboards implementiert - das lief zwar ziemlich fix allerdings, war es für 3te kaum nachvollziehbar und Fehler waren ziemlich schwierig zu finden.

Wenn man mit dem Programmieren anfängt geht es vor allem darum, dass man ein Gefühl für Strukturen, Muster und Konzepte entwickelt. Speicherverwaltung ist ein Thema was man sich später angucken kann und sollte. Aber es bringt anfänglich weniger, wenn man nach Fehlern im Algorithmus und in der Sprache suchen muss.

 

[GrafZahl]

das endet in einer grundsatz diskusion ...

*abhark*

Wenn man mit dem Programmieren anfängt geht es vor allem darum, dass man ein Gefühl für Strukturen, Muster und Konzepte entwickelt.

da setze ich die prioritäten etwas anders ... wer nicht präzise ausdrücken kann, was ein programm oder algorithmus tun soll, verliert sich in oberflächlichem denken... ich denke dass man durch eine präzise ausdrucksweise viel schneller bemerkt wo sich ein fehler eingeschlichen hat ... natürlich gehts auch ohne, aber die effektivität/produktivität wird darunter leiden ...

Speicherverwaltung ist ein Thema was man sich später angucken kann und sollte. Aber es bringt anfänglich weniger, wenn man nach Fehlern im Algorithmus und in der Sprache suchen muss.

bei der speicherverwaltung gebe ich dir recht, das ist ein thema das nicht wirklich viel bringt am anfang...

algorithmen und programme kann man sprachunabhänig entwickeln ... es ist daher möglich sich damit zu befassen ohne eine programmiersprache überhaupt näher gesehen zu haben.
das wäre natürlich eine art des lernens die man getrost als staub trocken bezeichnen kann ... von schnell sichtbaren ergebnissen und fortschritten keine spur ... der gedanke gleichzeitig eine programmiersprache zu erlernen liegt also nahe

wenn man nun eine sprache wählt die vorwiegend implizit arbeitet, läuft man meiner ansicht nach gefahr diese implikationen auf sein eigenes denken im bezug auf den themenbereich "programmieren" zu übertragen ...

man gewöhnt sich dinge an, die am anfang einfach erscheinen ... und wegen der implikationen (scheinbar) überall funktionieren ... man bemerkt nicht, dass da überhaupt impliziert wird, also dass da mehr vor sich geht, als man gemein hin im code lesen kann ...

ich sage ja nicht, dass man implikationen um jeden preis vermeiden muss, und folglich mit ASM anfangen sollte ... nur liegen zwischen der c-sprachfamilie und sprachen wie php oder python doch irgendwie welten was den grad solcher implikationen angeht ...

einem anfänger fällt es oft schwer abläufe in ihre einzelteile zu zerlegen ... eine fähigkeit die unabdingbar ist ... wenn die sprache ihn nun von anfang an dazu zwingt "alles in seine einzelteile" zu zerlegen, fördert diese sprache damit aktiv die entwicklung dieser fähigkeit

 

[.:L]

Ganz allgemein kann man sagen: Wenn man etwas zum ersten Mal tut, stellt man sich immer ziemlich blöd an. 6 Wochen sind zwar schon relativ viel, aber zum Programmieren Lernen ist es ziemlich wenig.

Es dauert lange. Wirklich.

fullack.

Du hast dir etwas ausgesucht, also probier erstmal ein wenig herum. Der Spruch ist alt und ausgelutscht, aber es ist noch kein Meister vom Himmel gefallen... Wenn du dich für Programmierung interessiert behaupte ich einfach mal, dass du zwangsläufig nicht an anderen Programmiersprachen vorbeikommst ;-) Realisiere deine Programmierung doch mal in einer anderen Programmiersprache, einfach mal um ein Gefühl dafür zu bekommen was bedeuted, C++ im Vergleich zu anderen Sprachen zu programmieren.

Ich wiederhole mich gerne nochmal: C# ist einfach zu lernen, bietet viele Funktionen und ist vor nicht besonders Komplex, zumindest nicht für Anfänger. C++ Kenntnisse hast du ja, also...

Probier alles aus was dich interessiert, es kostet ja nichts.

 

[Sin84]

Ich hab nicht mit so viel Resonanz auf meinen Thread gerechnet.
Danke erstmal dafür, dass ihr mir auf so freundliche Weise versucht weiterzuhelfen, Codes postet um mir Denkanstöße zu geben, und mir für den Anfang andere Programmiersprachen nahelegt, damit mir der Einstieg in die Materie vielleicht leichter Fallen könnte.

Ich denke, ich bleibe erstmal bei C++, obwohl auch einige gute Argumente genannt worden sind, mit einer anderen Programmiersprache zu beginnen.

Mit der Bowling Simulation habe ich, seit meinem letzten Code-Post, leider immer noch keinen Fortschritt erreicht. Ich probier die ganze Zeit alles Mögliche aus, um mit der Programmaufgabe wenigstens einen Schritt voran zu kommen, aber nichts funktioniert, was mich langsam etwas frustriert.
Vielleicht bin ich einfach noch nicht so weit diese Aufgabe zu lösen, oder mache sie komplizierter als sie eigentlich ist, und sollte sie vorerst auf Eis legen!


@ GrafZahl:

Ich hatte mich undeutlich ausgedrückt, als du mich fragtest, ob ich die Gesamtpunktzahl der einzelnen Spieler ausgeben möchte oder die einzelnen Würfe.
1. Anzeige: Die Einzelnen Würfe des jeweiligen Spielers.
2. Anzeige: Endergebnis des jeweiligen Spielers.

Aber wenn du den Code dementsprechend geschrieben hättest, muss ich trotzdem bezweifeln, ob ich ihn auf mein Code hätte übertragen können, ohne das Meißte einfach nur abzuschreiben.

.:L:
Ich wiederhole mich gerne nochmal: C# ist einfach zu lernen, bietet viele Funktionen und ist vor nicht besonders Komplex, zumindest nicht für Anfänger. C++ Kenntnisse hast du ja, also...

Probier alles aus was dich interessiert, es kostet ja nichts.

Hab deinen Beitrag gerade erst gelesen.. Stimmt, dagegen spricht eigentlich nichts.

 

[GrafZahl]

versuche mal deine lösung in stichworte zu fassen


beispielsweise:

das programm startet mit der eingabe der spieler
es wird zunächst gefragt wieviele spieler mitspielen.
danach werden die namen der spieler eingelesen
für jeden mitspieler geschieht nun folgendes
{
...
}
dann wird ...
...
das programm ist zuende


(mut zur lücke, was fehlt wird später ergänzt)

ziel der übung ist es deine idee erstmal in irgend einer form ausserhalb deines kopfes festzuhalten ... dann kann einerseits, zusätzlich zu dir, jemand anderes nachvollziehen ob der algorithmus grundsätzlich zum ziel führt, was dafür nötig ist (z.b. wie man für eine variable anzahl an spielern namen oder sonstige daten erfassen und speichern kann) und einzelne punkte präzisieren ... andererseits kann man das ganze schlussendlich formalisieren, sprich in eine hochsprache wie c++, c#, python, oder sonstwas überführen

der ablauf dessen ist völlig dir überlassen, du kannst zu jedem zeitpunkt fragen stellen, und jeden schritt selbst durchführen ... da das ganze aber in viele kleine aufgaben zerfällt, ist jede einzelne davon so klein, dass sie ohne viel wissen lösbar ist ... das ist im grunde das konzept hinter vielen (nicht zwangsweise) programmtechnischen lösungen von problemen (die strategie heißt "teile und hersche"/"divide and conquer"/"divide et impera") ... zerlegen von großen, im ganzen un- oder nur schwer lösbaren aufgaben, in kleinere einfacher lösbare aufgaben

 

[wlaner]

Bitte gib nicht auf Sin. Es gibt talentiertere Programmier und untalentiertere. Ein gewisses logisches Verständnis (weniger Mathe) solltest du mitbringen. Irgendwann werden sich die kryptischen Zeichen vor deinen Augen zu einer Sprache formen. Du musst nur am Ball bleiben. Um zu verstehn, wie Syntax funktioniert, besorg dir eine gute C++ Entwicklungsumgebung wie das Visual Studio. Benutze den Debugger und lösche einfach mal einzelne Zeichen in den Code-Bespielen, die du nicht verstehst. Fehlermeldungen können sehr Hilfreich sein.

 

[Sin84]

Hallo.

wlaner:
Bitte gib nicht auf Sin.

Hatte ich nicht vor, jedenfalls nicht mit dem Programmieren. Höchstens vorerst mit dieser beschissenen Bowling Simulation.

wlaner:
Um zu verstehn, wie Syntax funktioniert, besorg dir eine gute C++ Entwicklungsumgebung wie das Visual Studio. Benutze den Debugger und lösche einfach mal einzelne Zeichen in den Code-Bespielen, die du nicht verstehst. Fehlermeldungen können sehr Hilfreich sein.

hmm.. Leider benutze ich bereits "Visual C++ 2010 Express".


@all:

Ich hab meinen Code jetzt nochmal ein wenig umgeschrieben, hab wegen dieser Bowling Simu jetzt so viel mit Funktionen und Rückgabewerten herumprobiert, dass ich jetzt immerhin die besser verstehe. Ist ja schon mal was.

Aber eigentlich läuft der Code auf das Gleiche hinaus wie mein voriger, nur das ich die main() etwas entlastet und stattdessen mit einer Funktion mehr arbeite. Ich häng jedenfalls immer noch an der selben Stelle fest.

GrafZahl:
(mut zur lücke, was fehlt wird später ergänzt)

Ich poste den "neuen" Code hier jetzt nochmal, inklusive meiner "Mut zur Lücke" Lücke. Ich hab den Code kommentiert. Vielleicht wird euch dann schlüssiger, wo es hapert und was mir Schwierigkeiten bereitet.

	//	main.cpp	//

#include <iostream>
#include <conio.h>
#include <time.h>
using namespace std;


int iWurf(){

	int iPunkte = 0;

	iPunkte = rand()%11;	//Ein Wurf eines Spielers.
	cout << iPunkte << endl;
	if (iPunkte == 10) cout << iPunkte << endl;	//Im Fall eines Strikes.

	return iPunkte;
}


int iDurchgang1Spieler(int iDuchgangSpieler){
	
	for (int i = 0; i < 10;i++){	//Alle Würfe EINES Spielers.
		iWurf();
	}

	return iDuchgangSpieler;
}


int main(){

	int iWuerfeAllerSpieler = 0;
	int iPlayer;
	
	cout << "Wieviele Spieler sollen am Turnier teilnehmen?" << endl;
	cin >> iPlayer;
	cout << "Es nehmen " << iPlayer << " Spieler am Turnier teil." << endl;
	
	srand ((unsigned)time(NULL));
	for (int i = 1; i <= iPlayer;){			
	cout << "Spieler " << i++ << " wirft:" << endl;	// i++ zählt in dieser Zeile einfach nur die Zahlen hinter "Spieler " hoch.
	iDurchgang1Spieler(iWuerfeAllerSpieler);	// Alle Würfe aller Spieler.
	}

	//	Mut zur Lücke	// Hier folgt jetzt "Code", der einfach nur verdeutlichen soll, wie ich mir das Programm weiter vorstelle:
	
	int GesamtPunkte1Spieler = 0;
	int GesamtPunkteAlleSpieler = 0;
	
	GesamtPunkte1Spieler = iDurchgang1Spieler(iWuerfeAllerSpieler);
	
	string sBestenliste[100][100] =	{	{"Spieler1","Spieler2","Spieler3",},	//usw. Daten sollen natürlich automatisch ins 2D. Array eingetragen werden. Wie das auch immer gehen soll.
						{"60","80","45"} };		//usw. Gesamtpunktzahl, die jeweiliger Spieler erreicht hat.


	_getch();
}

Aufgrund von Chris-XY Beitrags, der nach diesem folgt, editiere ich nochmal kurz.
Ich meinte natürlich nicht, wie im Code^^ geschrieben, ein 2D. Array[100][100], sondern 2D. Array[100][2]. oder wahrscheinlich meine ich doch eher Array[100][1]?! sorry

 

[Chris_XY]

Mit der Bowling Simulation habe ich, seit meinem letzten Code-Post, leider immer noch keinen Fortschritt erreicht. Ich probier die ganze Zeit alles Mögliche aus, um mit der Programmaufgabe wenigstens einen Schritt voran zu kommen, aber nichts funktioniert, was mich langsam etwas frustriert

Kennt jeder Anfänger. Glaube ich.

//usw. Daten sollen natürlich automatisch ins 2D. Array eingetragen werden. Wie das auch immer gehen soll.

Beiß' dich nicht nicht so fest.

Meine Empfehlung wäre ein neues kleines Programm, das ein 2x4 Array oder so deklariert, mit verschiedenen Methoden ein paar Werte einfüllt also "array[1][2] = 4", "for (i=0; i<3; i++) { array[1] = i }", etc.

Damit lernt man dann, was Arrays sind und wie man sie benutzt und dieses Wissen kann man dann später deutlich einfacher benutzen.

Vielleicht kennst du ja Half Life 2. Da ist dieses Prinzip überall vertreten: Einen neuen Gegnertyp siehst du z.B. meistens ersteinmal in einer "sicheren" Umgebung und kannst beurteilen, was er alles kann und erst danach musst du gegen ihn kämpfen.

 

[GrafZahl]

ok, mit stichworten war eigentlich nicht der code gemeint, aber schauen wir mal was da bisher steht (korrigier mich, wenn ich etwas falsch verstehe)

----------------- anfang der bestandsaufnahme

beginnen wir mit der hauptprozedur ... main

zunächst wird dem benutzer die frage gestellt wieviele spieler mitspielen.
die anzahl wird in die variable iPlayer eingelesen
die anzahl der spieler wird dem benutzer bestätigt
der zufallszahlengenerator wird initialisiert
es beginnt eine schleife die alle spieler itteriert (durchgeht), itterations variable ist i
{
es wird mit i ausgegeben welcher spieler gerade dran ist
iDurchgang1Spieler wird aufgerufen und die rückgabe der funktion wird ignoriert ... die funktion bekommt als parameter iWuerfeAllerSpieler übergeben (ist immer 0)
}
an diesem punkt beginnt die lücke bis zum programmende


weiter mit der funktion iDurchgang1Spieler

die funktion hat scheinbar den zweck alle würfe für einen spieler zu erledigen

die funktion hat einen parameter iDuchgangSpieler

sie beginnt mit einer schleife die alle würfe eines spielers itteriert, itterationsvariable ist i und läuft von i=0 bis i=9 (10 durchläufe)
bei jedem durchlauf wird die parameterlose funktion iWurf aufgerufen und ihr rückgabewert ignoriert
nach ablauf der schleife, wird der parameter iDurchgangSpieler zurückgeliefert, damit endet die funktion

weiter mit iWurf

die funktion hat scheinbar den zweck einen wurf durchzuführen

die funktion ist parameterlos

die funktion erzeugt eine zufallzahl iPunkte im bereich 0 bis 10
die zufallszahl wird dem benutzer ausgegeben
ist die zahl gleich 10 wird sie nochmal ausgegeben
die funktion endet mit der rückgabe von iPunkte


zur lücke in der main:

du möchtest für jeden spieler seine persöhnliche gesammtpunktzahl
du möchtest ferner die gesammtpunktzahl ALLER spieler (?)
die bestenliste soll ein 2D array werden


----------------- ende der bestandsaufnahme


zunächt mal zur bestenliste, ein kleiner exkurs zu arrays ...

+-----------------------+---------------------+
| 1. Dimension          |  2. Dimension       |
+-----------------------+---------------------+


+-----------------------+---------------------+
|                       |     Spieler 1       |
|          1            +---------------------+
|                       | punktzahl Spieler 1 |
+-----------------------+---------------------+
|                       |     Spieler 2       |
|          2            +---------------------+
|                       | punktzahl Spieler 2 |
+-----------------------+---------------------+
|                       |     Spieler 3       |
|          3            +---------------------+
|                       | punktzahl Spieler 3 |
+-----------------------+---------------------+

ich denke das stellt deine bestenliste adequat dar ... in der ersten dimension steht mit 1,2,3 der jeweilige listenplatz ... diese dimension hat eine ausdehnung entsprechend der spielerzahl
in der 2. dimension haben wir auf der einen seite den namen des spielers (wir nehmen der einfacheit halber die nummer) auf dem jeweiligen listenplatz, und auf der anderen seite seine erreichten punkte ... die ausdehnung dieser dimension ist 2

schöner wäre das ganze mit mit einem struct oder einer klasse, aber für den anfang soll uns das so reichen

unser array kann man also deklarieren mit

int bestenliste[100][2]

wir haben maximal 100 einträge auf der liste, und für jeden eintrag auf der liste speichern wir 2 werte ...

eigentlich ist das für deinen jetzigen stand schon über das ziel hinaus geschossen, da wir die spielernummer auch als position auf der liste verstehen könnten (wir kämen mit einem 1D array aus) ... aber damit wird das sortieren die bestenliste später schwierig, daher nehmen wir mal den 2D ansatz ...

als nächstes ein kleiner exkurs zum thema funktionen, parameter, rückgabewerte ...

nehmen wir mal an wir haben eine funktion:

int multiply(int a, int b)
{
    int ergebnis = a * b;
    return ergebnis;
}

wenn du nun irgendwo schreibst

int zahl = multiply(2,21);

steht danach in zahl der wert 42 ... anstelle von 2 und 21 hätte man auch 2 variablen vom typ int übergeben können

ich habe hier allerdings absichtlich 2 konstanten benutzt, um dir eine sache nahezubringen: ... wenn ich in der funktion multiply beispielsweise der variable a einen anderen wert zuweise, dann hat das nur auswirkungen innerhalb von multiply ... das liegt daran, dass für einen funktionsaufruf die parameter als kopie des originals an die funktion gegeben werden ... ändere ich nun etwas an dieser kopie, passiert dem original nichts ...

möchten wir dagegen, dass die funktion den wert des originals verändern kann, so ist auch dies möglich ... das zauberwort heißt pointer ... dazu kommen wir, wenn es gebraucht wird ... spätestens wenn es darum geht wie wir von einer anderen funktion als main auf die bestenliste zugreifen können ...





so ... genug der erklärungen, weiter gehts mit deinem programm

bis auf die lücke in der main ist schon der grobe ablauf vorhanden... ich schlage vor wir schauen als nächstes mal über die funktionen iWurf und iDurchgang1Spieler ... genauergesagt auf das was diese funktionen tun sollen, und was sie derzeit tun ...

iWurf sieht für den anfang recht vollständig aus: es wird geworfen, und das punkte ergebnis zurück gemeldet ... dafür sind keine parameter nötig ... die funktion kann also zum jetzigen stand der dinge erstmal so bleiben wie sie ist, da sie alles tut was von ihr momentan erwartet wird.


iDurchgang1Spieler hingegen scheint noch nicht so ganz das zu tun was davon erwartet wird ... zum beispiel wird zwar iWurf aufgerufen, aber das ergebnis wird ignoriert ... iWurf gibt zwar die punkte an den benutzer aus (cout), aber iDurchgang1Spieler benutzt die von iWurft zurückgegebene zahl nicht. (der iWurf aufruf ist nicht bestandteil einer zuweisung)

was soll damit geschehen?

iDurchgang1Spieler bekommt zudem einen parameter, der unverändert zurückgegeben wird ... wofür genau steht dieser parameter?

(nicht falsch verstehen wenn die fragen etwas komisch klingen ... die antworten kenne ich quasi schon ... es geht darum dass du selbst darauf kommst)

 

[Sin84]

Chris_XY:
Kennt jeder Anfänger. Glaube ich.

Das beruhigt mich.

Chris_XY:
Meine Empfehlung wäre ein neues kleines Programm, das ein 2x4 Array oder so deklariert, mit verschiedenen Methoden ein paar Werte einfüllt also "array[1][2] = 4", "for (i=0; i<3; i++) { array[1] = i }", etc.

Hab jetzt mal kurz Werte einfüllen geübt. Hat funktioniert.

GrafZahl:
du möchtest ferner die gesammtpunktzahl ALLER spieler (?)

Ne, will ich gar nicht. Frag mich auch gerade, warum ich das wollte?!

GrafZahl:
iDurchgang1Spieler hingegen scheint noch nicht so ganz das zu tun was davon erwartet wird ... zum beispiel wird zwar iWurf aufgerufen, aber das ergebnis wird ignoriert ... iWurf gibt zwar die punkte an den benutzer aus (cout), aber iDurchgang1Spieler benutzt die von iWurft zurückgegebene zahl nicht. (der iWurf aufruf ist nicht bestandteil einer zuweisung)

was soll damit geschehen?

"iDurchgang1Spieler" soll die Ergebnisse von "iWurf" speichern und zurückgeben. Hab den Code jetzt dementsprechend angepasst, glaube ich.

GrafZahl:
iDurchgang1Spieler bekommt zudem einen parameter, der unverändert zurückgegeben wird ... wofür genau steht dieser parameter?

Jetzt wird doch, nach der Anpassung meines Codes, der letzte Wurf von "iWurf" in dem Parameter "iDuchgangSpieler" gespeichert?

Jedenfalls wird nur der letzte Wurf durch cout << iUebergabe; ausgegeben. Liegt wohl daran, dass "int iDuchgangSpieler" nur eine Zahl speichern kann..

Ich muss nur irgendwie alle Würfe von "iWurf" zurückgeben lassen. Wie ich das auch immer anstellen soll?

    //    main.cpp    //

#include <iostream>
#include <conio.h>
#include <time.h>
using namespace std;


int iWurf(){

    int iPunkte = 0;

    iPunkte = rand()%11;    //Ein Wurf eines Spielers.
    cout << iPunkte << endl;
    if (iPunkte == 10) cout << iPunkte << endl;    //Im Fall eines Strikes.

    return iPunkte;
}


int iDurchgang1Spieler(int iDuchgangSpieler){
    
    for (int i = 0; i < 10;i++){    //Alle Würfe EINES Spielers.
        iDuchgangSpieler = iWurf();
    }
    
    return iDuchgangSpieler;    // Soll alle Würfe übergeben, übergibt aber nur den letzten.
}


int main(){

    int iUebergabe;
    int iWuerfeAllerSpieler = 0;
    int iPlayer;
    
    cout << "Wieviele Spieler sollen am Turnier teilnehmen?" << endl;
    cin >> iPlayer;
    cout << "Es nehmen " << iPlayer << " Spieler am Turnier teil." << endl;
    
    srand ((unsigned)time(NULL));
    for (int i = 1; i <= iPlayer;){            
    cout << "Spieler " << i++ << " wirft:" << endl;    // i++ zählt in dieser Zeile einfach nur die Zahlen hinter "Spieler " hoch.
    iUebergabe = iDurchgang1Spieler(iWuerfeAllerSpieler);    // Alle Würfe aller Spieler.
    }

    //    Mut zur Lücke    // Hier folgt jetzt "Code", der einfach nur verdeutlichen soll, wie ich mir das Programm weiter vorstelle:
    /*
    int GesamtPunkte1Spieler = 0;
    
    GesamtPunkte1Spieler = iDurchgang1Spieler(iWuerfeAllerSpieler);
    
    string sBestenliste[100][1] =    {    {"Spieler1","Spieler2","Spieler3",},    //usw. Daten sollen natürlich automatisch ins 2D. Array eingetragen werden. Wie das auch immer gehen soll.
                                        {"60","80","45"} };    //usw. Gesamtpunktzahl, die jeweiliger Spieler erreicht hat.
    */


    _getch();
}

 

[GrafZahl]

wir kommen der ganzen sache deutlich näher ...

int iDurchgang1Spieler(int iDuchgangSpieler){
    
    for (int i = 0; i < 10;i++){    //Alle Würfe EINES Spielers.
        iDuchgangSpieler = iWurf();
    }
    
    return iDuchgangSpieler;    // Soll alle Würfe übergeben, übergibt aber nur den letzten.
}

wie du bereits völlig richtig vermutest, kann eine variable vom typ int exakt eine zahl speichern ... wenn du alle einzelnen würfe mitnehmen willst, wäre hier ein array angebracht ...

willst du aber sowieso nur das gesammtergebnis wissen, hindert dich aber auch niemand daran alle punkte einfach aufzusummieren, und mit der summe weiter zu machen ...

nehmen wir mal an letzteres ist die gewünschte vorgehensweise ...
diese zeile:

iDuchgangSpieler = iWurf();

ist dafür verantwortlich, dass bei jedem durchlauf der schleife das ergebnis von iWurf() den vorherigen wert überschreibt ... eine zuweisung (=) kümmert sich in keinster weise um das was an dem ort steht, auf den zugewiesen wird ... die information an dieser stelle geht verloren, da sie durch eine neue information ersetzt wird

x = 1; // x beinhaltet nun die 1
x = 2; // x beinhaltet nun die 2 ... die 1 ist verloren

für die aufsummierung ist eine einfache zuweisung demnach nicht geeignet ... wir müssen winen weg finden wie wir die information die dort bereits steht mitnehmen können ... nichts leichter als das ...

x = 1; //hier kommt die 1
x = x + 2; // hier wird zunächst x ausgewertet, was 1 ergibt, dann wird 2 addiert, und zu guter letzt wird das ergebnis in x gespeichert ...

da programmierer normalerweise von hause aus faul sind, gibts eine kurzschreibweise dafür ...

x += 2; // sieht komisch aus, ist aber völlig gleichbedeutend mit x = x + 2;

an dieser stelle sei dir natürlich noch die lektüre der operatoren von c++ ans herz gelegt ... eine nette kleine zusammenfassung fand onkel google hier: http://www.highscore.de/cpp/einfuehrung/operatoren.html

dann noch etwas zu der funktion ...
int iDuchgangSpieler führst du als parameter ein ... vereinfacht, und eigentlich auch nicht so ganz richtig, kannst du dir aber erstmal merken:

parameter haben den zweck "von aussen" informationen in eine funktion einzubringen

da du sofort auf die variable schreibst, ohne von ihr zu lesen, kann sie diesem zweck irgendwie nicht dienlich sein ... überlege dir mal ob es wirklich sinn macht diese variable als parameter einzuführen, oder ob das nicht eine ganz normale lokale variable sein darf ...

 

[Sin84]

Vielen Dank für deine Schritt für Schritt Anleitung, GrafZahl!

Leider kann ich den letzten Schritt nicht umsetzen. Entweder hab ich´s nicht richtig verstanden oder einer von uns beiden macht nen Denkfehler.
Vermutlich stellt sich heraus, dass ich der Eine bin. 8)

int iDurchgang1Spieler(){
    
    int iDurchgangSpieler = 0;
    for (int i = 0; i < 10;i++){    
    iDurchgangSpieler = iWurf();
    }
    iDurchgangSpieler = iDurchgangSpieler + iDurchgangSpieler;  // Hier sollen die einzelnen Würfe addiert werden.

    return iDurchgangSpieler;    
}

Aber natürlich können die einzelnen Würfe nicht addiert werden, weil vorher iDurchgangSpieler = iWurf(); ausgeführt wird und iDurchgangSpieler dann wieder nur eine Zahl beinhaltet. Würde ich iDurchgangSpieler = iDurchgangSpieler + iDurchgangSpieler; über iDurchgangSpieler = iWurf(); "packen", wäre ja noch kein Ergebnis eines Wurfes in der Variable.

GrafZahl:
... wenn du alle einzelnen würfe mitnehmen willst, wäre hier ein array angebracht ...

willst du aber sowieso nur das gesammtergebnis wissen, hindert dich aber auch niemand daran alle punkte einfach aufzusummieren, und mit der summe weiter zu machen ...

nehmen wir mal an letzteres ist die gewünschte vorgehensweise ...

Oder wäre an gerade behandelter Stelle jetzt etwa schon ein Array angebracht?


Ok. Ich muss noch einmal editieren:

Anfangs hatte ich
iDurchgangSpieler = iDurchgangSpieler + iWurf();
ausprobiert.

Hatte nicht geklappt, weil ich in der main() vergessen hatte iUebergabe ausgeben zu lassen. Jetzt klappt´s. Er zählt die Punkte zusammen.

	//	main.cpp	//

#include <iostream>
#include <conio.h>
#include <time.h>
using namespace std;


int iWurf(){

	int iPunkte = 0;

	iPunkte = rand()%11;	//Ein Wurf eines Spielers.
	cout << iPunkte << endl;
	if (iPunkte == 10) cout << iPunkte << endl;	//Im Fall eines Strikes.

	return iPunkte;
}


int iDurchgang1Spieler(){
	
	int iDurchgangSpieler = 0;
	for (int i = 0; i < 10;i++){	//Alle Würfe EINES Spielers.
	iDurchgangSpieler = iDurchgangSpieler + iWurf();
	}

	return iDurchgangSpieler;	// Soll alle Würfe übergeben, übergibt aber nur den letzten.
}


int main(){

	int iUebergabe;
	int iPlayer;
	
	cout << "Wieviele Spieler sollen am Turnier teilnehmen?" << endl;
	cin >> iPlayer;
	cout << "Es nehmen " << iPlayer << " Spieler am Turnier teil." << endl;
	
	srand ((unsigned)time(NULL));
	for (int i = 1; i <= iPlayer;){			
	cout << "Spieler " << i++ << " wirft:" << endl;	// i++ zählt in dieser Zeile einfach nur die Zahlen hinter "Spieler " hoch.
	iUebergabe = iDurchgang1Spieler();	// Alle Würfe aller Spieler.
	}

	cout << iUebergabe;

	
	_getch();
}

Neues Problem. Er addiert leider immer nur die Punkte des Spielers, der zu letzt geworfen hat, wie ich gerade feststellen musste.

 

[Thunder11]

Der Code wie du ihn geschrieben hast funktioniert insofern nicht, weil die Variable iDurchgangSpieler mit jedem "iDurchgangSpieler=iWurf();" überschrieben wird.
Ein Array könnte dieses Problem sicherlich auch lösen, wäre aber nur notwendig, wenn du die Punktzahl für jeden Wurf seperat gespeichert brauchst (und soweit ich weiß, brauchst du nur die Gesamtpunktzahl).
Also könntest du, um alle Würfe zusammenzuaddieren eben diese Zeile "iDurchgangSpieler=iWurf();" durch folgende ersetzen:

iDurchgangSpieler=iDurchgangSpieler+iWurf();
// oder als Kurzschreibweise (üblicher):
iDurchgangSpieler+=iWurf();

Sie würde immer zum alten Wert von iDurchgangSpieler die Punktzahl, die beim neuen Wurf erzielt wurde, hinzuaddieren.

mfg Christian

Edit: Tut mir leid, ich hab anscheinend das Problem falsch verstanden und wahrscheinlich zusätzlich Verwirrung gestiftet :/

Edit2: Also doch nicht

 

[GrafZahl]

erm ... er addiert für jeden spieler die punkte, nicht nur für den letzten ...

das problem ist prinzipiell das gleiche, dass du gerade erfolgreich erkannt hast ...

    for (int i = 1; i <= iPlayer;){            
    cout << "Spieler " << i++ << " wirft:" << endl;    // i++ zählt in dieser Zeile einfach nur die Zahlen hinter "Spieler " hoch.
    iUebergabe = iDurchgang1Spieler();    // Alle Würfe aller Spieler.
    }

    cout << iUebergabe;

machen wir mal ein gedankliches experiment:

dafür nehmen wir an, dass iPlayer den wert 3 hat ...
der einfachheit halber nehmen wir an, dass iDurchgang1Spieler() den gleichen wert wie i zurückliefert (dient nur der übersicht)

schreib mal schritt für schritt auf was beim ausführen dieses codes passiert

den ersten schleifendurchlauf krigst du hier:

i erhält den wert 1
es erfolgt die ausgabe "Spieler 1 wirft:" und i erhält den wert 2
iDurchgang1Spieler() wirdaufgerufen und gibt (nur laut annahme) den wert 2 zurück
iUebergabe erhält diesen rückgabewert

----(bitte fortsetzen)----

 

[Sin84]

Hi Thunder11,

ich weiß nicht, ob du das Problem falsch verstanden hast. Da ich nicht weiß, was das Problem ist.

Jedenfalls führt iDurchgangSpieler+=Wurf(); zu dem Ergebnis, welches ich erreichen wollte. Die Würfe des einzelnen Spielers werden addiert und es wird das Gesamtergebnis ausgegeben.
Das Ergebnis hatte ich sowieso erreicht, wenige Minuten bevor du mich beratschlagt hast, also hast du bestimmt nicht für Verwirrung gesorgt.


@ GrafZahl

Auf deinen Beitrag antworte ich besser erst morgen, da mein Hirn in Alkohol getränkt ist.

 

[GrafZahl]

jaja ... zuviel blut im alkohol ...

 

[Sin84]

iUebergabe hatte übrigens nur das Gesamtergebnis des letzten Spielers ausgespuckt, weil sich cout << iUebergabe nicht in der Schleife befand..

GrafZahl:
Code:
for (int i = 1; i <= iPlayer{
cout << "Spieler " << i++ << " wirft:" << endl; // i++ zählt in dieser Zeile einfach nur die Zahlen hinter "Spieler " hoch.
iUebergabe = iDurchgang1Spieler(); // Alle Würfe aller Spieler.
}

cout << iUebergabe;
schreib mal schritt für schritt auf was beim ausführen dieses codes passiert

Ich weiß zwar nicht worauf du hinaus willst, aber gut.

Zweiter Schleifendurchlauf:

i hat den wert 2.
Es erfolgt die Ausgabe "Spieler 2 wirft:" und i erhält den Wert 3.
iDurchgang1Spieler() wird aufgerufen und gibt (laut annahme) den wert 3 zurück.
iUebergabe erhält diesen rückgabewert.

iUebergabe erhält einen anderen Wert als iDurchgang1Spieler(). Wird das noch relevant? Momentan ist das doch eigentlich wurscht?!