Ausgabe mehrdimensionales Array mit Zeigeroperationen

Habe das Problem, dass ich es nicht schaffe, die Werte dieses mehrdimensionalen Arrays auszugeben. Wo liegt der Fehler?!

#include <stdio.h>
#define DIMX 4
#define DIMY 3

int main(void)
{
int dimx=DIMX,
    dimy=DIMY,
    iMin=0,

  // Warum erhalte ich immer die Speicheradressen anstatt der Werte?!
   iAry[DIMY][DIMX]={{12,19,99,8},{55,-6,7,-33},{9,10,11,12}};

  //Mit nur einer Dimension würde es gehen (Werte werden ausgegeben)
  //iAry[DIMX*DIMY]={23,423,2,-2,-21,56,75,64,23,12,8,5};

    for (iMin=0; iMin<(DIMY*DIMX); iMin++)
	printf("%d\n", *(iAry+iMin));

return 0;
}

akari

Hallo

da du im C++ Forum gepostest hast :

#include <iostream>
const int DIMX = 4;
const int DIMY = 3;

int main()
{

  // Warum erhalte ich immer die Speicheradressen anstatt der Werte?!
  int iAry[DIMY][DIMX]={{12,19,99,8},{55,-6,7,-33},{9,10,11,12}};

  for (int x = 0; x < DIMX; x++)
  {
    for (int y = 0; y < DIMY; y++)
      std::cout << iAry[y][x] << " ";
    std::cout << std::endl;
  }

return 0;
}

bis bald
akari

Ich verstehe nicht ganz dein Problem. Liegt der Fehler in der Ausgabe der Werte oder äußert er sich bei der Speicherung in dem Array?

Folgende Beispielapplikation sollte funktionieren.

#include <iostream>
using namespace std;

int main()
{
  static const int dimx = 4;
  static const int dimy = 3;

  int v[dimy][dimx] = { {12, 19 ,99 ,8},
			{55, -6, 7, -33},
			{9, 10, 11, 12} };

  for (int i=0; i<dimy; ++i)
    for (int j=0; j<dimx; ++j)
      cout << v[i][j] << endl;

  return 0;
}

Ausgabe:

12
19
99
8
55
-6
7
-33
9
10
11
12

Edit: Ich bin wohl immer ein Tick zu langsam

Danke für eure Hilfe, aber ein Student hat es da nicht so einfach. Es gilt das Ganze ohne die Benutzung von eckigen Klammern zu bewerkstelligen :-p

Also nur mit Zeigern...

Wenn ich das Ganze mit einem eindimensionalem Array laufen lasse, erhalte ich (durch den Dereferenzierungsoperator) die Werte. Nur beim Mehrdimensionalen dann die Adressen, obwohl ich nichts verändere...

CStoll

Um ein mehrdimensionales Array auszugeben, mußt du auch doppelt dereferenzieren:

*(*(arr+x)+y)

#include <iostream>
using namespace std;

int main()
{
  static const int dimx = 4;
  static const int dimy = 3+1;  // nullterminiert

  /**
   * Zweidimensionales Array initialisieren. '\0' repraesentiert das
   * Ende des Arrays
  */
  int v[dimy][dimx] = { {12, 19 ,99 ,8},
			{55, -6, 7, -33},
			{9, 10, 11, 12},
			{'\0'} };

  /**
   * Zeiger auf das Erste Element des Arrays. Die Elemente befinden
   * sich der Reihe nach im Speicher. Es reicht also, wenn man den
   * Zeiger dereferenziert und anschließend inkrementiert. Das
   * Vorkommen von '\0' beenden die Schleife.
  */
  int* p = &v[0][0];
  while (*p) cout << *p++ << endl;

  return 0;
}

CStoll schrieb:

Um ein mehrdimensionales Array auszugeben, mußt du auch doppelt dereferenzieren:
*(*(arr+x)+y)

Warum? Die einzelnen Felder stehen doch hintereinander im Speicher... oder?!

btw: Beziehe mich hier auf die SPrache "C" - kein C++! (sry)

CStoll

Die einzelnen Elemente deines Arrays sind vom Typ "Array of int" (also selbst wieder Arrays), d.h. um auf die Elemente dieser Teilarrays zugreifen zu können, benötigst du noch eine Dereferenzierung (btw: der Indexzugriff "a[i]" ist äquivalent zur Pointer-Arithmetik "*(a+i)").

CStoll schrieb:

Die einzelnen Elemente deines Arrays sind vom Typ "Array of int" (also selbst wieder Arrays), d.h. um auf die Elemente dieser Teilarrays zugreifen zu können, benötigst du noch eine Dereferenzierung (btw: der Indexzugriff "a[i]" ist äquivalent zur Pointer-Arithmetik "*(a+i)").

Das ist mir klar, und analog folgere ich daraus, dass a[i][j] äquivalent ((a+i)+j) sein sollte...

VS .NET 03 hält das aber für eine ungültige Zeigeroperation...

btw: Beziehe mich hier auf die SPrache "C" - kein C++! (sry)

Das Konzept der Arrays gibt es in C und in C++. Es ist letzten Endes egal ob du in C oder in C++ programmierst; spielt für dieses Problem keine Rolle!

Die einzelnen Felder stehen doch hintereinander im Speicher... oder?!

Genau deswegen kann man sich das ((a+i)+j) Konstrukt sparen, auch wenn dieses funktionieren würde - bekanntlich führen ja mehrere Wege nach Rom.