C ++ zurückkehren und ein Array 2D-Objekt einfügen

Question

Ich versuche, ein Array Daten Mitglied von einem kleineren 2D-Array-Objekt zurück, und versuche, das Array in ein größeres 2D-Array-Objekt einfügen. Aber wenn dieser Versuch kam ich in zwei Probleme.

Die erste Problem ist, dass ich den Namen des 2D-Arrays zurückkehren will, aber ich weiß nicht, wie man richtig Syntax zurückzukehren Namen 2D Array.

Das ist, was mein 2D-Array-Datenelement wie

sieht

private:
int pieceArray[4][4];
// 2D Smaller Array

und ich möchte dieses Array in eine Funktion zurück, aber dies führt zu einem Compiler-Fehler:

int Piece::returnPiece()
{
    return pieceArray; //not vaild
    // return the 2D array name
}

ich müde mit diesem Rückgabetyp und es hat funktioniert:

int Piece::returnPiece()
{
    return pieceArray[4][4];
}

Aber ich bin nicht sicher, ob dies ist, was ich will, wie ich das Array zurückkehren will und all seine Inhalte.

Das andere Problem ist die InsertArray () Funktion, wo ich die returnPiece () Funktion in der InsertArray () 's Argument setzen würde.

Das Problem mit dem InsertArray () ist das Argument, here der Code für sie:

void Grid::InsertArray( int arr[4][4] ) //Compiler accepts, but does not work
{
    for(int i = 0; i < x_ROWS ; ++i)
    {
         for (int j = 0; j < y_COLUMNS ; ++j)
         {
             squares[i][j] = arr[i][j];
         }
    }
}

Das Problem dabei ist, dass es nicht meine returnPiece () nicht akzeptiert, und wenn ich die "[4] [4]" entfernen, mein Compiler nicht akzeptiert.

Meistens alle diese sind Syntaxfehler, aber wie löse ich diese Probleme?

1. Rückgabe des gesamten pieceArray in returnPiece ()
2. Die korrekte Syntax für das Argument in InsertArray ()
3. Das Argument von InsertArray () die Annahme des returnPiece ()

Diese 3 sind die wichtigsten Probleme, die ich brauche Hilfe mit und hatten das gleiche Problem, wenn ich die Zeiger Zeiger-Methode zu verwenden versuchen. Wer weiß, wie diese drei Probleme zu lösen?

Answer 1

Wenn Ihr Array, das um, müssen Sie entscheiden, ob Sie eine Kopie des Arrays machen wollen, oder wenn Sie wollen einfach nur einen Zeiger auf das Array zurückzukehren. Für die Wieder-Arrays können Sie nicht (leicht) zurückgeben eine Kopie - nur einen Zeiger (oder Referenz in C ++) zurückkehren kann. Zum Beispiel:

// Piece::returnPiece is a function taking no arguments and returning a pointer to a
// 4x4 array of integers
int (*Piece::returnPiece(void))[4][4]
{
    // return pointer to the array
    return &pieceArray;
}

Um es zu nutzen, rufen Sie es wie folgt:

int (*arrayPtr)[4][4] = myPiece->returnPiece();
int cell = (*arrayPtr)[i][j];  // cell now stores the contents of the (i,j)th element

Beachten Sie die Ähnlichkeit zwischen der Typdeklaration und deren Verwendung -. Klammer, Operator * dereferencing und Klammern sind an den gleichen Stellen

Ihre Erklärung für Grid::InsertArray ist richtig - es nimmt ein Argument, das ein 4x4-Array von ganzen Zahlen ist. Dies ist Call-by-Wert:., Wann immer Sie es nennen, Sie eine Kopie Ihrer 4x4-Matrix zu machen, so dass jede Änderung, die Sie vornehmen, werden nicht in dem Array übergebenen reflektiert Wenn Sie stattdessen Call-by-Referenz verwenden wollten, könnten Sie passiert einen Zeiger auf ein Array statt:

// InsertArray takes one argument which is a pointer to a 4x4 array of integers
void Grid::InsertArray(int (*arr)[4][4])
{
     for(int i = 0; i < x_ROWS; i++)
     {
         for(int j = 0; j < y_COLUMNS ; j++)
             squares[i][j] = (*arr)[i][j];
     }
}

Diese Typdeklarationen mit Zeigern auf mehrdimensionale Arrays kann wirklich verwirrend schnell. Ich empfehle Herstellung eines typedef es etwa so:

// Declare IntArray4x4Ptr to be a pointer to a 4x4 array of ints
typedef int (*IntArray4x4Ptr)[4][4];

Dann können Sie Ihre Funktionen viel besser lesbar erklären

IntArray4x4Ptr Piece::returnPiece(void) { ... }
void Grid::InsertArray(IntArray4x4Ptr arr) { ... }

Sie können auch die cdecl Programm zu helfen entziffern komplizierte C / C ++ Typen.

Answer 2

Es scheint, wie Sie auf Zeiger in C mehr lesen ++ und auf Pass von Referenz vs. Pässe von Wert.

Ihre returnPiece Methode wird als die Rückgabe des Werts einer einzelnen Zelle definiert. Angesichts den Index (zum Beispiel [4] [4]) Sie geben eine Kopie des Inhalts dieser Zelle, so dass Sie es nicht ändern können, oder richtiger gesagt, ändert es würde die Kopie ändern.

Ich bin sicher, dass jemand finden Sie die richtige Syntax geben, aber ich würde dieses Zeug zu lernen wirklich empfehlen, da sonst können Sie den Code verwenden, die Sie falsch tun bekommen.

Answer 3

Hier ist, wie ich es tun würde:

class Array {
  public:

    Array() {
      for (int i = 0; i < 4; ++i)
      {
         for (int j = 0; j < 4; ++j)
         {
            (*this)(i, j) = 0;
         }
      }
    }


    int &operator()(int i, int j)
    {
      return pieceArray[i][j];
    }

  private:
    int pieceArray[4][4];
};

Sie können dann so etwas wie:

  Array x; // create 4x4 array
  x(1, 2) = 3; // modify element

Answer 4

Ärger mit Adam Rosenfield ist arrayPtr , dass Piece :: pieceArray können unter Ihnen ändern aus. (Copy-by-reference vs Copy-by-Wert).

Copy-by-Wert ist ineffizient. Aber wenn Sie es wirklich wollen tun, nur betrügen:

struct FOO { int  piece [4][4]; };

FOO Piece::returnPiece()
{
  FOO f;
  memcpy( f.piece, pieceArray, sizeof(pieceArray) );
  return f;
}

void Grid::InsertArray( const FOO & theFoo )
{
  // use theFoo.piece[i][j]
}

Natürlich eine bessere, objektorientierte Lösung, wäre zu haben, returnPiece () erstellen und gibt ein Stück oder Array Objekt. (A Juan vorgeschlagen ...)