Array an Funktion übergeben



  • Erst einmal danke für die ganzen infos.

    Weil ich noch ein Anfänger im Programmieren bin ist mir OOP noch ein bisschen suspekt.

    314159265358979 schrieb:

    Ich nehme an, du verwendest Visual Studio.

    Stimmt

    314159265358979 schrieb:

    std::array<std::array<Spielfigur, 8>, 8>; // Entspricht Spielfigur[8][8]
    

    Wo gebe ich den Namen des Arrays an? Immer im tiefsten geschachtelten?

    314159265358979 schrieb:

    Ich würde zuerst prüfen, ob der König überhaupt im Schach ist.

    Tu ich ja auch

    314159265358979 schrieb:

    Dann würde ich alle freien Randfelder prüfen. Ist man auf jedem Randfeld im Schach, so ist das Spiel zu Ende.

    Nein, weil das die Figur ungedeckt vor dem König stehen könnte, oder nur über eine Senkrechte, oder nur über eine Waagrechte oder nur über eine Diagonale Schach gegeben werden könnte.

    314159265358979 schrieb:

    Ob ein Feld im Schach ist, ist auch relativ einfach.

    Stimmt, ist ja auch nicht das Problem.

    314159265358979 schrieb:

    Message angekommen? Du musst hier nirgens etwas verändern.

    Doch, ich muss prüfen ob es einen möglichen Zug gibt der das Schach aufhebt, sei es durch schlagen der Schachgebenden Figur, durch wegziehen des Königs, oder durch Ziehen einer anderen Figur vor den König, wenn es ihn nicht gibt ist Matt.

    und um das zu überprüfen, übergebe ich den array an eine Funktion, die mir die x und y werte für jeden gültigen Zug sucht, in den Array schreibt und dann an eine Funktion übergibt, die testet ob mit diesen neuen Werten immer noch schach gegeben wird.

    Nochmals zur Verdeutlichung: In diesem Array steht nicht das Spielfeld, sondern jede der 32 Figuren, mit ihrer aktuellen Position und welche figur es ist (Bauer, Turm, Springer, Läufer, Dame, König)



  • Ich hab mal wieder zu wenig nachgedacht *schäm*
    Ich hab den Namen beim Array vergessen, ich meinte natürlich:

    std::array<std::array<Spielfigur, 8>, 8> spielfeld;
    


  • 314159265358979 schrieb:

    Ich hab den Namen beim Array vergessen, ich meinte natürlich:

    std::array<std::array<Spielfigur, 8>, 8> spielfeld;
    

    Für was steht Spielfigur?



  • Eine Klasse, die du schreiben kannst/solltest 😉



  • Tal Ker schrieb:

    314159265358979 schrieb:

    Ich hab den Namen beim Array vergessen, ich meinte natürlich:

    std::array<std::array<Spielfigur, 8>, 8> spielfeld;
    

    Für was steht Spielfigur?

    std::array<Spielfigur,8> arr; //definiert ein array-Objekt mit 8 Elementen vom Typ Spielfigur.
    std::array<std::array<Spielfigur,8>, 8> arr2; //definiert ein array-Objekt mit 8 Elementen vom Typ std::array<Spielfigur, 8>
    


  • Tachyon schrieb:

    std::array<Spielfigur,8> arr; //definiert ein array-Objekt mit 8 Elementen vom Typ Spielfigur.
    std::array<std::array<Spielfigur,8>, 8> arr2; //definiert ein array-Objekt mit 8 Elementen vom Typ std::array<Spielfigur, 8>
    

    Danke und wenn ich den Typ Spielfigur nicht habe?
    Dann so

    std::array<std::array<std::array<3>, 16>,2>
    

    ?



  • Dann bastelst du ihn dir :p



  • Und wie? Als struct von einem int oder wie? 🙂



  • struct Spielfigur
    {
        Spielerfarme farbe;
        Figurtyp type;
    };
    

    Würde schon ausreichen und deinen Code vereinfachen sowie verständlicher machen. 😉



  • Tal Ker schrieb:

    Zur Erklärung: Ich programmier gerade Schach, dazu habe ich ein 3-Dim Array mit [2][16][3]. In diesem Array speicher ich die Figuren der jeweiligen Farbe ab mit den Infos wo sie sind und was für eine Figur sie sind.

    Wo kommen Deine Figuren denn her? Was ist der Elementtyp von Deinem Array[2][16][3]?



  • Nicht, wenn ich abwechselnd spielen lasse und die farbe über eine bool steuere, also

    bool bfarbe = 0; //0 = weiß, 1 = schwarz
    figuren[bfarbe][zu ziehende figur][typ der figur];
    

    Das Array ist ein int.

    Die Figuren werden am Spielanfang mit der Grundaufstellung initialisiert.
    Die weißen so:

    array[0][0][0] = 0; //Spielfigur ist ein Bauer
    array[0][0][1] = 0; //Bauer hat die x-Koordinate 0
    array[0][0][2] = 1; //Bauer hat die y-Koordinate 1
    array[0][1][0] = 0; //Spielfigur ist ein Bauer
    ...
    array[0][8][0] = 1; //Spielfigur ist ein Turm
    array[0][8][1] = 0; //Turm hat die x-Koordinate 0
    array[0][8][2] = 0; //Turm hat die y-Koordinate 0
    

    und die schwarzen so:

    array[0][0][0] = 0; //Spielfigur ist ein Bauer
    array[1][0][1] = 0; //Bauer hat die x-Koordinate 0
    array[1][0][2] = 6; //Bauer hat die y-Koordinate 6
    array[1][1][0] = 0; //Spielfigur ist ein Bauer
    ...
    array[1][8][0] = 1; //Spielfigur ist ein Turm
    array[1][8][1] = 0; //Turm hat die x-Koordinate 0
    array[1][8][2] = 7; //Turm hat die y-Koordinate 7
    


  • Tal Ker schrieb:

    Nicht, wenn ich abwechselnd spielen lasse und die farbe über eine bool steuere, also

    bool bfarbe = 0; //0 = weiß, 1 = schwarz
    figuren[bfarbe][zu ziehende figur][typ der figur];
    

    Das Array ist ein int.

    Ein bischen umständlich.

    Vielleicht wäre es besser, eine Klasse Feld zu haben, welche Deine Spielfelder kennzeichnet. Dann hättest Du ein Array Felder felder[8][8] . Die Klasse Feld hätte dann vielleicht sinnvollerweise ein Attribut Figur. Figur wäre dabei eine weitere Klasse. So wäre das ganze vielleicht etwas besser zu handhaben.



  • Wenn man mit OOP vertraut ist sicherlich. 🙂
    Aber dazu fehlt mir das Wissen und die Erkenntnis was an OOP um so vieles besser ist.



  • Tal Ker schrieb:

    Aber dazu fehlt mir das Wissen

    Kann man sich aneignen

    und die Erkenntnis was an OOP um so vieles besser ist.

    Zum Beispiel unter anderem, dass der Code sagt, was gemeint ist, und nicht zu jeder Zeile Code eine mindestens so lange Zeile Kommentar zur Erklärung benötigt wird.



  • Tal Ker schrieb:

    Wenn man mit OOP vertraut ist sicherlich. 🙂
    Aber dazu fehlt mir das Wissen und die Erkenntnis was an OOP um so vieles besser ist.

    Dann solltest Du es besser jetzt beim Lernen verinnerlichen. Sonst kommt nur Murks dabei raus.



  • Was ist den an der OOP so gut?
    Wenn ich den Variablen sprechende namen gebe, brauch ich auch keinen Kommentar dazu.



  • Tal Ker schrieb:

    Nicht, wenn ich abwechselnd spielen lasse und die farbe über eine bool steuere

    Und wie repräsentierst du ein leeres Feld?



  • 314159265358979 schrieb:

    Und wie repräsentierst du ein leeres Feld?

    Gar nicht. Das Spielfeld taucht als solches im Code nur bei der mattüberprüfung auf.



  • Irgendwie ist in Deinem Code nur schwer ersichtlich was wo wie ist.

    Durch OOP wird das irgendwie etwas klarer.

    class piece
    {
    public:
        enum color_type{white, black};
        enum figure_type{rook, knight, bishop, queen, king, pawn};
    
        piece(color_type col, figure_type fig);
    private:
        //...
    };
    
    class square
    {
    public:
        enum color_type{white, black};
        square();
        square(color_type col);
        square(color_type col, piece const & p);
    private:
        //...
    };
    
    std::array<std::array<square, 8>, 8> board;
    
    board[0][0] = square(square::white, piece(piece::white, piece::rook));  //weisses Feld, weisser Turm. Kommantar eigentlich ueberfluessig
    
    //im Gegensatz uu:
    array[1][8][0] = 1; //Spielfigur ist ein Turm -> aha...
    

    Wenn man dann noch Entwurfsmuster kennt, könnte man aus board auch noch eine Klasse machen, welche z.B. das Strategie-Muster benutzt um die Regeln für die Figurbewegungen durchzusetzen. Dann könnte man große Teile z.B. auch für Dame wiederverwenden.



  • Tachyon schrieb:

    Irgendwie ist in Deinem Code nur schwer ersichtlich was wo wie ist.

    Durch OOP wird das irgendwie etwas klarer.

    class piece
    {
    public:
        enum color_type{white, black};
        enum figure_type{rook, knight, bishop, queen, king, pawn};
        
        piece(color_type col, figure_type fig);
    private:
        //...
    };
    
    class square
    {
    public:
        enum color_type{white, black};
        square();
        square(color_type col);
        square(color_type col, piece const & p);
    private:
        //...
    };
    
    std::array<std::array<square, 8>, 8> board;
    
    board[0][0] = square(square::white, piece(piece::white, piece::rook));  //weisses Feld, weisser Turm. Kommantar eigentlich ueberfluessig
    //im Gegensatz uu:
    array[1][8][0] = 1; //Spielfigur ist ein Turm -> aha...
    

    Nur wenn man die Bedeutung der Wörter "rook" und "white" kennt. Genauso wie "array[1][8][0] = 1" nur richtig interpretiert werden kann wenn man den Kontext kennt. Und dann ist "array[1][8][0] = 1" kürzer als "board[0][0] = square(square::white, piece(piece::white, piece::rook));"


Anmelden zum Antworten