Przesyłanie tablicy dwuwymiarowej z funkcji do drugiej funckji

Question

Cześć!
Z góry uprzedzam, że tak, przeglądałam podobne wątki ale nie znalazłam w nich odpowiedzi na moje pytanie.

Piszę prostą gierkę w sapera. Napisałam funkcję generującą bomby, zwracającą dwuwymiarową tablicę intów, które są parami współrzędnych bomb, które będą wykorzystane w tej głównej tablicy, czyli planszy.

W drugiej funkcji natomiast, czyli w funkcji mającej za zadanie wypełnić tablicę (najpierw w miejsce danych współrzędnych powstawiać literkę "B" np) potrzebowałabym przekonwertować dane pary współrzędnych (czyli te tablice dwuwymiarową z funkcji generującej bomby) na te "główną" planszę z funkcji wypełniającej. Problem dla mnie stanowi wywołanie np w pętli (aby następnie przyporządkować je jako współrzędne głównej planszy) po kolei liczb tablicy zwracanej przez poprzednią funkcję.

Kompletnie nie mam pojęcia jak się za to zabrać, mój pomysł się nie sprawdził więc już nie wiem jak to funkcjonuje...

int *generowanie_bomb()
{
    int wspolrzedne_bomb[15][2];
    srand(time(NULL));
    for(int i=0; i<15; i++){
        for(int j=0; j<2; j++)
        {
            wspolrzedne_bomb[i][j]=rand()%10;
            //cout << wspolrzedne_bomb[i][j]<< " ";
        }
        //cout << endl;
    }
    return *wspolrzedne_bomb;
}

void wypelnianie_planszy(string plansza[11][11])
{

//i co tutaj???

}

 

Answer 1

Ja bym się za to zabrał troszkę inaczej. Najpierw utworzyłbym pustą planszę, a następnie losowałbym gdzie umieścić bombę.
Przykład:
 

#include <iostream>
#include <memory>
#include <stdexcept>

using namespace std;

class Board {
private:
    int mRows;
    int mCols;
    std::unique_ptr<std::unique_ptr<char[]>[]> mBoard;
public:
    Board(int rows, int cols) :
        mRows(rows),
        mCols(cols)
    {
        if (rows <=0 )
            throw std::invalid_argument("rows");
        if (cols <=0 )
            throw std::invalid_argument("cols");
        mBoard.reset(new std::unique_ptr<char[]>[rows]);
        for (int r = 0; r < rows; r++) {
            auto &row = mBoard[r];
            row.reset(new char[cols]);
            for (int c = 0; c < cols; c++) {
                auto &cell = row[c];
                cell = ' ';
            }
        }
    }
    char &getField(int row, int col) {
        if (row < 0 || row >= mRows)
            throw std::invalid_argument("row");
        if (col <0 || col >= mCols)
            throw std::invalid_argument("col");
        return mBoard[row][col];
    }
    int rows() const {
        return mRows;
    }
    int cols() const {
        return mCols;
    }
    void print() const {
        for (int r = 0; r < mRows; r++) {
            std::cout << "|";
            for (int c = 0; c < mCols; c++) {
                auto &cell = mBoard[r][c];
                std::cout << cell;
            }
            std::cout << "|" << std::endl;
        }
    }
};

int main()
{
    Board board(10, 10);
    srand(time(nullptr));
    for (int i=0; i<30; i++) {
        while (true) {
            int r = rand()%board.rows();
            int c = rand()%board.cols();
            auto &cell = board.getField(r,c);
            if (cell == 'B')
                continue;
            cell = 'B';
            break;
        }
    }
    board.print();
    return 0;
}

 

Comments

char &getField(int row, int col)

Dlaczego zwracasz referencje? 

---

Nie chciało mi się pisać settera . W ten sposób otrzymuję dwa w jednym.

---

@tangarr, Okej, na podobny pomysł wpadłam później, i faktycznie, jest on lepszy, ale chciałabym znać rozwiązanie tego problemu też "po mojemu"- żeby wiedzieć na przyszłość :P

---

Nie ma problemu. Jednak sugeruję zmienić planszę z tablicy string na tablicę char.
 

#include <iostream>

int ** generowanie_bomb (int ilosc, int dlugosc_mapy)
{
  int **wspolrzedne_bomb = new int *[ilosc];
  srand (time (NULL));
  for (int i = 0; i < ilosc; i++)
    {
      while (true)
	{
	  int bomba[2];
	  bomba[0] = rand () % dlugosc_mapy;
	  bomba[1] = rand () % dlugosc_mapy;
	  bool losuj_od_nowa = false;
	  for (int j = 0; j < i; j++)
	    {
	      if (wspolrzedne_bomb[j][0] == bomba[0]
		  && wspolrzedne_bomb[j][1] == bomba[1])
		{
		  // wylosowana pozycja znajduje sie juz w tablicy
		  losuj_od_nowa = true;
		  break;
		}
	    }
	  if (losuj_od_nowa)
	    {
	      // rozpoczynamy losowanie wspolrzednych od nowa
	      continue;
	    }
	  wspolrzedne_bomb[i] = new int[2];
	  wspolrzedne_bomb[i][0] = bomba[0];
	  wspolrzedne_bomb[i][1] = bomba[1];
	  break;
	}
    }
  return wspolrzedne_bomb;
}

int
usun_tablice_bomb (int **tablica, int dlugosc)
{
  for (int i = 0; i < dlugosc; i++)
    delete[]tablica[i];
  delete[]tablica;
}

void wypelnianie_planszy (char plansza[11][11])
{
  const int dlugosc_mapy = 11;
  const int ilosc_bomb = 15;
  auto bomby = generowanie_bomb (ilosc_bomb, 11);
  for (int i = 0; i < dlugosc_mapy; i++)
    {
      for (int j = 0; j < dlugosc_mapy; j++)
	{
	  plansza[i][j] = ' ';
	}
    }
  for (int i = 0; i < ilosc_bomb; i++)
    {
      int x = bomby[i][0];
      int y = bomby[i][1];
      plansza[x][y] = 'B';
    }
  usun_tablice_bomb (bomby, ilosc_bomb);
}

void rysujPlansze (char plansza[11][11])
{
    int dlugosc_mapy = 11;
  for (int i = 0; i < dlugosc_mapy; i++)
    {
      std::cout << "|";
      for (int j = 0; j < dlugosc_mapy; j++)
	{
	  std::cout << plansza[i][j];
	}
      std::cout << "|" << std::endl;
    }
}

int main ()
{
  char plansza[11][11];
  wypelnianie_planszy (plansza);
  rysujPlansze (plansza);
  return 0;
}

Poprawiłem losowanie bomb. Zamiast zwracać wskaźnik na pierwszy element lokalnej tablicy zwracam nową dwuwymiarową tablicę dynamiczną. Dodałem funkcję czyszczącą zaalokowaną pamięć (BARDZO WAŻNE). Dodatkowo upewniłem się, że wylosowane współrzędne się nie powtarzają.
Nie wiem, czy twoja plansza jest już wyczyszczona, więc w pierwszym kroku wypełniam ją pustymi polami (spacjami). Następnie umieszczam bomby w wylosowanych polach.