wie weise ich gepopte list items einer variable zu ?

T0bi

hi,
ich habe hier ener liste voll mit struct items und e3in array des types. nun moechte ich die items in der liste den array zuweisen.

-die liste besteht aus strcut items

list< _Struct > stack;
_Struct array[ 5 ]; <- dieses array ist in einer weiteren struct deklariert
Tester tester;

wie komm ich nun in einer for()-schleife zu ziel?

for( ... ) {

tester.array[ i ] = stack. <--- geht aber nicht

COMPILER:
"[C++ Error] MauMau.cpp(70): E2109 Not an allowed type"

wieso geht des net und wie mach ichs beser?

Gruß Tobi.

CStoll

Kannst du mal bitte etwas mehr zeigen als ein paar unzusammenhängende Fragmente?

(allgemein - list<>s bieten keinen Direktzugriff per Index. Aber du kannst per stack.front() das erste und per stack.back() das letzte Element deiner Liste herausgreifen (um alle Elemente zu bekommen, mußt du mit einem Iterator sequenziell durchlaufen))

Werner Salomon

Hallo Tobi,

Deine Frage scheint mir etwas ungenau formuliert. Ich vermute mal Du hast in etwa so eine Struktur

struct Struct
{
    int m_dummy; // egal
};

struct Tester
{
    static int const array_size = 5;
    Struct m_array[array_size];
};

und eine std::list< Struct >, die in das m_array eines Tester-Objekts kopiert werden sollen. Das geht mit einer for-Schleife so:

list< Struct > stack;  
    // stack füllen 
    Tester tester;
    list< Struct >::iterator j = stack.begin();
    for( int i=0; i<Tester::array_size && j != stack.end(); ++i, ++j )
    {
        tester.m_array[i] = *j;
    }

eleganter aber mit einem std::copy - also

assert( stack.size() <= Tester::array_size ); // erst prüfen, dass array nicht überläuft
    copy( stack.begin(), stack.end(), tester.m_array );

Für letzteres braucht man die Includes <algorithm> und <cassert>.

Oder - noch 'ne Nummer eleganter; man kann auch eine Zuweisung daraus machen.

struct Tester
{
    template< typename C >  // C: Container-Klasse
    Tester& operator=( const C& c )
    {
        using namespace std;
        assert( c.size() <= Tester::array_size ); // erst prüfen, dass array nicht überläuft
        copy( c.begin(), c.end(), m_array );
        return *this;
    }

    static int const array_size = 5;
    Struct m_array[array_size];
};

// -- Aufruf; (Variablen s.o.)
    tester = stack;

Das bitte aber nur, wenn m_array der einzige (bzw. fast der einzige) Member in der struct Tester ist.

Gruß
Werner

T0bi

hmm... also irgendwie komm ich net mit klar... *brett vorm kop -.-*
ich schick euch mal den quelltext, ist ja noch nicht so viel.

es soll nen kleines MauMau spiel werden... im mom sollen nur die karten init werdenund in eine liste geladen werden... und dann auf 4spieler verteilt werden.

#include <iostream>
#include <iomanip>
#include <list>
#include <conio>
#include <ctime>
    using namespace std;

#pragma hdrstop
#pragma argsused

#define MAX_CARDS 32

struct Cards {

    char _color[8];
    char _value[4];
    int color;
    int value;
};

struct Player {

    Cards _cards[ 5 ];  // 5 cards for each player
    int wins;
    int lose;
};

void intCards( Cards stack[ MAX_CARDS ], list< Cards > con ) {

    bool isInStack;
    char *_color[] = { "Heart", "Caro", "Pike", "Cross" };
    char *_value[] = { "7", "8", "9", "10", "J", "Q", "K", "A" };

    for( int i = 0; i < MAX_CARDS; i++ ) {

        do {

            stack[ i ].color = rand() % 4;
            stack[ i ].value = rand() % 8;

            isInStack = false;
            for( int j = 0; j < i; j++ ) {

                if( ( stack[ j ].color == stack[ i ].color ) &&
                    ( stack[ j ].value == stack[ i ].value ) ) {

                    isInStack = true;

                }
            }
        } while( isInStack );
    }

    for( int i = 0; i < MAX_CARDS; i++ ) {

        strcpy( stack[ i ]._color, _color[ stack[ i ].color ] );
        strcpy( stack[ i ]._value, _value[ stack[ i ].value ] );
        con.push_back( stack[ i ] );
    }
}

void givePlayerCards( Player player[ 4 ], list< Cards > con ) {

    Cards current;

    // hand Player1 cards
    for( int i = 0; i < 5; i++ ) {

        current = con.back();
   //    player[ 0 ]._cards[ i ] = current;
        strcpy( player[ 0 ]._cards[ i ]._color, current._color );
        strcpy( player[ 0 ]._cards[ i ]._value, current._value );
        con.pop_back();
    }

/*    // hand Player2 cards
    for( int i = 0; i < 5; i++ ) {

        strcpy( player[ 1 ]._cards[ i ]._color, stack[ i+5 ]._color );
        strcpy( player[ 1 ]._cards[ i ]._value, stack[ i+5 ]._value );
    }

    // hand Player3 cards
    for( int i = 0; i < 5; i++ ) {

        strcpy( player[ 2 ]._cards[ i ]._color, stack[ i+10 ]._color );
        strcpy( player[ 2 ]._cards[ i ]._value, stack[ i+10 ]._value );
    }

    // hand Player4 cards
    for( int i = 0; i < 5; i++ ) {

        strcpy( player[ 3 ]._cards[ i ]._color, stack[ i+15 ]._color );
        strcpy( player[ 3 ]._cards[ i ]._value, stack[ i+15 ]._value );
    }
*/
}

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

    srand( time( 0 ) );
    Cards stack[ 32 ];
    Player player[ 4 ];
    list< Cards > con; // contains all 32 created cards
    list< Cards >::iterator oti;
    list< Cards > cemetery; // contains all played cards

    intCards( stack, con );

    for( int i = 0; i < MAX_CARDS; i++ ) {

        cout << setw( 2 ) << i+1 << ".Card:   " << setw( 5 ) << left << stack[ i ]._color
             << " " << setw( 2 ) << right << stack[ i ]._value << endl;
    }
    givePlayerCards( player, con );

    cout << "\n=================================\n" << endl;
    for( int i = 0; i < 5; i++ ) {

        cout << player[ 0 ]._cards[ i ]._color << " "
             << player[ 0 ]._cards[ i ]._value << endl;
    }
    getchar();
    return 0;
}

