c++ - 车钩运动功能未发现中断

Question

我正在尝试编写一个函数，检查白鸦是否检查了黑王。当我尝试搜索车和国王之间是否有任何零件时，会出现问题。

    void rook_white(piece A[])                                      // does WR check BK
{
    cout << "Found White Rook ";
    int k_x;                                                  // BK'S x coordinate
    int k_y;                                                  // BK's y coordinate
    bool check = false;
    for(int x=0; x<8; x++)
    {
        for(int y=0; y<8; y++)
        {
            if(A[t_i].field[m_x-x][m_y] == 'k')                 // Moving Left
            {
                k_x=m_x;
                k_y=m_y;
                goto al_1;
            }
        }
    }
    for(int x=0; x<8; x++)
    {
        for(int y=0; y<8; y++)
        {
            if(A[t_i].field[m_x+x][m_y] == 'k')                 // Moving Right
            {
                k_x=m_x;
                k_y=m_y;
                goto al_2;
            }
        }
    }
    for(int x=0; x<8; x++)
    {
        for(int y=0; y<8; y++)
        {
            if(A[t_i].field[m_x][m_y-y] == 'k')                 // Moving Up
            {
                k_x=m_x;
                k_y=m_y;
                goto al_3;
            }
        }
    }
    for(int x=0; x<8; x++)
    {
        for(int y=0; y<8; y++)
        {
            if(A[t_i].field[m_x][m_y+y] == 'k')                 // Moving Down
            {
                k_x=m_x;
                k_y=m_y;
                goto al_4;
            }
        }
    }
al_1:
    for(int x=0; x<k_x; x++)
    {
        for(int y=0; y<k_y; y++)
        {
            if(!A[t_i].field[m_x-x][m_y] == '*')                   // Checking left
            {
                goto loop_exit;
            }
        }
    }
al_2:
    for(int x=0; x<k_x; x++)
    {
        for(int y=0; y<k_y; y++)
        {
            if(!A[t_i].field[m_x+x][m_y] == '*')                    // Checking Right
            {
                goto loop_exit;
            }
        }
    }
al_3:
    for(int x=0; x<k_x; x++)
    {
        for(int y=0; y<k_y; y++)
        {
            if(!A[t_i].field[m_x][m_y-y] == '*')                    // Checking Up
            {
                goto loop_exit;
            }
        }
    }
al_4:
    for(int x=0; x<k_x; x++)
    {
        for(int y=0; y<k_y; y++)
        {
            if(!A[t_i].field[m_x][m_y+y] == '*')                    // Checking Down
            {
                goto loop_exit;
            }
        }
    }
loop_exit:
    check = false;
    if (check == true)
    {
        ofstream fr(FVR,ios::app);
        fr << "Black is in check by rook " << t_i << endl;
    }
}

该函数搜索x和y轴上国王的位置。然后，它转到特定的算法（al_1，al_2等），在该算法中搜索国王和车队之间是否有任何东西。

输入文件如下所示：

********
***k****
********
***q****
********
********
***R****
********

这不应该什么都不输出，而

********
***k****
********
********
********
********
***R****
********

应该输出“ Black正在检查”。 （t_i是要对其进行检查的板的编号）

A [t_i]是一个结构数组，结构片段由char字段[8] [8]组成。

我使用结构体是因为我需要检查的板数不限。

k_x和k_y是国王坐标。
m_x和m_y是全局变量，它们是从搜索到的函数中找到的

这是带有int main（）的程序本身

