Aktuell wird der gewinner ja durch:

printf(" Spieler %d hat gewonnen!\n", player);

angezeigt.

wie kriege ich es hin also mit else und sowas.
Das er für beide spieler extra cout zeilen habe?

also ungefähr so

else
{
cout<<"spieler 1 hat gewonnen";
else if
{
cout <<"Spieler 2 hat gewonnen";

damit will ich bezwecken das er die spieler namen anzeigt.

sprich

Thomas hat gewonnen

cout<<playername[x]," hat gewonnen !";

wenn man die Spieler namen vorher definiert, oder habe ich was falsch verstanden ?

//...
cout << spieler1 << " hat gewonnen!"; //spieler1 ist die Variable
//...

cout << " Spieler 1:";
    cout << " ";
    cin  >> spieler1;
    cout << ""<< endl;
    cout << " Spieler 2:";
    cout << " ";
    cin  >> spieler2;

Du musst die Spielernamen am Anfang deines Programms einlesen und es dann so ausgeben

//...
cout << spieler1 << " hat gewonnen!"; //spieler1 ist die Variable
//...

habe ich ja wie man ein oberen post sieht.

bloss

cout << spieler1 << " hat gewonnen!";

würde ja nur sagen das spieler 1 immer gewinnt

ich geh mal von etwas dieser art aus:

#include <iostream>
#include <string>
#include <cstdlib>

using namespace std;

main()
{

cout<<"wie heißt du Spieler 1 ?: "<<namevonspieler[1];
getline(cin,namevonspieler[1]); // einlesen als String
cout<<"wie heißt du Spieler 2 ?: "<<namevonspieler[2];
getline(cin,namevonspieler[2]); // einlesen als String
cout<<"das Spiel kann beginnen"
cin.get();

// und so weiter was das auch immer für ein game ist ...

int winner;
if(punktesp[1] > punktesp[2]) // sp1 hat mehr punkte als sp2
winner = 1; // gewinner ist sp1
else
winner = 2;

//oder ähnlich, je nach spieler anzahl

if(winner = 1)
cout<<namevonspieler[1]<<" hat das spiel gewonnen";
else
cout<<namevonspieler[2]<<" hat das spiel gewonnen";
cin.get();
return 0;
}

ich nehme an ungefähr so soll das aussehen oder ?

Harald44 schrieb:

Jorckel schrieb:

Du musst die Spielernamen am Anfang deines Programms einlesen und es dann so ausgeben

//...
cout << spieler1 << " hat gewonnen!"; //spieler1 ist die Variable
//...

habe ich ja wie man ein oberen post sieht.

bloss

cout << spieler1 << " hat gewonnen!";

würde ja nur sagen das spieler 1 immer gewinnt

Nein würde es nicht heißen, es würde heißen das der Spieler ausgegeben wird, welche am Start des Programmes ausgegeben hat.

Schau dir lieber nochmal die Grundlagen, wie Eingabe,Ausgabe,Variablen und Arrays an.

if ( nInARow(row, column, player,WIN_COUNT) )  // Beende das Spiel, falls eine Gewinnsituation aufgetreten ist oder das
              {                         // Spielbrett voll ist

ich wette das ist kopiert worden, vielleicht solltest du dir zu anfang was einfacheres ansehen, nur so als tipp, nimms mir nicht übel
[/quote]

Der Lehrer hat selbst gesagt da wir nur paar Monate Algo haben und nicht in der Lage sind ein eigenes programm zu programmieren, das wir aus dem internet eins runterladen und es abändern können.

hier der gesamte code:

//-----------------------------------------------------------------------------
// INCLUDES
//-----------------------------------------------------------------------------

#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <windows.h>
#include <conio.h>
#include <iostream.h>
#include "vollbild.h"

const unsigned short player1 = 14;
const unsigned short player2 = 10;
const unsigned short text = 15;
const unsigned short bannerf1 = 15;
const unsigned short bannerf2 = 14;

//-----------------------------------------------------------------------------
// TYPEN
//-----------------------------------------------------------------------------

enum BoardCell                /// Belegungsarten einer Spielbrettzelle
{
   NO_PIECE,                /// Kein Spielstein
   PLAYER1,                /// Spielstein von Spieler 1
   PLAYER2                /// Spielstein von Spieler 2
};

//-----------------------------------------------------------------------------
// KONSTANTEN (Konfiguration des Spieles)
//-----------------------------------------------------------------------------

const int PLAYFIELD_WIDTH  = 7;     /// Breite des Spielfeldes
const int PLAYFIELD_HEIGHT = 6;    /// Höhe des Spielfeldes
const int WIN_COUNT        = 4;   /// Anzahl der konsekutiven Steine für eine Gewinnsituation

//-----------------------------------------------------------------------------
// GLOBALE VARIABLEN
//-----------------------------------------------------------------------------

BoardCell board[PLAYFIELD_HEIGHT][PLAYFIELD_WIDTH]; /// Spielbrett
int numFreeCells[PLAYFIELD_WIDTH];                 /// Anzahl der freien Zellen in einer Spalte

//-----------------------------------------------------------------------------
// FUNKTIONEN
//-----------------------------------------------------------------------------

void color(unsigned short color)
{
    HANDLE hcon = GetStdHandle(STD_OUTPUT_HANDLE);
    SetConsoleTextAttribute(hcon,color);
}

void initBoard()
{

  for ( int column = 0; column < PLAYFIELD_WIDTH; column ++ ) // Über die Spalten iterieren
  {
  for ( int row = 0; row < PLAYFIELD_HEIGHT; row ++ )   // Über die Zeilen iterieren
    {
     board[row][column] = NO_PIECE;       // Inhalt der Spielfeldzelle zurücksetzen
    }
     numFreeCells[column] = PLAYFIELD_HEIGHT;    // Anzahl der freien Zellen pro Spalte initialisieren

   }
 }

//-----------------------------------------------------------------------------

void printBoard()
{
    cout << endl << endl;
    cout << " ";
for (int column = 0; column < PLAYFIELD_WIDTH; column ++ )  // Spaltennummern ausgeben
    {
        cout << "";
        cout << column;
    }
    cout << endl;

    cout << " ";
for (int column = 0; column < PLAYFIELD_WIDTH; column ++ )     // Oberen Spielfeldrand ausgeben
    {

        cout << "-";
    }
    cout << endl;

    cout << " ";
    for ( int row = 0; row < PLAYFIELD_HEIGHT; row ++ )   // Über die Zeilen iterieren
    {
    cout << " ";
    for ( int column = 0; column < PLAYFIELD_WIDTH; column ++ )   // Über die Spalten iterieren
        {

            if (board[row][column] == PLAYER1)          // Inhalt der Zelle ausgeben
            {
                color(player1);
                cout << "X";
                color(text);
            }
            else if (board[row][column] == PLAYER2)
            {
                color(player2);
                cout << "O";
                color(text);
            }
            else
                cout << " ";
                  }

        cout << endl;                     // Nächste zeile
    }

    cout << " ";
    for (int column = 0; column < PLAYFIELD_WIDTH; column ++ )     // Unteren Spielfeldrand ausgeben
    {

        cout << "-";
    }
    cout << endl;
    cout << endl;

}

//-----------------------------------------------------------------------------

BoardCell getCell( int row, int column )
{

    if (row >= 0 && row < PLAYFIELD_HEIGHT && column >= 0 && column < PLAYFIELD_WIDTH)
        return board[row][column];
    else
        return NO_PIECE;
}

//-----------------------------------------------------------------------------

int countPieces(int row, int column, int dx, int dy, BoardCell player)
{

  assert(row>=0 && row < PLAYFIELD_HEIGHT && column>=0 && column < PLAYFIELD_WIDTH); // Stelle sicher, dass Referenzposition innerhalb des Spielfeldes liegt

  if (getCell(row,column) == player)
  {

    int count = 1;       // Zähler initialisieren (mindestens 1 Stein)

    int sy1=row;              // Scankoordinaten
    int sx1=column;

    while ( getCell(sy1+dy,sx1+dx) == player )   // Erhöhe Zähler, solange von Referenzposition row,column ausgehend
    {                                           // in Richtung dy,dx weitere Steine von Spieler player folgen

      sy1+=dy;          // Scankoordinaten aktualisieren
      sx1+=dx;

      count++;         // Weiterzählen
    }

    int sy2=row;           // Scankoordinaten
    int sx2=column;

    while ( getCell(sy2-dy,sx2-dx) == player )       // Erhöhe Zähler, solange von Referenzposition row,column ausgehend
        {                                            // in Richtung -dy,-dx weitere Steine von Spieler player folgen

      sy2-=dy;    // Scankoordinaten aktualisieren
      sx2-=dx;

      count++;        // Weiterzählen
    }

    return count;      // Zähler zurückgeben

  }
  else
    return 0;

}

//-----------------------------------------------------------------------------

bool nInARow( int row, int column, BoardCell player, int n)
{
    assert(row >= 0 && row < 6 && column >= 0 && column < 7);
    assert(board[row][column] == player);

    if (countPieces(row,column,1,0,player)>=n) return true;     // Horizontaler Fall

    if (countPieces(row,column,0,1,player)>=n) return true;    // Vertikaler Fall

    if (countPieces(row,column,1,1,player)>=n) return true;    // Hauptdiagonale "\"

    if (countPieces(row,column,-1,1,player)>=n) return true;  // Nebendiagonale "/"

    return false;       // Keiner der Fälle ist eingetreten => keine Gewinnsituation
}

//-----------------------------------------------------------------------------

bool boardIsFull()
{
    for ( int column = 0; column < PLAYFIELD_WIDTH; column ++ )
    {
        if ( numFreeCells[column] > 0 ) return false;  // Falls mindestens eine nicht volle Spalte gefunden wird
        }   // so ist das Brett nicht leer

    return true;      // Spielbrett voll
}

void banner()
{
       //Banner

        color(text);
     cout<<""<<endl;   
     cout<<" °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°"<<endl;
     color(bannerf2);
     cout<<" .............................................................................."<<endl;
     cout<<" ..##............######...########.##......##.####.##....##.##....##.########.."<<endl;
     cout<<" ..##....##.....##....##..##.......##..##..##..##..###...##.###...##....##....."<<endl;
     cout<<" ..##....##.....##........##.......##..##..##..##..####..##.####..##....##....."<<endl;
     cout<<" ..##....##.....##...####.######...##..##..##..##..##.##.##.##.##.##....##....."<<endl;
     cout<<" ..#########....##....##..##.......##..##..##..##..##..####.##..####....##....."<<endl;
     cout<<" ........##.....##....##..##.......##..##..##..##..##...###.##...###....##....."<<endl;
     cout<<" ........##......######...########..###..###..####.##....##.##....##....##....."<<endl;
     cout<<" .............................................................................."<<endl;
     color(text);
     cout<<" °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°";
     color(bannerf2);
     cout<<" by GSGT Games ";
     color(text);
     cout<<"°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°"<<endl;
     color(bannerf1);

}

void anleitung()
{
     system("cls");
     banner();

    cout << "" << endl;
    cout << "" << endl;
    cout<<"\t\t\t\t***************"<<endl;
    cout<<"\t\t\t\t*";
    cout<<"  Anleitung  ";
    cout<<"*"<<endl;
    cout<<"\t\t\t\t***************"<<endl;

   cout<<""<<endl;  
   cout<<""<<endl;
   cout<<""<<endl;
   cout<<"  Ziel des Spieles ist es, als erster 4 Steine seiner Farbe in eine"<<endl;
   cout<<"  Reihe zu bekommen."<<endl;
   cout<<""<<endl;
   cout<<"  Die Steinfarben sind f\x81r Spieler 1";
   color(player1);
   cout<<" (GELB)";
   color(text);
   cout<<" und Spieler 2";
   color(player2);
   cout<<" (GR\x9aN)"<<endl;
   color(text);
   cout<<""<<endl;
   cout<<"  Es wird abwechselnd je 1 Stein der eigenen Farbe"<<endl;
   cout<<"  in die Felder fallen gelassen."<<endl;
   cout<<""<<endl;
   cout<<"  Dies kann man tun mit den Tasten 0,1,2,3,4,5,6. "<<endl;
   cout<<"  Wobei 0 f\x81r die ganz linke Spalte sowie 6 f\x81r ganz rechte Spalte steht."<<endl;
   cout<<"  Durch Strategie und Taktik versucht man nun, mit den eigenen Steinen"<<endl;
   cout<<"  eine 4er-Reihe zu bilden."<<endl;
   cout<<""<<endl;
   cout<<"  Die Reihen k\x94nnen entweder"<<endl;
   cout<<"  -senkrecht"<<endl;
   cout<<"  -waagerecht"<<endl;
   cout<<"  -diagonal"<<endl;
   cout<<"  angeordnet sein."<<endl;
   cout<<""<<endl;
   cout<<"  Dabei darf man aber nie den Gegner aus den Augen lassen,"<<endl;
   cout<<"  denn wenn er eine Zwickm\x81hle bildet, kann bald alles zu sp\x84t sein!"<<endl;
   cout<<"  Man muss also gleichzeitig verhindern, dass er zuvor eine"<<endl;
   cout<<"  4er-Reihe zustande bringt."<<endl;
   cout<<""<<endl;
   cout<<""<<endl;
   cout<<""<<endl;
   cout<<"                Beliebige Taste dr\201cken um zum Men\201 zugelangen"<<endl;
     getch();

     system("cls");
}

int spiel(void)
{

    char taste;

    banner();

    char spieler1[15], spieler2[15];

    cout << "" << endl;
    cout << "" << endl;
    cout<<"\t\t\t\t***************"<<endl;
    cout<<"\t\t\t\t*";
    cout<<"    Namen  ";
    cout<<"  *"<<endl;
    cout<<"\t\t\t\t***************"<<endl;
    cout << ""<< endl;
    cout << ""<< endl;
    cout << ""<< endl;
    color(player1);
    cout << " Spieler 1:";
    cout << " ";
    cin  >> spieler1;
    cout << ""<< endl;
    color(player2);
    cout << " Spieler 2:";
    cout << " ";
    cin  >> spieler2;
    color(text);

    system("cls");
    banner();  

    initBoard();          // Initialisiere das Spielbrett und gebe es aus
    printBoard();

    BoardCell player = PLAYER1;    // Aktueller Spieler

    while ( true )
    {

        int column;    // Fordere Spieler zur Eingabe eines Spielzuges auf

        if (player == PLAYER1)
{
color(player1);
cout <<" ";
cout << spieler1<<": ";
color(text);
}else
{
color(player2);
cout <<" ";
cout << spieler2<<": ";
color(text);
}

        int res = scanf("%d", &column);

        while ( res != 1 || column < 0 || column >= PLAYFIELD_WIDTH || numFreeCells[column] == 0 )        // Wiederhole, falls Eingabe ungültig
           {      // (kein Integer eingegeben  oder  ungültige Spaltennummer  oder  Spalte bereits voll)
            if ( res != 1 )
                fflush(stdin);
            cout <<" ";
            cout << "Ung\201ltig. Nochmal: ";
            res = scanf("%d", &column);
        }

        numFreeCells[column] --;             // Aktualisiere den Zustand des Spielbrettes
        int row = numFreeCells[column];
        board[row][column] = player;

        system("cls");
        banner();
        printBoard();                 // Gebe das Spielbrett aus

if ( nInARow(row, column, player,WIN_COUNT) )  // Beende das Spiel, falls eine Gewinnsituation aufgetreten ist oder das
              {                         // Spielbrett voll ist

           printf(" Spieler %d hat gewonnen!\n", player);

            getch();
            break;
        }
        else if ( boardIsFull() )
        {
            printf("Unentschieden!\n");
            getch();
            break;
        }

        player = (player == PLAYER1) ? PLAYER2 : PLAYER1;             // der nächste Spieler ist an der Reihe

    }
}

//-----------------------------------------------------------------------------
// MAIN
//-----------------------------------------------------------------------------

int main()           /// Hauptprogramm
{
    char taste;

    vollbild(true);

    menue:

    banner();

    cout << "" << endl;
    cout << "" << endl;
    cout<<"\t\t\t\t***************"<<endl;
    cout<<"\t\t\t\t*";
    cout<<"     Men\201  ";
    cout<<"  *"<<endl;
    cout<<"\t\t\t\t***************"<<endl;

    cout << "" << endl;
    cout << "" << endl;
    cout << "" << endl;
    cout << " (S)piel starten" << endl;
    cout << "" << endl;
    cout << " (A)nleitung" << endl;
    cout << "" << endl;
    cout << " (B)eenden" << endl;

   taste = getch();

    switch(taste)
    {
        case 'S':
        case 's':
             system("cls");
             spiel();
             system("cls");
             goto menue;

        break;

        case 'A':
        case 'a':
             anleitung();
             system("cls");
             goto menue;
        break;

        case 'B':
        case 'b':
             return 0;

        default:
             system("cls");
             goto menue;

      }

    return 0;
}

ich würde gerne mit deinem Programm 4 ewinnt etwas spielen, als mit dem code.

Aber dafür fehlt mir die vollbild.h

Hast du diese noch?

hatj emand ne idee wie ich das machen kann mit dem ausgeben des gewinnerS?

hatj emand ne idee wie ich das machen kann mit dem ausgeben des gewinnerS?

Die Antworten, sowie Suchbegriffe wurden dir schon ausreichend gegeben.

Eigentlich zu viel hilfe ^^

Keros

player = (player == PLAYER1);
if
{
cout << spieler1<<"hat gewonnen!";
}
else if
{
cout << spieler2<<"hat gewonnen!";
}

der meckert das ein fehler ist in der klammer nach dem IF

cout << " Spieler 1:";
    cout << " ";
    cin  >> spieler1;
    cout << ""<< endl;
    cout << " Spieler 2:";
    cout << " ";
    cin  >> spieler2;

[quote]

wenn du das machst, sollte nach dem IF kein Fehler sien, ich denke jetzt das er die variable spieler1 nicht hat...

Vor allem weil man das gleich nach Hello World in jeder Sprache beigebracht bekommt. Das hat nix mit Profi und so zu tun sondern sind einfach nur Grundlagen. Ohne diese sollte dich den Prof mit, sagen wir mal wiederholen bewerten

Du brauchst dir ja nur mal den geladenen Code ansehen und darin wirst du viele if Anweisungen sehen und wie sie aufgebaut sind.

Keros

viergewinnt.h

class viergewinnt
{  int p[7][5];
   int s;
   int chance;
   public:
        viergewinnt();
        void setP1(int wahl);
        void setP2(int wahl);
        void matrix();
        char getm(int x, int y);
        void ruecksetzten();
        bool nextP(); 
        int win();
        void setFW(int farbe);
        int zugPC();    
};

viergewinnt.cpp

#include <iostream>
#include "viergewinnt.h"
#include <windows.h> 
#include <math.h>
using namespace std;

viergewinnt::viergewinnt()
{  s=0;
   for(int i=0; i<7; i++)
      for(int i2=0; i2<5; i2++)
      p[i][i2]=0;
}
void viergewinnt::ruecksetzten()
{  s=0;
   for(int i=0; i<7; i++)
      for(int i2=0; i2<5; i2++)
      p[i][i2]=0;
}
bool viergewinnt::nextP()
{
    if(s==0)return true;
    else return false; 
}
void viergewinnt::setP1(int wahl)
{  if(wahl >=1 && wahl <=7)
   { 
     switch(wahl)
    {
        case 1:if     (p[0][0]==0){p[0][0]=1;s=1;}
               else if(p[0][1]==0){p[0][1]=1;s=1;}
               else if(p[0][2]==0){p[0][2]=1;s=1;}
               else if(p[0][3]==0){p[0][3]=1;s=1;}
               else if(p[0][4]==0){p[0][4]=1;s=1;}break;
        case 2:if     (p[1][0]==0){p[1][0]=1;s=1;}
               else if(p[1][1]==0){p[1][1]=1;s=1;}
               else if(p[1][2]==0){p[1][2]=1;s=1;}
               else if(p[1][3]==0){p[1][3]=1;s=1;}
               else if(p[1][4]==0){p[1][4]=1;s=1;}break;
        case 3:if     (p[2][0]==0){p[2][0]=1;s=1;}
               else if(p[2][1]==0){p[2][1]=1;s=1;}
               else if(p[2][2]==0){p[2][2]=1;s=1;}
               else if(p[2][3]==0){p[2][3]=1;s=1;}
               else if(p[2][4]==0){p[2][4]=1;s=1;}break;
        case 4:if     (p[3][0]==0){p[3][0]=1;s=1;}
               else if(p[3][1]==0){p[3][1]=1;s=1;}
               else if(p[3][2]==0){p[3][2]=1;s=1;}
               else if(p[3][3]==0){p[3][3]=1;s=1;}
               else if(p[3][4]==0){p[3][4]=1;s=1;}break;
        case 5:if     (p[4][0]==0){p[4][0]=1;s=1;}
               else if(p[4][1]==0){p[4][1]=1;s=1;}
               else if(p[4][2]==0){p[4][2]=1;s=1;}
               else if(p[4][3]==0){p[4][3]=1;s=1;}
               else if(p[4][4]==0){p[4][4]=1;s=1;}break;
        case 6:if     (p[5][0]==0){p[5][0]=1;s=1;}
               else if(p[5][1]==0){p[5][1]=1;s=1;}
               else if(p[5][2]==0){p[5][2]=1;s=1;}
               else if(p[5][3]==0){p[5][3]=1;s=1;}
               else if(p[5][4]==0){p[5][4]=1;s=1;}break;
        case 7:if     (p[6][0]==0){p[6][0]=1;s=1;}
               else if(p[6][1]==0){p[6][1]=1;s=1;}
               else if(p[6][2]==0){p[6][2]=1;s=1;}
               else if(p[6][3]==0){p[6][3]=1;s=1;}
               else if(p[6][4]==0){p[6][4]=1;s=1;}break;
    }
    }     
}

void viergewinnt::setP2(int wahl)
{  
   if(wahl >=1 && wahl <=7)
   { 
   switch(wahl)
    {
        case 1:if     (p[0][0]==0){p[0][0]=2;s=0;}
               else if(p[0][1]==0){p[0][1]=2;s=0;}
               else if(p[0][2]==0){p[0][2]=2;s=0;}
               else if(p[0][3]==0){p[0][3]=2;s=0;}
               else if(p[0][4]==0){p[0][4]=2;s=0;}break;
        case 2:if     (p[1][0]==0){p[1][0]=2;s=0;}
               else if(p[1][1]==0){p[1][1]=2;s=0;}
               else if(p[1][2]==0){p[1][2]=2;s=0;}
               else if(p[1][3]==0){p[1][3]=2;s=0;}
               else if(p[1][4]==0){p[1][4]=2;s=0;}break;
        case 3:if     (p[2][0]==0){p[2][0]=2;s=0;}
               else if(p[2][1]==0){p[2][1]=2;s=0;}
               else if(p[2][2]==0){p[2][2]=2;s=0;}
               else if(p[2][3]==0){p[2][3]=2;s=0;}
               else if(p[2][4]==0){p[2][4]=2;s=0;}break;
        case 4:if     (p[3][0]==0){p[3][0]=2;s=0;}
               else if(p[3][1]==0){p[3][1]=2;s=0;}
               else if(p[3][2]==0){p[3][2]=2;s=0;}
               else if(p[3][3]==0){p[3][3]=2;s=0;}
               else if(p[3][4]==0){p[3][4]=2;s=0;}break;
        case 5:if     (p[4][0]==0){p[4][0]=2;s=0;}
               else if(p[4][1]==0){p[4][1]=2;s=0;}
               else if(p[4][2]==0){p[4][2]=2;s=0;}
               else if(p[4][3]==0){p[4][3]=2;s=0;}
               else if(p[4][4]==0){p[4][4]=2;s=0;}break;
        case 6:if     (p[5][0]==0){p[5][0]=2;s=0;}
               else if(p[5][1]==0){p[5][1]=2;s=0;}
               else if(p[5][2]==0){p[5][2]=2;s=0;}
               else if(p[5][3]==0){p[5][3]=2;s=0;}
               else if(p[5][4]==0){p[5][4]=2;s=0;}break;
        case 7:if     (p[6][0]==0){p[6][0]=2;s=0;}
               else if(p[6][1]==0){p[6][1]=2;s=0;}
               else if(p[6][2]==0){p[6][2]=2;s=0;}
               else if(p[6][3]==0){p[6][3]=2;s=0;}
               else if(p[6][4]==0){p[6][4]=2;s=0;}break;
    }
    }      
}

char viergewinnt::getm(int x, int y)
{   if(p[x][y] == 2){setFW(10);return 'O';}
    if(p[x][y] == 1){setFW(12);return 'X';}
    if(p[x][y] == 0)return ' ';
}

void viergewinnt::setFW(int farbe)
{
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), farbe);     
}

void viergewinnt::matrix()
{  setFW(15);
   cout<<endl<<"    1   2   3   4   5   6   7 "<<endl;
   for(int i=4; i>=0; i--)
   { 
      cout<<"  +---+---+---+---+---+---+---+"<<endl;
       cout<<"  | ";setFW(15);
       cout<<getm(0,i);
       setFW(15);cout<<" | ";
       cout<<getm(1,i);
       setFW(15);cout<<" | ";
       cout<<getm(2,i);
       setFW(15);cout<<" | ";
       cout<<getm(3,i);
       setFW(15);cout<<" | ";
       cout<<getm(4,i);
       setFW(15);cout<<" | ";
       cout<<getm(5,i);
       setFW(15);cout<<" | ";
       cout<<getm(6,i);
       setFW(15);cout<<" | "<<endl;

}

cout<<"  +---+---+---+---+---+---+---+"<<endl;
}

int viergewinnt::win()
{  for(int i=1; i<3; i++)
  {if(p[0][0] == i && p[0][1] == i && p[0][2] == i && p[0][3] == i)return 1;
   if(p[0][1] == i && p[0][2] == i && p[0][3] == i && p[0][4] == i)return 1;
   if(p[1][0] == i && p[1][1] == i && p[1][2] == i && p[1][3] == i)return 1;
   if(p[1][1] == i && p[1][2] == i && p[1][3] == i && p[1][4] == i)return 1;
   if(p[2][0] == i && p[2][1] == i && p[2][2] == i && p[2][3] == i)return 1;
   if(p[2][1] == i && p[2][2] == i && p[2][3] == i && p[2][4] == i)return 1;
   if(p[3][0] == i && p[3][1] == i && p[3][2] == i && p[3][3] == i)return 1;
   if(p[3][1] == i && p[3][2] == i && p[3][3] == i && p[3][4] == i)return 1;
   if(p[4][0] == i && p[4][1] == i && p[4][2] == i && p[4][3] == i)return 1;
   if(p[4][1] == i && p[4][2] == i && p[4][3] == i && p[4][4] == i)return 1;
   if(p[5][0] == i && p[5][1] == i && p[5][2] == i && p[5][3] == i)return 1;
   if(p[5][1] == i && p[5][2] == i && p[5][3] == i && p[5][4] == i)return 1;
   if(p[6][0] == i && p[6][1] == i && p[6][2] == i && p[6][3] == i)return 1;
   if(p[6][1] == i && p[6][2] == i && p[6][3] == i && p[6][4] == i)return 1;

   if(p[0][0] == i && p[1][0] == i && p[2][0] == i && p[3][0] == i)return 1;
   if(p[1][0] == i && p[2][0] == i && p[3][0] == i && p[4][0] == i)return 1;
   if(p[2][0] == i && p[3][0] == i && p[4][0] == i && p[5][0] == i)return 1;
   if(p[3][0] == i && p[4][0] == i && p[5][0] == i && p[6][0] == i)return 1;

   if(p[0][1] == i && p[1][1] == i && p[2][1] == i && p[3][1] == i)return 1;
   if(p[1][1] == i && p[2][1] == i && p[3][1] == i && p[4][1] == i)return 1;
   if(p[2][1] == i && p[3][1] == i && p[4][1] == i && p[5][1] == i)return 1;
   if(p[3][1] == i && p[4][1] == i && p[5][1] == i && p[6][1] == i)return 1;

   if(p[0][2] == i && p[1][2] == i && p[2][2] == i && p[3][2] == i)return 1;
   if(p[1][2] == i && p[2][2] == i && p[3][2] == i && p[4][2] == i)return 1;
   if(p[2][2] == i && p[3][2] == i && p[4][2] == i && p[5][2] == i)return 1;
   if(p[3][2] == i && p[4][2] == i && p[5][2] == i && p[6][2] == i)return 1;

   if(p[0][3] == i && p[1][3] == i && p[2][3] == i && p[3][3] == i)return 1;
   if(p[1][3] == i && p[2][3] == i && p[3][3] == i && p[4][3] == i)return 1;
   if(p[2][3] == i && p[3][3] == i && p[4][3] == i && p[5][3] == i)return 1;
   if(p[3][3] == i && p[4][3] == i && p[5][3] == i && p[6][3] == i)return 1;

   if(p[0][4] == i && p[1][4] == i && p[2][4] == i && p[3][4] == i)return 1;
   if(p[1][4] == i && p[2][4] == i && p[3][4] == i && p[4][4] == i)return 1;
   if(p[2][4] == i && p[3][4] == i && p[4][4] == i && p[5][4] == i)return 1;
   if(p[3][4] == i && p[4][4] == i && p[5][4] == i && p[6][4] == i)return 1;

   if(p[0][0] == i && p[1][1] == i && p[2][2] == i && p[3][3] == i)return 1;
   if(p[0][1] == i && p[1][2] == i && p[2][3] == i && p[3][4] == i)return 1;
   if(p[1][1] == i && p[2][2] == i && p[3][3] == i && p[4][4] == i)return 1;
   if(p[1][0] == i && p[2][1] == i && p[3][2] == i && p[4][3] == i)return 1;
   if(p[2][1] == i && p[3][2] == i && p[4][3] == i && p[5][4] == i)return 1;
   if(p[2][0] == i && p[3][1] == i && p[4][2] == i && p[5][3] == i)return 1;
   if(p[3][1] == i && p[4][2] == i && p[5][3] == i && p[6][4] == i)return 1;
   if(p[3][0] == i && p[4][1] == i && p[5][2] == i && p[6][3] == i)return 1;

   if(p[6][1] == i && p[5][2] == i && p[4][3] == i && p[3][4] == i)return 1;
   if(p[6][0] == i && p[5][1] == i && p[4][2] == i && p[3][3] == i)return 1;
   if(p[5][1] == i && p[4][2] == i && p[3][3] == i && p[2][4] == i)return 1;
   if(p[5][0] == i && p[4][1] == i && p[3][2] == i && p[2][3] == i)return 1;
   if(p[4][1] == i && p[3][2] == i && p[2][3] == i && p[1][4] == i)return 1;
   if(p[4][0] == i && p[3][1] == i && p[2][2] == i && p[1][3] == i)return 1;
   if(p[3][1] == i && p[2][2] == i && p[1][3] == i && p[0][4] == i)return 1;
   if(p[3][0] == i && p[2][1] == i && p[1][2] == i && p[0][3] == i)return 1;
   }

}

int viergewinnt::zugPC()
{  srand (time(NULL));
    return rand()%7;
}

main.cpp

#include <iostream>

using namespace std;

#include "viergewinnt.h"
int main(int argc, char *argv[])
{   viergewinnt spiel;
    int wahl, wahlpc;
    spiel.matrix();
    cout<<"    Player vs Player?   - 1"<<endl<<"    Player vs Computer? - 2  ";
    cin>>wahlpc;
    switch(wahlpc)
    {
        case 1: while (spiel.win() != 1)
                {  
                    if(spiel.nextP()) { spiel.setFW(12); cout<<endl<<"       Spieler 1 (1-7): ";}
                    else {spiel.setFW(10);cout<<endl<<"       Spieler 2 (1-7): ";}
                    cin>>wahl;
                    system("cls");
                    if(spiel.nextP())spiel.setP1(wahl);
                    else spiel.setP2(wahl);
                    spiel.matrix();

                }

                if(spiel.win() == 1)if(spiel.nextP())  {spiel.setFW(10); cout<<endl<<endl<<"        Spieler 2";spiel.setFW(9);cout<<" WIN!";}
                else { spiel.setFW(12);cout<<endl<<endl<<"        Spieler 1";spiel.setFW(9);cout<<" WIN!";}
                break;
        case 2: while (spiel.win() != 1)
                {  
                    if(spiel.nextP()) { spiel.setFW(12); cout<<endl<<"       Spieler 1 (1-7): ";}
                    else {spiel.setFW(10);cout<<endl<<"       Comp 2 (1-7): ";}
                    if(spiel.nextP())cin>>wahl;
                    system("cls");
                    if(spiel.nextP())spiel.setP1(wahl);
                    else spiel.setP2(spiel.zugPC());
                    spiel.matrix();

                }

                if(spiel.win() == 1)if(spiel.nextP())  {spiel.setFW(10); cout<<endl<<endl<<"        Computer";spiel.setFW(9);cout<<" WIN!";}
                else { spiel.setFW(12);cout<<endl<<endl<<"        Spieler 1";spiel.setFW(9);cout<<" WIN!";}
                break;

    }

    spiel.ruecksetzten();

    system("PAUSE>NUL");
    return EXIT_SUCCESS;
}

nicht schimpfen...

if
player = (player == PLAYER1)
{
cout << spieler1<<"hat gewonnen!";
}
else if
{
cout << spieler2<<"hat gewonnen!";
}

jetzt meckert er bei

player = (player == PLAYER1)

Hier ist sogar nochn Tut
http://tutorial.schornboeck.net/if.htm

Alta ich hab heute echt meinen guten Tag

Keros

if (player == PLAYER1)
{
...
}

hf

geht immer noch nicht

if (player == PLAYER1)
{
cout << spieler1<<"hat gewonnen!";
}
else if
{
cout << spieler2<<"hat gewonnen!";
}