Gruß Tobi.

CStoll

Erstmal solltest du die Möglichkeit bedenken, daß ein Spieler auch mehr oder weniger als 5 Karten bekommen kann (d.h. anstelle des Arrays Cards _cards[5]; ist eine list<Cards> besser geeignet).

Zweitens kannst du die Karte als eine einzelne Zahl (0..31) speichern und für die Ausgabe auseinandernehmen:

struct Card
{
  int value;
};
ostream& operator<<(ostream& fout,Card c)
{
  static const string Color[] = {"Karo","Herz","Pik","Kreuz"};
  static const string Wert[] = {"7","8","9","10","Bube","Dame","König","As"};
  fout<<Color[c.value%4]<<" "<<Wert[c.value/4];
  return fout;
}

Drittens: Schau dir mal random_shuffle() an.

Viertens: Wo genau liegt dein Problem?

T0bi

Viertens: Wo genau liegt dein Problem?

ich kann kein MauMau xD.

Trotzdem erstmal danke, Gruß Tobi.

Werner Salomon

T0bi schrieb:

void intCards( Cards stack[ MAX_CARDS ], list< Cards > con ) {
// ..

Der Parameter 'con' muss hier als 'list< Cards >& con' also per Referenz übergeben werden, damit man in der Routine initCards auf die Variable in main zugreift und nicht auf dessen Kopie.

T0bi schrieb:

ich kann kein MauMau xD.

Schlag nach bei Wiki.

Gruß
Werner