是否有一种更容易的方式来表示C++中的条件？

Question

我写了一个基于多维数组的基本井字棋游戏。克[3] [3]。在我的程序中，我有大约9个条件，比如我正要向你们展示的条件：

if((g[0][0] == X && g[0][1] == X && g[0][2] == X) || (g[0][0] == O && g[0][1] == O && g[0][2] == O)) 

这是非常疯狂的。我可能做错了什么，但这就是我解决这个问题的原因。是否有更简单的方式来表示像这样长期和复杂的条件？例如我不能做莫名其妙：

if(grid.hasXes) 

Answer 1

你可能会约了错误的方式。目前只有3^9，或 19683种可能的组合，所以你甚至可以在16位机器上的网格转换为int， ：

int 
asInt(char const (&grid)[3][3]) 
{ 
    int results = 0; 
    for (int i = 0; i != 3; ++ i) { 
     for (int j = 0; j != 3; ++ j) { 
      results *= 3; 
      switch (grid[i][j]) { 
      case 'X': 
       results += 1; 
       break; 

      case 'Y': 
       results += 2; 
       break; 

      case ' ': 
       break; 

      default: 
       assert(0); 
      } 
     } 
    } 
    return results; 
} 

之后，您可以使用INT来索引表表明谁赢得了 （如果有的话）。或者，你可以转换只是一个或另一个 玩家的位置到9位的int：

int 
asInt(char const (&grid)[3][3], char who) 
{ 
    int results = 0; 
    for (int i = 0; i != 3; ++ i) { 
     for (int j = 0; j != 3; ++ j) { 
      results *= 2; 
      if (grid[i][j] == who) { 
       ++ results; 
      } 
     } 
    } 
    return results; 
} 

然后，您可以使用一个简单的线性搜索到一个表，核实该 必要位设置：

static int const wins[] = 
{ 
    0007, 0070, 0700,  // rows 
    0111, 0222, 0444,  // columns 
    0124, 0421    // diagonals 
}; 

class Wins 
{ 
    int myToMatch; 
public: 
    Wins(char const (&grid)[3][3], char who) 
     : myToMatch(asInt(grid, who)) 
    { 
    } 
    bool operator()(int entry) const 
    { 
     return (entry & myToMatch) == entry; 
    } 
}; 

然后：

if (std::find_if(begin(wins), end(wins), Wins(grid, 'X')) 
      != end(wins) { 
    // X wins 
else if (std::find_if(begin(wins), end(wins), Wins(grid, 'O')) 
      != end(wins) { 
    // O wins 
else 
    // play another turn. 

你甚至可以考虑保持电网作为两个int S，每名球员之一。 的位置的位数是3 * i + j，并测试一个 此举是合法的：

bool 
isLegal(int gridX, int gridY, int i, int j) 
{ 
    return ((gridX | gridY) & (1 << (3 * i + j))) == 0; 
} 

Answer 2

现在我知道了......

bool check(char *g, int x, int y, int moveX, int moveY, char ch) 
{ 
    for (int i(0); i<3; ++i) 
    { 
     if ((g+(y*3)+x) != ch) return false; 
     x += moveX; 
     y += moveY; 
    } 
    return true; 
} 

你使用它像：

if (check(g, 0, 0, 0, 1, 'O')) //checking O in the first row. 
if (check(g, 0, 0, 0, 1, 'X')) //checking X in the first row. 
if (check(g, 0, 0, 1, 0, 'O')) //checking O in the first column. 
if (check(g, 0, 0, 1, 0, 'X')) //checking X in the first column. 

Answer 3

你可以写函数隐藏复杂性并增强主要驱动程序功能的可读性。例如，您可以检查一行或一列以查看它是否全部等于X或O.

Answer 4

处理这类问题最简单和最强大的方法是简单地通过提取丑陋的代码变成一个功能。如果方便的话，该函数可以是类的成员，或者只是一个自由函数。在你的情况下，快速修复可能是

bool hasXes(char[3][3] g) { 
    return (g[0][0] == X && g[0][1] == X && g[0][2] == X) || (g[0][0] == O && g[0][1] == O && g[0][2] == O) 
} 

然后，你可以简单地写：

if (hasXes(g)) ... 

Answer 5

这应该工作：

bool found = false; 
int i, j; 
for(i = 0; i < 3; i++) 
{ 
    for(j = 0; j < 3; j++) 
    { 
     if(g[i][j] == X) 
     { 
      found = true; 
      break; 
     } 
    } 
    if(found == true) 
    { 
     break; 
    } 
} 
if(found == true) 
{ 
    // do something because one of them had X. i, j have the co-ordinates of the first find of it 
} 
else 
{ 
    // none of them had X 
} 

有可能是使用goto语句的一种方式好吧，尽管这些在C++中非常令人沮丧。如果您一次只需要一行，则只使用1循环。

Answer 6

另有一个选项可供选择。可以使用memcmp如果存储是连续

if(!memcmp(g[0],"XXX",3) || !memcmp(g[0],"OOO",3)) 

Answer 7

你可以计数两个X或试图找到它们：

假设g为3×3阵列，包含字符X或O：

char* end = g + 9; 
std::count(g, end, 'X') > 0; 

或更有效地：

char* end = g + 9; 
std::find(g, end, 'X') != end; 

Answer 8

在该规范IAL情况下也有个较为简单的比较：

if(g[0][0] == g[0][1] && g[0][1] == g[0][2]) 

至少假设有只X和O可能。否则这将成为

if(g[0][0] == g[0][1] && g[0][1] == g[0][2] && (g[0][1] == X || g[0][1] == O)) 

这仍然是一个更简单的恕我直言。

如果您不能像这样简化，请使用其他人指出的循环。

Answer 9

Typesafe评论！

const bool first_is_xful = g[0][0] == X && g[0][1] == X && g[0][2] == X, 
      second_is_xful = ...; 

if (first_is_xful || second_is_xful || ...) ... 

或函数功能：

bool is_xful (int row, ...) ... 

... 

if (is_ixful(0) || ...