Als nächstes Projekt habe ich mir überlegt, ein 4 gewinnt Spiel zu programmieren (ja, ich weiß, nicht allzu optimal für die Konsole, ich möchte es aber trotzdem machen :D).
Die Regeln sind wie beim Original, die Spieler müssen also versuchen, vier ihrer Spielsteine horizontal, vertikal oder diagonal nebeneinander zu bekommen.
Da es in der Konsole ja nunmal keine Grafiken gibt, besteht das Spielfeld in meiner Version standartmäßig aus Nullen, genauer gesagt aus 42 Stück (6*7 Felder).
Das ganze soll letztendlich so funktionieren, dass die Spieler abwechselnd eine Zahl eingeben, die für den jeweiligen Einschub steht.
Die Null an der Position, zu der der Stein fallen würde, wird daraufhin durch die jeweilige Spielerzahl ersetzt. Nicht schön, aber besser kriegt man es mit der Konsole denke ich mal nicht hin.
Nun habe ich mir auch bereits überlegt, wie ich das ganze Umsetzen könnte und angefangen, das Programm zu schreiben (Stellen, wo etwas fehlt oder unschön ist usw. sind per Kommentar gekennzeichnet):

#include <cstdlib>
#include <iostream>
#include <stdlib.h>

using namespace std;

// Hauptprogramm
int main(int argc, char *argv[])
{

	// Variablen
	int felderFrei = 42;
	int setzen = 0;

	// Variablen für die Felder (reduzierbar?)
	int a1 = 0;
	int a2 = 0;
	int a3 = 0;
	int a4 = 0;
	int a5 = 0;
	int a6 = 0;
	int a7 = 0;
	int b1 = 0;
	int b2 = 0;
	int b3 = 0;
	int b4 = 0;
	int b5 = 0;
	int b6 = 0;
	int b7 = 0;
	int c1 = 0;
	int c2 = 0;
	int c3 = 0;
	int c4 = 0;
	int c5 = 0;
	int c6 = 0;
	int c7 = 0;
	int d1 = 0;
	int d2 = 0;
	int d3 = 0;
	int d4 = 0;
	int d5 = 0;
	int d6 = 0;
	int d7 = 0;
	int e1 = 0;
	int e2 = 0;
	int e3 = 0;
	int e4 = 0;
	int e5 = 0;
	int e6 = 0;
	int e7 = 0;
	int f1 = 0;
	int f2 = 0;
	int f3 = 0;
	int f4 = 0;
	int f5 = 0;
	int f6 = 0;
	int f7 = 0;

	// Hauptmenü (noch nicht vollständig, tut ja aber auch nicht zur Sache)
	cout << "Willkomen bei 4 gewinnt! \n" << endl;

	// Hauptspiel
	while (felderFrei > 0 && /* keineVierSteineNebeneinander */)
	{
		cout << "1234567\n\n0000000\n0000000\n0000000\n0000000\n0000000\n0000000\n" << endl; // Nullen müssen durch die oben angelegten Variablen ersetzt werden, habe ich nur noch nicht gemacht

		cout << "Wähle einen einschub, indem du seine Zahl eingibst!\n" << endl;
		cin >> setzen;

		// hier muss der Code hin, der überprüft, auf welchem Feld der Stein landet und nachprüft, ob sich bereits vier Steine eines Spielers nebeneinander befinden.

		felderFrei--;
	}

	// Sieger ausgeben
	if (/* keineVierSteineNebeneinander */)
	{
		cout << "Das Ergebnis ist unentschieden! \a \n" << endl;
	}

	cout << "Spieler"  <<  /* hier kommt die Variable hin, die die Nummer des Siegers enthält */ << "ist der Sieger! \a \n" << endl;

	// Programm pausieren und nach Tastendruck beenden
	system("PAUSE");
	return 0;
}

