Как очистить массив от мусора?

Question

[Gagatyn]

Здравствуйте!
Проблема заключается в игре Крестики нолики.

//Вот матрица a[i][j]
[ 1 ] [ 2 ] [ 3 ]  //[00 ] [01 ] [02 ]
[ 4 ] [ 5 ] [ 6 ]  //[10 ] [11 ] [12 ]
[ 7 ] [ 8 ] [ 9 ]  //[20 ] [21 ] [22 ]

// при вводе конечного результат в [ 3 ]
// благодаря этой проверки: a[i][j+1] == X && a[i][j+2] == X
// пишет, что X выиграл. А значения он сравнивал в [0,4] и [0,3], которые каким-то 
// образом равны Х оба.
[ O ] [ 2 ] [(X)]
[ X ] [ X ] [ O ]
[ 7 ] [ 8 ] [ O ]

(1)Я думаю ограничить, но не работает это ограничение.

// size = 3, i и j , текущие, зависят от номера ячейки, сверху в [ 3 ] - i = 0, j = 2
if (((i+1) >= size && (i-1) < 0 && (j+1) >= size && (j-1) < 0) &&
        ((i+2) >= size && (i-2) < 0 && (j+2) >= size && (j-2) < 0)) {
        return ' ';
    }

(2)Или присвоить нолик элементам, которые находятся за границей.

// элементам где есть -1 и 3
[-1-1] [-10] [-11] [-12] [-13]
[0-1 ] [00 ] [01 ] [02 ] [03]
[1-1 ] [10 ] [11 ] [12 ] [13]
[2-1 ] [20 ] [21 ] [22 ] [23]
[3-1 ] [30 ] [31 ] [32 ] [33]

Стоит ли делать (2)? Как исправить проблему с выходом за границу?

Answer 1

[Иван Корюков]

Массивы в Си это указатели на область памяти некоторого размера. Точнее просто указатели, размер, хоть где-то и есть (free ведь откуда-то знает сколько памяти освободить), но точно не в указателе.
Рядом с массивом - за его границами, лежат какие-то данные. Для вас это ничего не значащий мусор, но это могут быть другие переменные, или адреса возврата из функции, если массив лежит на стэке.
Так вот, ни в коем случае не модифицируйте и не читайте память, которая лежит за границами массива. В лучшем случае, вы наткнётесь на свободный участок, заполненный мусором. В худшем - перезапишете значение другой переменной и создадите себе баг, который без отладчика не найдёте.

Что касается предметной области:

char symbols[] = "XO";
uint8_t winner_index;
for(uint8_t char_index=0; char_index<2; char_index++){
  for(uint8_t i=0; i<3; i++){
    // rows
    if(a[i][0] == symbols[char_index] && a[i][1] == symbols[char_index] && a[i][2] == symbols[char_index]){
        winner_index = char_index;
        break 2;
    }
    // columns
    if(a[0][i] == symbols[char_index] && a[1][i] == symbols[char_index] && a[2][i] == symbols[char_index]){
        winner_index = char_index;
        break 2;
    }
  }
  // diagonal 1
  if(a[0][0] == symbols[char_index] && a[1][1] == symbols[char_index] && a[2][2] == symbols[char_index]){
      winner_index = char_index;
      break;
  }
  // diagonal 2
  if(a[0][2] == symbols[char_index] && a[1][1] == symbols[char_index] && a[2][0] == symbols[char_index]){
      winner_index = char_index;
      break;
  }
}

Comments

[Gagatyn]

Иван Корюков, У меня немного другая ситуации. У меня есть матрица NxN. Нужно собрать три Х или три О.

// к примеру 3х3
[ 1 ] [ 2 ] [ 3 ] 
[ 4 ] [ 5 ] [ 6 ]  
[ 7 ] [ 8 ] [ 9 ]

Вводят номер ячейки, ставится туда в отдельной (1)функции О или Х.
В (1)функции стравнивается введенный номер с значением ячейки, и там же (2)функция
проверка идет по тем координатам, т.е. i и j, нет ли поблизости два Х или два О.

// проверка: (*q = a[3][3], size = 3, i = 0, j = 3), выигрыш сработает на этих значениях в " → " сторону
if(*(q + (i+1) * size + (j+1)) == win && *(q + (i-1) * size + (j-1)) == win || /* \ */
       *(q + (i-1) * size + (j))   == win && *(q + (i+1) * size + (j))   == win || /* ↕ */
       *(q + (i)   * size + (j-1)) == win && *(q + (i)   * size + (j+1)) == win || /* ↔ */
       *(q + (i+1) * size + (j-1)) == win && *(q + (i-1) * size + (j+1)) == win || /* / */

       *(q + (i-1) * size + (j))   == win && *(q + (i-2) * size + (j))   == win || /* ↑ */
       *(q + (i+1) * size + (j))   == win && *(q + (i+2) * size + (j))   == win || /* ↓ */
       *(q + (i)   * size + (j+2)) == win && *(q + (i)   * size + (j+1)) == win || /* → */
       *(q + (i)   * size + (j-1)) == win && *(q + (i)   * size + (j-2)) == win || /* ← */
       *(q + (i-2) * size + (j-2)) == win && *(q + (i-1) * size + (j-1)) == win || /* °\ */
       *(q + (i+1) * size + (j+1)) == win && *(q + (i+2) * size + (j+2)) == win || /* \. */
       *(q + (i-2) * size + (j+2)) == win && *(q + (i-1) * size + (j+1)) == win || /* /° */
       *(q + (i+1) * size + (j-1)) == win && *(q + (i+2) * size + (j-2)) == win)   /* ./ */ {
        return win;
    }
    return 0;

// к примеру Х
[ O ] [ 2 ] [(X)] [ X ] [ X ]
[ X ] [ X ] [ O ]
[ 7 ] [ 8 ] [ O ]

Проверка находит за границей значения равные текущим координатам, т.е. i и j, и выигрыш!
Я просто еще не пойму как перенести ваш ответ в мой код.

[Иван Корюков]

Не совсем понимаю вашу логику. Вы хотите сказать, что у вас другие правила игры? Если нет, то для проверки того, что 3 одинаковых символа выстроились в линию, совсем не обязательно отталкиваться от последней введённой координаты. На поле 3*3 возможны только 8 линий: 3 вертикальные + 3 горизонтальные + 2 диагональные. После каждого хода можно проверять все линии. Код для этого я написал выше.