Array of pointers to arrays

Captain

Hallo zusammen!

Ich sitze seit 3 Stunden vor folgendem Problem und komme nicht weiter. In sämtlichen Büchern und google hab ich nichts brauchbares gefunden.

Ich habe folgende mehrdim. Arrays:

int c0[][5] =	{	{0,1,1,1,0} , 
						{1,0,0,0,1} ,
						{1,0,0,0,1} ,
						{1,0,0,0,1} ,
						{1,0,0,0,1} ,
						{1,0,0,0,1} ,
						{0,1,1,1,0} };

	int c1[][5] =	{	{0,0,1,0,0} , 
						{0,1,1,0,0} ,
						{0,0,1,0,0} ,
						{0,0,1,0,0} ,
						{0,0,1,0,0} ,
						{0,0,1,0,0} ,
						{0,1,1,1,0} };

Ich will z.b. per int arraynummer = 1; auf die einzelnen Elemente von c1 zugreifen. Nur wie stelle ich das an ?

Folgendes hab ich unter anderem schon probiert:

int *cc[2] = { &c0, &c1 };
int *ccp;
int value;
ccp = cc[arraynummer];
value = (&cc[arraynummer])[xi][yi];

Aber das geht leider nicht...

Vielen Dank im Voraus für alle Tips!

Liebe Grüße,
Hannes.

SirLant

Mal aus dem Kopf, weiß nicht ob es geht, aber vllt. hilft es dir ja

int c0[][5] =    {    {0,1,1,1,0} ,  
                        {1,0,0,0,1} , 
                        {1,0,0,0,1} , 
                        {1,0,0,0,1} , 
                        {1,0,0,0,1} , 
                        {1,0,0,0,1} , 
                        {0,1,1,1,0} }; 

int c1[][5] =    {    {0,0,1,0,0} ,  
                        {0,1,1,0,0} , 
                        {0,0,1,0,0} , 
                        {0,0,1,0,0} , 
                        {0,0,1,0,0} , 
                        {0,0,1,0,0} , 
                        {0,1,1,1,0} };

int *ZeigerArrayAufC1UndC2[] = { c0, c1 };
int *ZeigerAufC1 = &ZeigerArrayAufC1UndC2[1];
int value = ZeigerAufC1[3][4]; //Spalte 3 Zeile 4
int **ZeigerAufC1OderC2 = ZeigerArrayAufC1UndC2;
int wert = ZeigerAufC1OderC2[0][3][4]; // C0 Spalte 3 Zeile 4

Wie gesagt ungetestet müsste aber so gehen.

Captain

Vielen Dank für Deine Antwort!

Leider geht keine der beiden Methoden. Habs so oder so ähnlich schon probiert gehabt, aber es kommt immer

error C2109: subscript requires array or pointer type

bei

int value = ZeigerAufC1[3][4]; //Spalte 3 Zeile 4

und

int wert = ZeigerAufC1OderC2[0][3][4]; // C0 Spalte 3 Zeile 4

Liebe Grüße,
Hannes.

SirLant

Habe es eben auch mal in nem Beispielprogramm testen wollen, bekam die gleichen
Fehler, weiß im mom aber echt nicht wo mein Denkfehler liegt.
Mal sehen ob es mir noch einfällt.

Edit:
Ne heut hab ich echt kein Kopf mehr dazu, habe eben nochmal an etwas rumexperimentiert,
aber bekomme es nicht hin über ein zeigerArray auf die beiden Array zu dereferenzieren
und dazu noch in die richtige Zeile sowie Spalte.
Sorry

Captain

Danke Dir jedenfalls recht herzlich für Deine Bemühungen!

Vielleicht hat wer anderer noch eine Idee...

Liebe Grüße,
Hannes.

Captain

Hab gerade noch 2 Stunden herumprobiert und gesucht, aber es ist wie verhext... entweder das Teil läßt sich kompilieren und hängt sich dann aber auf oder es läßt sich erst gar nicht kompilieren...