Letztendlich ist mein Problem nicht, dass ich das Programm nicht zu Ende schreiben könnte, in meiner Version würde es nur seeeeeeeehr lang werden, was natürlich nicht allzu optimal ist. Wie man an meinen Kommentaren bereits erahnen kann, sind meine Hauptprobleme nun also folgende:
1. ist es irgendwie möglich, das anlegen der ganzen Variablen komplett zu umgehen oder zumindest irgendwie zusammenzufassen? (notfalls nicht so wichtig)
2. ist es möglich, die Position, zu der der Stein fällt, anders herauszufinden, als mit Verschachtelungen von if-Abfragen von oben nach unten zu überprüfen, ob auf dem Feld jeweils bereits ein Stein ist, und das für jede Reihe?
3. wie ist es am geschicktesten möglich, herauszufinden, ob bereits vier Steine nebeneinander sind? Mir fällt erneut nichts weiter ein, als das Verschachteln von if-Anweisungen, nur, dass der Code hier noch länger wäre, als bei Problem zwei, weil man hier ja auch wertikal und diagonal überprüfen muss, welche Zahl sich dort befindet...

Schonmal entschuldigung, dass mein Text so ewig lang ist, aber bevor ich zu wenig Infos gebe, mache ich es lieber so.
Wahrscheinlich sind meine Fragen für euch Experten unglaublich dumm, ich wäre aber trotzdem für jede Hilfe dankbar!

Schau die mal an, was ein std::vector ist. Oder alternativ ein Array. Und dann staune!

edit: Außerdem könnte 4 gewinnt für deinen Kenntnisstand (auch mit std::vector) eventuell etwas zu schwierig sein. Vielleicht solltest du noch ein bisschen mit noch einfacheren Programmen deine Kenntnisse festigen und in 1-2 Monaten zu 4 gewinnt zurückkehren. Es gibt bei dem Spiel so einige Sachen die zuerst ganz einfach aussehen, aber über die man als Anfänger ohne jede Erfahrung dann stolpert, was letztlich bloß zu Frust führt.

Ich würde hier keinen vector nehmen, sondern ein zweidimensionales Array. Wenn vorhanden auch array<array<..., aber keinen Vector. Das wäre einfach das falsche Mittel, so wie woanders endl, gell?

Das wäre einfach das falsche Mittel, so wie woanders endl, gell?

Agreed

Ich würde hier keinen vector nehmen, sondern ein zweidimensionales Array. Wenn vorhanden auch array<array<..., aber keinen Vector. Das wäre einfach das falsche Mittel, so wie woanders endl, gell?

Ich denke schon an das verschärfte 4 gewinnt mit dynamischer Spielfeldgröße

Tipp: Eventuell siehst du etwas zu jung aus, am besten das linke Bein leicht nachziehen

Hoffentlich hat der Autor nicht die Initialen J.W.?

Nein, hat er nicht.

Ich denke schon an das verschärfte 4 gewinnt mit dynamischer Spielfeldgröße

Geheimagentenlaserhindernisviergewinnt.
http://www.youtube.com/watch?v=lnz_YueCt5U

1. 2D-Array, wurde ja schon genannt. Als Typ schlage ich der Einfachheit halber einen Integer vor. Damit gilt dann: 0 = "leer", 1 = "Spieler 1", 2 = "Spieler 2".
2. Du weißt, dass der Stein in Spalte X fallen soll. Du läufst dann wie folgt über dein Array (fields[Spalte][Reihe]):

for (size_t y = 0; y < anzahlReihen; ++y)
{
    if (fields[x][y] == 0)
    {
        // Reihe y gefunden, Stein setzen (Pseudocode!)
        fields[x][y] = "Spieler 1"|"Spieler 2";

        break; // Aus der Schleife springen
    }
}

1. Hier würde ich so rangehen: Du durchläufst die Felder in 2 Schleifen spalten- und reihenweise und wiederum innerhalb kommen zwei weiter Schleifen hinzu, die die Richtung der "Suche" angeben. Sie gehen von -1 bis 1, damit steht -1 für links/oben und 1 für rechts/unten. Du brauchst diese Richtung einfach auf die aktuelle Position zu addieren und zu überprüfen, ob du immernoch einen gleichfarbigen Stein findest. Wenn du bei 4 angekommen bist, hast du eine Reihe gefunden.