#include <iostream>
#include <fstream>                  // chess
#include <cstdlib>
using namespace std;                                                       // PROGRAM CHECKS FOR CHESS CHEKS
const char FVD[]="5_input.txt";                                 // **************************************************
const char FVR[]="5_output.txt";                                // P - white pawn   (WP)      p - black pawn     (BP)
//---                                                           // R - white rook   (WR)      r - black rook     (BR)
//---                                                           // B - white bishop (WB)      b - black bishop   (BB)
int m_i=0;          // max i                                    // N - white knight (WN)      n - black knight   (BN)
int m_x=0;          //                                          // Q - white queen  (WQ)      q - black queen    (BQ)
int m_y=0;          //                                          // K - white king   (WK)      k - black king     (BK)
int t_i=0;          //                                          // **************************************************
struct piece
{
    char field[8][8];
};
void read(piece A[])
{
    ifstream fd(FVD);
    int i=0;
    m_i=0;
    while(!fd.eof())
    {
        for(int x=0; x<8; x++)
        {
            for(int y=0; y<8; y++)
            {
                fd >> A[i].field[x][y];
            }
        }
        fd.ignore();
        i++;
        m_i=i;
    }
    fd.close();
}
///  ----------------------------------------------BLACK KING IS IN CHECK--------------------------------------------------------------
void rook_white(piece A[])                                      // does WR check BK
{
    cout << "Found White Rook ";
    int k_x;                                                  // BK'S x coordinate
    int k_y;                                                  // BK's y coordinate
    bool check = false;
    for(int x=0; x<8; x++)
    {
        for(int y=0; y<8; y++)
        {
            if(A[t_i].field[m_x-x][m_y] == 'k')                 // Moving Left
            {
                k_x=m_x;
                k_y=m_y;
                goto al_1;
            }
        }
    }
    for(int x=0; x<8; x++)
    {
        for(int y=0; y<8; y++)
        {
            if(A[t_i].field[m_x+x][m_y] == 'k')                 // Moving Right
            {
                k_x=m_x;
                k_y=m_y;
                goto al_2;
            }
        }
    }
    for(int x=0; x<8; x++)
    {
        for(int y=0; y<8; y++)
        {
            if(A[t_i].field[m_x][m_y-y] == 'k')                 // Moving Up
            {
                k_x=m_x;
                k_y=m_y;
                goto al_3;
            }
        }
    }
    for(int x=0; x<8; x++)
    {
        for(int y=0; y<8; y++)
        {
            if(A[t_i].field[m_x][m_y+y] == 'k')                 // Moving Down
            {
                k_x=m_x;
                k_y=m_y;
                goto al_4;
            }
        }
    }
al_1:
    for(int x=0; x<k_x; x++)
    {
        for(int y=0; y<k_y; y++)
        {
            if(!A[t_i].field[m_x-x][m_y] == '*')                   // Checking left
            {
                goto loop_exit;
            }
        }
    }
al_2:
    for(int x=0; x<k_x; x++)
    {
        for(int y=0; y<k_y; y++)
        {
            if(!A[t_i].field[m_x+x][m_y] == '*')                    // Checking Right
            {
                goto loop_exit;
            }
        }
    }
al_3:
    for(int x=0; x<k_x; x++)
    {
        for(int y=0; y<k_y; y++)
        {
            if(!A[t_i].field[m_x][m_y-y] == '*')                    // Checking Up
            {
                goto loop_exit;
            }
        }
    }
al_4:
    for(int x=0; x<k_x; x++)
    {
        for(int y=0; y<k_y; y++)
        {
            if(!A[t_i].field[m_x][m_y+y] == '*')                    // Checking Down
            {
                goto loop_exit;
            }
        }
    }
loop_exit:
    check = false;
    if (check == true)
    {
        ofstream fr(FVR,ios::app);
        fr << "Black is in check by rook " << t_i << endl;
    }
}
///-----------------------------------------SEARCHING FOR THE CHECKS // CALLING FUNCTIONS --------------------------------------------
void search(piece A[])                                               // searches for piece and calls a function related to it
{
    for(int i=0; i<m_i-1; i++)
    {
        for(int x=0; x<8; x++)
        {
            for(int y=0; y<8; y++)
            {
        if (A[i].field[x][y]=='R')
                {
                    t_i=i;
                    m_x=x;
                    m_y=y;
                    rook_white(A);
                }

            }
        }
    }
}
int main()
{
    piece A[10];
    remove(FVR);            // clears the output before inputting new data because of ios::app
    read(A);
    search(A);
    ofstream fr(FVR);
    fr << "Done";
    return 0;
}

Answer 1

我会做我通常不做的事情-我会给你一个完整的往返行程（因为我感觉很满意）。



您从main()开始，它应该读取任意数量的字段（但实际上在11日崩溃），以及一个search()函数，该函数旨在最终遍历所有可能的棋子……但是您的程序在检查第一块白鸦。

您还从C开始，然后介绍了C ++的顺势疗法剂量，实际上使事情变得更加困难。

因此，让我们将其减少。首先，我们将“最小值”添加到您的示例代码中。



让我们使用<vector>代替二维数组。向量是C ++中最有用的东西之一，实际上几乎没有理由再使用C样式数组了（也许出于C API兼容性）。

#include <vector>
#include <iostream>

typedef std::vector< std::vector< char > > Field;

Field现在是 char s向量的向量的别名。这基本上与二维数组（包括 [][]寻址）相同，但是您将很快看到它的一些优点。



您的 rook_white()（按您的设计）需要一个字段，并且车的X和Y坐标。请允许我稍微调整一下函数原型-我喜欢更具表现力的标识符名称。

void rook_white( Field const & field, unsigned rook_x, unsigned rook_y );

