sehe vor lauter pointer den wald nicht mehr

[Master S. (snowman)]

hallo zusammen.

ich habe:

const char *ListeA[] = {
   "Text 1A",
   "Text 2A",
   "Text 3A"
};
const char *ListeB[] = {
   "Text 1B",
   "Text 2B"
};
const char *ListeC[] = {
   "Text 1C",
   "Text 2C",
   "Text 3C",
   "Text 4C"
};

const char *(*AlleListen[]) = {ListeA, ListeB, ListeC};

void DisplayText(char *text) {...}

jetzt habe ich aber probleme, um innerhalb von funktionen auf diese 
arrays zuzugreifen.

void funktion1(char* ListeX[]) {...}
// hier ListeX = {ListeA, ListeB, ListeC}
// hier möchte ich auf die einzelnen texte von ListeX zugreifen können
// z.b. DisplayText(ListeX[i]);

void funktion2(char* ListeX[]) {...}
// hier ListeX = AlleListen
// hier möchte ich auf die einzelnen texte von ListeX zugreifen können
// z.b. DisplayText(ListeX[i][j]);

ich bin froh um jegliche hilfe, oder fehler bei der deklaration etc. 
danke

[Master S. (snowman)]

danke für die formatierung

>> Das kann schon mal nicht stimmen.
ja eben, ich stehe irgendwie auf dem schlauch. auch mit 'char 
*(*AlleListen[])' ging's nicht. nun, wie soll ich das machen mit 
typedefst?

und wie ginge es, wenn ich funktion2 auch nur eine eindimensinales array 
übergeben möchte aber nur 'AlleListen[]' habe, z.b. AlleListen[2] 
übergeben mlchte?

danke!

[Tom (Gast)]

http://openbook.galileocomputing.de/c_von_a_bis_z/012_c_zeiger_009.htm#mj477a1c84c32c1708b923a6f03df18868

[Karl H. (kbuchegg)]

Der ganze Ansatz kann so nicht funktionieren, weil du in AlleListen 
keine Möglichkeit mehr hast, die tatsächlichen Längen der einzelnen 
Teilarrays festzustellen. Du brauchst also eine Zwischenstruktur, mit 
der du diese Information ergänzen kannst.

#include "stdafx.h"

const char* ListeA[]= {
   "Text 1A",
   "Text 2A",
   "Text 3A"
};

const char* ListeB[] = {
   "Text 1B",
   "Text 2B"
};

const char* ListeC[] = {
   "Text 1C",
   "Text 2C",
   "Text 3C",
   "Text 4C"
};

#define ARRAY_LEN(x) (sizeof(x)/sizeof(*x))

struct TextSubList {
  int          nrElements;
  const char** Elements;
};

struct TextSubList AlleListen[] = {
  { ARRAY_LEN(ListeA), ListeA },
  { ARRAY_LEN(ListeB), ListeB },
  { ARRAY_LEN(ListeC), ListeC }
};

void DisplayText(const char *text)
{
  printf( "%s\n", text );
}

void function1( struct TextSubList* EineGruppe )
{
  int i;

  for( i = 0; i < EineGruppe->nrElements; i++ )
    DisplayText( EineGruppe->Elements[i] );
}

void function2( int nrGruppen, struct TextSubList* AllGruppen )
{
  int i;

  for( i = 0; i < nrGruppen; i++ ) {
    printf( "******\n" );
    function1( &AllGruppen[i] );
  }
}

int main()
{
  function2( ARRAY_LEN( AlleListen ), AlleListen );
}

[Master S. (snowman)]

ich dachte, da es 'const' sind, kann sich der compiler zur 
compilier-zeit die adressen berechnen. Danke für den code und den link, 
da werde ich wohl noch etwas nacht-lektüre haben...

[Karl H. (kbuchegg)]

Master Snowman schrieb:
> ich dachte, da es 'const' sind, kann sich der compiler zur
> compilier-zeit die adressen berechnen.

Die Adressen: ja

Aber wieviele sind es denn pro Subliste? 2, 3, oder 4?

[Master S. (snowman)]

OK jetzt funktioniert's :-) der text über pointer auf pointer hat mir 
die augen geöffnet. danke.

[W.S. (Gast)]

Mein Rat:

Laß lieber die Finger auf solche Konstrukte wie Zeiger auf Zeiger auf 
sonstwas.

Denk dir lieber eine ganz andere Strategie aus. C hat keine 
mehrdimensinalen Felder, das sollte man sich ganz dick hinter die Ohren 
schreiben und beherzigen. Jeder Versuch, sich mit sowas wie 
MyBlabla[x][y}[z] zu behelfen, läuft auf etwas hinaus, daß der naive 
Programmierer SO nie beabsichtigt hatte.

Mein Vorschlag: Arbeite mit einer Art Handle und laß dir den zugehörigen 
Text von einem Unterprogramm liefern. Mehr Code als für das mehrfache 
Dereferenzieren braucht das auch bloß nicht.
Ich hab das bei meinen Geräten etwa so gemacht:

#define  txt_KlappeAuf  1
#define  txt_KlappeZu   2
#define  txt_FensterAuf 3
.. usw.

char* GetText (int handle, int language)
{...
}


W.S.