#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;
}

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

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

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...

*(*(arr+x)+y)

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)

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.