搜索并删除 A[t_i].，我们目前仅在该字段上工作。用 m_x搜索和替换 rook_x，并用 m_y搜索和替换 rook_y。不是太难。同时替换：

        ofstream fr(FVR,ios::app);
        fr << "Black is in check by rook " << t_i << endl;

带有：

        std::cout << "Black is in check by rook" endl;

现在，我们不必理会文件I / O。



现在，我们需要设置一个字段，但是现在我们不需要从文件中读取它。一旦实际检查生效，您就可以扩展代码。

int main()
{
    Field field( 8, std::vector< char >( 8, '*' ) );

std::vector< char >( 8, '*' )创建一个8个 '8'字符的临时向量。 Field field( 8, /*...*/ );创建一个由该临时矢量的8个副本组成的 Field。

现在，让我们放置您的碎片。

    unsigned rook_x = 3;
    unsigned rook_y = 6;
    field[rook_x][rook_y] = 'R';

    unsigned king_x = 3;
    unsigned king_y = 1;
    field[king_x][king_y] = 'k';

在这一点上，我意识到您的示例代码在 search()中混合了“ X”和“ Y”坐标（报告车队在X = 6，Y = 3），但是没关系。那不是问题的根源。

现在，我们有了字段和坐标来调用您的函数。

    rook_white( field, rook_x, rook_y );
    return 0;
}

编写 main()并不能真正反映最终应用程序应该执行的操作，而是针对特定功能设置测试的这种方式称为测试驱动程序。我们仅从您的示例中删除了50行不必要的代码，从而消除了各种不相关的潜在问题。



现在，让我们看一下 rook_white()，可以吗？



由于现在有了一个 vector< vector< char > >而不是“哑”数组，因此我们可以做一些漂亮的事情：用 []替换 .at()访问。原因？如果 []的索引超出范围，则可能会或可能不会使程序崩溃。如果 .at()的索引超出范围，它将引发异常。

因此，尽管 .at()稍慢一些并且通常不用于生产代码中，但我建议初学者使用它，因为它不允许错误“隐藏”。

此时，您应该扬起眉毛，对自己说：“他为什么这么建议？”。然后，您应该查看循环，然后...

for(int x=0; x<8; x++)
{
    for(int y=0; y<8; y++)
    {
        if(field[rook_x-x][rook_y] == 'k')
        {
            k_x=rook_x;
            k_y=rook_y;
            goto al_1;
        }
    }
}

对，就是这样。您具有对字段的无限制访问权限。

rook_x / rook_y在领域中间，但是如果您找不到国王，则您坚持要访问 [rook_x - 7][rook_y]以下的任何内容。那是原始代码中的负索引。由于我将坐标更改为 unsigned（它会溢出并变得非常大），所以您会遇到段错误崩溃（如果幸运的话）。这实际上是无意的。我只是用哈比特声明不能为负的 unsigned。

但这就是为什么我建议在您仍在学习时使用 vector<>的 .at()方法的原因：尽早且尽可能大声地失败。异常比未定义的行为要好。



此外，您（在所有这些循环中）总是循环遍历 x和 y，但仅使用循环内的两个变量之一。这浪费了很多时钟周期。这不会破坏您的逻辑只是机会...

此时，您可能希望完全重新编写代码。但是，等等，还有更多。



如果您在第一个循环中“左移”并在其中找到国王，则您 goto al_1。在那里循环（再次仅使用两个循环计数器之一）来检查中间片段。

第一个循环是 x == 0，检查 [rook_x - 0][rook_y] ...猜猜是什么，您发现白菜车正在干预其中，因为该字段中没有 '*'，所以您跳到 loop_exit ...



即使您不会犯此错误，也可以退出该循环并输入 al_2，同时还要检查车队的所有其余方向...



即使所有这些都不会发生，无论发生了什么，您最终都会遇到以下问题：

loop_exit:
    check = false;
    if (check == true)
    {
        std::cout << "Black is in check by rook \n";
    }

好吧， check == true永远不会发生，对吧？



在这一点上，我引用您的评论之一...


  ...我只是不理解[switch语句]，也无法真正地思考如何将它们编写为switch。


我的建议？我完全理解为什么您要尽快写“真实的东西”。课本很无聊。但是您确实应该花更多的时间来“围绕”基本概念。 C和C ++是真正不能与“尝试与错误”方法一起学习的语言。简直有太多东西会并且会出错。

We have a list of recommended textbooks, if the one you have isn't to your tastes.

而且，如果您在真正掌握基础知识之前尝试了太大的事情（例如国际象棋程序），那么您可能会遇到的任何问题的答案都比舒适的要长得多，而且两个问题都要写（如果有人觉得喜欢）和你消化。



并请：

除非您完全肯定地知道自己在做什么，否则不要使用 goto。