3. Array-Elemente in anderem Array referenzieren

Array-Elemente in anderem Array referenzieren

  • S

    hi,

    wie kann ich die Elemente eines Array A in einem zweiten Array B referenzieren, so dass beim Ändern von Werten in A oder B das jeweils andere Array mit geändert wird?

    Dabei soll aber Array B um 90 Grad gedreht vorliegen, d.h. die Spalten in Array A sollen quasi die Zeilen in Array B darstellen.

    Beispiel:

    Array A, Breite = 4, Höhe = 3
    Array B, Breite = 3, Höhe = 4

    A[0][0] = B[0][0]
    A[1][0] = B[0][1]
    A[2][0] = B[0][2]
    A[3][0] = B[0][3]
    usw.

    0
  • L

    Ich weiß nicht ob das funzt aber ich würde das Array B erst mal als Referenz deklarieren und dann die B auf A richten. Somit ist B lediglich Synonym für A und umkehrt.

    0
  • L

    du könntest auch b als pointer array deklarieren und dann nur die adressen der elemente von a zuweisen

    0
  • M

    Du kannst auch ne Klasse schreiben und A und B als Memberfunktionen bereitstellen, die unterschiedlich auf das interne Array zugreifen:

    int &A(int x, int y) { return *(pointer + x*size + y); }
int &B(int y, int x) { return *(pointer + x*size + y); }
    0
  • N

    So in etwa:

    template<class T,unsigned x,unsigned y>
class array
{
private:
    T a[x][y];
public:
    //fehlt natürlich ne Menge...
    T get_at(unsigned xi,usigned yi)const{assert(xi<x&&yi<y);return a[x][y];};
    void set_at(unsigned xi,unsigned yi,T d){assert(xi<x&&yi<y);a[x][y]=d;};
    T operator()(unsigned xi,yi)const    //hab grad keine Lust aufn proxy
        {return get_at(xi,yi);};
    T& operator()(unsigned xi,unsigned yi)
    {
        assert(xi<x&&yi<y);
        return a[x][y];
    };
};

template<class T,unsigned x,unsigned y>
class rot_array_ref
{
private:
    array<T,x,y>& a;
public:
    rot_array_ref(array& ar):a(ar){};
    T get_at(unsigned xi,unsigned yi)const{return a.get_at(//was auch immer
    //...
};
    0
  • S

    naja, das ist alles nicht das was ich zu ereichen erhoffe. ich versuche es mal genauer zu erklaeren...

    beispiel mit einem 1D-Feld

    int *test1 = new int[2];  // Array mit 2 Elementen
int *test2 = new int[2];  // dito

int **ptest = &test2;

*ptest++ = &test1[0];
*ptest   = &test1[1];

// Werte zuweisen
test1[0] = 1;
test2[1] = 5;

    wenn ich mir jetzt test1 und test2 ausgeben lassen, enthalten beiden die gleichen werte, egal ob ich die in test1 oder test2 zuweise.

    leider gelingt es mir nicht dieses auf ein 2D-Array zu uebertragen, so dass ich einmal spalten- und einmal zeilenweise auf die elemente zugreifen kann.

    Beispiel: Erzeugen eines 2D-Array (zeilenweiser Zugriff)

    int   ydim  = 3;
int   xdim  = 5;
int **Array = new int *[ydim];

for (int y = 0; y < ydim; ++y)
  Array[y] = new int[xdim];

    nun kann ich ja wie folgt darauf zugreifen:

    int *ArrayRow;

for (int y = 0; y < ydim; ++y)
{
  ArrayRow = Array[y];

  // zeilenweiser Zugriff
  for (int x = 0; x < xdim; ++x)
    ArrayRow[x] = x * y;
}

    was natürlich besser ist als:

    for (int y = 0; y < ydim; ++y)
  for (int x = 0; x < xdim; ++x)
    ArrayRow[y][x] = x * y;

    denn man erspart sich in der inneren Schleife den 2. Arrayzugriff auf die Zeile.

    nun möchste ich gerne das auch folgendes geht:

    int *ArrayCol;

for (int x = 0; x < xdim; ++x)
{
  ArrayCol = Array[x];

  // spaltenweiser Zugriff
  for (int y = 0; y < ydim; ++y)
    ArrayCol[y] = x * y;
}

    es soll also der zeilenweise und auch der spaltenweise zugriff möglich sein, ungeachtet dessen, das man den doppelten speicherbedarf hat.

    ist das ueberhaupt möglich?

    0
  • P

    dein Bsp. für ein 1-dim Array scheint aber seine Macken zu haben?
    Wenn ich am Ende noch ein "delete []test1;" und "delete []test2;" mache gibts Laufzeitfehler bei mir ...

    0
  • F

    Sunday schrieb:

    es soll also der zeilenweise und auch der spaltenweise zugriff möglich sein, ungeachtet dessen, das man den doppelten speicherbedarf hat.

    ist das ueberhaupt möglich?

    Zwei kleine Denkansätze:

    template <typename T>
class ArrayCol
{
public:
  ArrayCol( T** data, std::size_t col )
    : data_(data)
    , col_(col)
  { } // empty

  T operator[]( std::size_t index ) const
  { return data_[index][col_]; }

private:
  T**  data_;
  std::size_t  col_;
};

typedef unsigned int uint;

int main()
{
  size_t nrows = 5, ncols = 5;
  int** arr = new int*[nrows];
  for (uint row = 0; row < nrows; ++row) {
    arr[row] = new int[ncols];
    for (uint col = 0; col < ncols; ++col) {
      arr[row][col] = row * ncols + col;
    }
  }

  ArrayCol<int> arrCol(arr, ncols/2);
  for (uint row = 0; row < nrows; ++row) {
    std::cout << arrCol[row] << '\n';
  }
  std::cout.flush();

  for (uint row = 0; row < nrows; ++row) {
    delete[] arr[row];
  }
  delete[] arr;
}
    0
  • S

    Danke für den Code, aber damit verlagert sich der doppelte Array-Zugriff nur in die Klasse. Ich möchte aber gern erreichen, dass in der inneren Schleife nur noch ein Array-Zugriff benötigt wird egal ob ich zeilenweise oder spaltenweise ueber die Array-Elemente gehen.

    Gehen würde es mit nem dreidimensionalen Array wo ich mir einfach die Zeiger auf die einzelnen Elemente des anderen Array speichere. Dann muss ich aber immer den Dereferenzoperator aufrufen, wenn ich auf die Elemente zugreifen will, was letzt endlich dann auch dem normalen Zugriff gleichkommt.

    0
  • S

    nochmal pushen

    0
  • P

    ich würde sagen in deinem Code geht das nicht. du hast ja kein richtiges 2-dimensionales Feld, sondern die Zeilen liegen verstreut im Speicher.

    Wenn du das zweidimensionale Feld auf ein eindimensionales selber abbildest, also "alles am Stück" kannst du über entsprechende Indexberechnung das auf eine Schleife bekommen, aber ob das dann so viel besser ist ...

    0
Anmelden zum Antworten