Vielen Dank im Voraus falls noch wer Ideen hat!

Liebe Grüße,
Hannes.

> Array of pointers to arrays <<

Hab's mir nicht genau angeguckt aber ein Array mit Pointern hast du nicht,
sondern einen mehrdimesionalen array !

Ein array mit pointern wäre z.B. das hier:

int *c0[5];

vielleicht hilft's ja.

IMHO kannst du nur auf Konstanten zeigen mit einem Zeigerarray.

Also würde z.B.

char *p[2] = { "illegal", "true"};

/*und ein Zugriff mit p[0]/p[1] funktionieren, da "illegal u. "true"
  konstante Zeichenketten sind.*/

Warum behälst du nicht einfach dein mehrdimensionales Array nicht
zur Indizierung bei , ohne Zeiger?

Captain

BWK, hier ist mein array of pointers

int *cc[2] = { &c0, &c1 };

xy, leider weis ich nicht genau was Du damit meinst:

Warum behälst du nicht einfach dein mehrdimensionales Array nicht
zur Indizierung bei , ohne Zeiger?

Liebe Grüße,
Hannes.

SirLant

Ich habe mich selbst mal schlau gemacht bzw. nachgefragt und das sollte gehen,
sieht auch einleuchtend aus:

// int-array mit größe 4x4
int   myArrayA[4][4],
      myArrayB[4][4],
      myArrayC[4][4];

// array von zeigern auf int-arrays mit größe 4x4
int (*apMyArray[3])[4][4];

apMyArray[0] = &myArrayA;
apMyArray[1] = &myArrayB;
apMyArray[2] = &myArrayC;

apMyArray[0][2][3] = 1; // 1. Array, 3. Zeile, 4. Spalte
apMyArray[1][1][0] = 1; // 1. Array, 2. Zeile, 1. Spalte
                        // ...

Captain

Es geht jetzt! Vielen Dank!

Allerdings muß es heissen:

*(apMyArray[1])[1][0] = 1;

Nur schaffe ich es nicht, daß z.b. myArrayA schon mit Werten gefüllt ist.

In der final-version habe ich ca. 40 solcher arrays:

int c0[][5] =    {    {0,1,1,1,0} ,  
                        {1,0,0,0,1} , 
                        {1,0,0,0,1} , 
                        {1,0,0,0,1} , 
                        {1,0,0,0,1} , 
                        {1,0,0,0,1} , 
                        {0,1,1,1,0} };

und da ist eine Einzelzuweisung für jedes Element zu aufwändig.
Wie kann man in Deiner Lösung die myArray's vordefinieren ?

Vielen Dank nochmals!
Liebe Grüße,
Hannes.

Captain

Hallo zusammen!

Hab das ganze jetzt mal ein wenig ruhen lassen - mit dem Gedanken, daß ich vielleicht jetzt draufkomm' - aber nichts da. Die Initialisierung der Arrays haut nicht hin:

// int-array mit größe 4x4 
int   myArrayA[4][4] = {    {11,12,13,14} ,   
                            {21,22,23,24} ,  
                            {31,32,33,34} ,  
                            {41,42,43,44} };

int	  myArrayB[4][4]; 
int	  myArrayC[4][4]; 

// array von zeigern auf int-arrays mit größe 4x4 
int (*apMyArray[3])[4][4]; 

apMyArray[0] = &myArrayA; 
apMyArray[1] = &myArrayB; 
apMyArray[2] = &myArrayC; 

//	*(apMyArray[0])[2][3] = 134; // so funktionierts, aber nicht mit der init. oben

printf("*(apMyArray[0])[2][3] = %d\n", *(apMyArray[0])[2][3]);

// Ergebnis: *(apMyArray[0])[2][3] = 4199240 ????????

Hat noch wer Ideen wie man die Initialisierung der Arrays anders lösen kann ?
Denn für hunderte Werte ist mir
*(apMyArray[0])[2][3] = 134;
einfach zu unsauber.

Vielen Dank!

Liebe Grüße,
Hannes