Java: Verhinderung von array-going out-of-bounds

Arbeite ich an einem Spiel der Kontrolleure, wenn Sie mehr Lesen möchten über man kann es hier; http://minnie.tuhs.org/I2P/Assessment/assig2.html

Wenn ich Tue mein test, um zu sehen, wenn der Spieler ist in der Lage, um auf einem bestimmten Platz auf dem Netz (D. H. +1 +1, +1 -1 .etc) von der aktuellen Position, ich bekomme eine java.lang.ArrayIndexOutOfBoundsException-Fehler.

Dies ist der code, den ich benutze, um den Umzug machen; 

public static String makeMove(String move, int playerNumber)
   {
       //variables to contain the starting and destination coordinates, subtracting 1 to match array size
       int colStart = move.charAt(1) - FIRSTCOLREF - 1;
       int rowStart = move.charAt(0) - FIRSTROWREF - 1;
       int colEnd   = move.charAt(4) - FIRSTCOLREF - 1;
       int rowEnd   = move.charAt(3) - FIRSTROWREF - 1;


       //variable to contain which player is which
       char player, enemy;
       if (playerNumber==1)
        {
            player= WHITEPIECE;
            enemy=  BLACKPIECE;
        }
       else
        {
            player= BLACKPIECE;
            enemy=  WHITEPIECE;
        }

        //check that the starting square contains a player piece
        if (grid [ colStart ] [ rowStart ] == player)
        {
            //check that the player is making a diagonal move
            if (grid [ colEnd ] [ rowEnd ] == grid [ (colStart++) ] [ (rowEnd++) ] &&
                grid [ colEnd ] [ rowEnd ] == grid [ (colStart--) ] [ (rowEnd++) ] &&
                grid [ colEnd ] [ rowEnd ] == grid [ (colStart++) ] [ (rowEnd--) ] &&
                grid [ colEnd ] [ rowEnd ] == grid [ (colStart--) ] [ (rowEnd--) ])
                {
                    //check that the destination square is free
                    if (grid [ colEnd ] [ rowEnd ] == BLANK)
                    {
                        grid [ colStart ] [ rowStart ] = BLANK;
                        grid [ colEnd ] [ rowEnd ]     = player;

                    }
                }
            //check if player is jumping over a piece
            else if (grid [ colEnd ] [ rowEnd ] == grid [ (colStart+2) ] [ (rowEnd+2) ] &&
                     grid [ colEnd ] [ rowEnd ] == grid [ (colStart-2) ] [ (rowEnd+2) ] &&
                     grid [ colEnd ] [ rowEnd ] == grid [ (colStart+2) ] [ (rowEnd-2) ] &&
                     grid [ colEnd ] [ rowEnd ] == grid [ (colStart-2) ] [ (rowEnd-2) ])
                 {
                   //check that the piece in between contains an enemy
                    if ((grid [ (colStart++) ] [ (rowEnd++) ] == enemy ) &&
                        (grid [ (colStart--) ] [ (rowEnd++) ] == enemy ) &&
                        (grid [ (colStart++) ] [ (rowEnd--) ] == enemy ) &&
                        (grid [ (colStart--) ] [ (rowEnd--) ] == enemy ))
                    {
                        //check that the destination is free
                        if (grid [ colEnd ] [ rowEnd ] == BLANK)
                        {
                            grid [ colStart ] [ rowStart ] = BLANK;
                            grid [ colEnd ] [ rowEnd ]     = player;
                        }

                    }
                 }

        }

Ich bin mir nicht sicher, wie kann ich verhindern, dass der Fehler passiert, was empfehlen Sie?

InformationsquelleAutor Troy | 2010-03-12
  1. 1

    Ist die erste Sache, springt in den Sinn ist Ihr Gebrauch post-Inkrement-Ausdrücke wie (colstart++) in der Mitte eine if Anweisung Bedingung. Es gibt sicherlich Fälle, in denen dies nützlich sein könnte, aber ich glaube nicht, dass Sie solch einen von Ihnen.

    Verwenden (colstart+1) statt; es ändert nicht den Wert der colstart variable selbst und es sieht aus wie das, was Sie wirklich wollen, zu tun.

    Im detail, vermute colstart 4:

    System.out.println(colstart); //prints 4
System.out.println(colstart++); //prints 4
System.out.println(colstart); //prints 5

    Vergleichen:

    System.out.println(colstart); //prints 4
System.out.println(colstart+1); //prints 5
System.out.println(colstart); //prints 4
    • Ah danke, habe ich nicht bemerkt, dass. Aber es ist immer noch, dass Sie mir das out-of-bounds-Fehler...
    • Überlegen Sie, was passiert, wenn Sie in der Nähe der Kante der platine.
    • Ich habe in Betracht gezogen, aber ich bin mir nicht sicher, was der beste Weg, um dies zu überprüfen wäre.
    • Bevor Sie Zugang (zum Beispiel) grid[colstart-1] überprüfen, um sicherzustellen, dass colstart-1 >= 0. Ebenso, vor grid[colstart+1] überprüfen, dass colstart+1 < grid.length.
    • Das scheint zu Komplex für das, was ich zu tun versuche.... es muss eine einfachere Weise, die ich versuche zu tun, alle Prüfungen auf einmal, wie das Stück kann in 4 verschiedenen Richtungen, also werde ich die überprüfung, dass alle diese Richtungen gültig sind...
    • Vielleicht, wenn es einen Weg, um es zu überprüfen alle auf einmal, vielleicht durch die Einnahme colStart von colEnd und rowStart von rowEnd und arbeiten aus, die...
    • eine andere Technik ist das hinzufügen einer (oder zwei) Räume von "Polsterung" um Ihre arrays. Also, anstatt Sie 8 große, machen Sie 12 breit und haben an Bord vertreten, die in der Mitte. Dann, wenn man sich nur über die Kanten, die Sie nicht bekommen, array-Grenzen, Ausnahmen, aber Sie können zugreifen, was da ist. Normalerweise würde man eine so genannte "sentinel" - Wert gibt, bedeutet "dieser Ort ist der Weg vom Brett".

    InformationsquelleAutor Greg Hewgill
  2. 0

    Fügen Sie bedingte Anweisungen, um sicherzustellen, dass die Werte, die Sie für die Fütterung des Arrays liegen zwischen 0 und size - 1

    InformationsquelleAutor zellio
  3. 0

    Wann immer Sie prüfen den Inhalt von einem array-index gibt es drei Wege:

    1. "Wissen", dass der index innerhalb der Grenzen
    2. Überprüfen Sie vorher, dass der index innerhalb der Grenzen
    3. Den Fehler behandeln, nachdem Sie aufgerufen einen index out of bounds

    Somit für jede dimension des Rasters und jedem Wert für einen index, im Vorfeld zu überprüfen oder den Fehler behandeln.

    Stimme ich Greg, dass postincrements sind in der Regel ärger, obwohl ich die Verdienste hier. Möchten Sie vielleicht zu prüfen, die postincrements:

    //check that the player is making a diagonal move
        if (grid [ colEnd ] [ rowEnd ] == grid [ (colStart++) ] [ (rowEnd++) ] &&
            grid [ colEnd ] [ rowEnd ] == grid [ (colStart--) ] [ (rowEnd++) ] &&
            grid [ colEnd ] [ rowEnd ] == grid [ (colStart++) ] [ (rowEnd--) ] &&
            grid [ colEnd ] [ rowEnd ] == grid [ (colStart--) ] [ (rowEnd--) ])

    Beginnend mit einigen hypothetischen Punkt (2,2):

    colStart = 2 -> 3 -> 2 -> 3 => 2
    rowEnd = 2 -> 3 -> 4 -> 3 => 2

    So, ausgehend von (2,2), das Sie prüfen (3,3), (2,4) und (3,3) wieder, die Ziellinie mit dem ursprünglichen Wert. Dies scheint äußerst unerwünscht zu mir, denn du machst den gleichen test zweimal. (Könnte sein, dass bedeutete, schlagen andere stellen.)

    InformationsquelleAutor Don Johe
Schreibe einen Kommentar