nochmal Arraypointerreferenztohuwabohu

[Moppi]

Stört vielleicht, dass von "(**mlist0)" nach "void importlist ( char ** extlist )" konvertiert werden soll?
Leider werde ich hier nicht weiter helfen können, weil ich mich damit zu wenig auskenne. Werde ich auch mal abstellen müssen...

[HaWe]

vermutlich hat gestört, dass von der Form
char list1[a][b]
in die Form von
char **list2
übertragen werden sollte, daher mein Versuch des expliziten casts
(char**) list1 // list1[a][b] ->-> **list1
dann --> als Parameter für Funktion importlist (char ** list2)

führt dann aber zu Laufzeitfehlern, wenn die array-Inhalte kopiert werden sollen

Ich weiß nur absolut nicht, wie es stattdessen richtig geht

[Moppi]

Hier definierst Du die Liste:

char mlist0[6][11]

mit ** mlist0 erzeugst Du einen Zeiger. (mit dem ersten * auf mlist0[x] und mit dem zweiten * auf mlist[x][x])

Was ist, wenn Du so den Aufruf machst: menu0.importlist(*mlist0);

Und Deine Funktion so gestaltest: void importlist ( char * extlist )

Weil, beim Kopieren verwendest Du ja nur:extlist[line] nicht: extlist[x][line]

Aber wie gesagt, ich glaube, ich stifte nur mehr Verwirrung!

[Ceos]

deine Deklaration macht mir irgendwie Kopfschmerzen ... aber für die symmetrie ist es schon nicht ganz verkehrt

(nicht böse gemeint, da schrillen nur ein paar alarmglocken)

deklariere doch ein

char* mlist[]

und fülle es mit

char* entry0 = "bla"
char* entry1 = "foo"
mlist[0] = entry0;
mlist[1] = entry1;

ist zwar etwas umständlich aber explizit

und in deiner import funktion kannst du auch so etwas schreiben
void importlist ( char * extlist[] )
damit sollte es besser funktionieren, probiert haeb ich es aber nciht ... das Problem ist nämlich dass die strings dabei unterschiedlich lang sind was weider andere phänomene hervorrufen kann

[Moppi]

Ich habs jetzt mal so:

void importlist (char ** extlist )

und so:

tMenu menu0(char ** mlist0);


Nur so wird es für ein ESP-12E ohne Warnung und Fehler compiliert.

[HaWe]

man kann eine
char ** mlist;
ja nicht initialisieren als
{"Titel","ESC","Ja","Nein","foo","bas"}; // error !!

Das ist aber wesentlich, sonst wird es bei der Initialisierung aller Menüpunkte aller Menüs und Untermenüs zu kompliziert.

also brauche ich für den Original-Array
char mlist[6][11] = {"Titel","ESC","Ja","Nein","foo","bas"};

und den will ich jetzt an die Funktion
tMenu::import() // (fraglich ob hier als Argument (char ** extlist) richtig ist ?!? )
übergeben,

denn man kann als Funktions-Argument kein
import(char extlist[MENULEN][LINELEN])
definieren, zumal MENULEN und LINELEN grundsätzlich in der Class variabel sind und keine Konstanten (ihre Größe wird erst bei Instanziierung des Objekts bekannt gegeben, wenn die interne list erzeugt wird)

public:      
     char ** list;

  tMenu (int16_t menulen, int16_t linelen, tMenu* pMenu) {   // constructor
     MENULEN = menulen;    
     LINELEN = linelen; 
     list = new char*[MENULEN];
        for(int i = 0; i < MENULEN; i++)
        {
          list[i] = new char[LINELEN+1];
        }

habe ich es erst mal übergeben, kann ich die Liste von strings in der Objekt-Methode weiterverwenden:

for(int line=0; line<MENULEN; line++) {
strncpy( list[line], extlist[line], strlen( list[line] ) );
...

Offenbar ist das für die Übergabe mit den ** falsch, aber wie geht es richtig?

Wie übergibt man einen 2-dim array (bzw. eine Aufzählung von cstrings) per Pointer oder als Kopie an einen zweiten 2-dim array?

[Moppi]

char mlist0[6][11] = {"menu0","ESC >","Ja","Nein","foo","bas"};

class tMenu{
 private:
   int MENULEN;
 public:
   char ** list; //char * list[];


   void importlist (char ** extlist ) {
        int16_t N = MENULEN;
        for(int line=0; line<N; line++) {
           strncpy( list[line], extlist[line], strlen(extlist[line]) );
        }
  }
};


void setup(){
}


void loop(){
  tMenu menu0(char ** mlist0);
}

[HaWe]

ist das nicht mein eigener Code?
Der war zwar zu kompilieren, aber ergab ja einen Runtime Error.

Oder hast du daran etwas verändert?

[HaWe]

ach so, du übergibst auch schon die Liste an den Constructor...
mal sehen...

- - - Aktualisiert - - -

tMenu menu0(char ** mlist0);

gehört aber global instanziiert, nicht jedes Mal neu in der loop,
und warum übergibst du die Liste mlist0 als Doppelpointer mitsamt Variablentyp char** ?
Parameter führen doch keine Typen beim Aufruf...?
Das gibt bei mir zumindest auch einen compile error.

Instanziiere ich indes global per

tMenu menu0(6,11, (char**)mlist0 );

lässt es sich kompilieren, erzeugt aber ebenfalls wieder einen Laufzeitfehler, wie schon zuvor

rst cause:4, boot mode: (1,7)
wdt reset

class tMenu {       
  protected:  
     int16_t    MENULEN, LINELEN, VISLNUM, FONTHI; 
  
  public:      
     char ** list; 
     tMenu * preMenu;
     int16_t act; 

     tMenu (int16_t menulen, int16_t linelen, char ** extlist)    // constructor     
     {
        MENULEN = menulen;  // number of available menu options        
        LINELEN = linelen;  // line length of menu options       
                        
        list = new char*[MENULEN];
        for(int i = 0; i < MENULEN; i++)
        {
          list[i] = new char[LINELEN+1];
          strncpy( list[i], extlist[i], LINELEN);
        }     
                       
     }      
};
//

[HaWe]

habe es hingekriegt, bin selber überrascht:

 tMenu (int16_t menulen, int16_t linelen, char ** extlist, tMenu* pMenu) :   // constructor
     MENULEN(5), LINELEN(11), VISLNUM(5), FONTHI(13), act(0)  
     {
        firstvln=0; lastvln=0; displn=0;     
        act=0;
        MENULEN = menulen;  // number of available menu options        
        LINELEN = linelen;  // line length of menu options       
        preMenu = pMenu;    // predesessor menu       
                
        list = new char*[MENULEN];
        for(int i = 0; i < MENULEN; i++)
        {
          list[i] = new char[LINELEN+1];
          strncpy( list[i], extlist[i], strlen(extlist[i]));
        }                            
     }

char * mlist0[11] = {"Titel 0","Zeile1","zu menu02>","Zeile3","Zeile4","Zeile5"}; 
tMenu menu0(6,11, (char**)mlist0, &menu0);  // numEntries, lineLength, preMenu (N/A);

char * mlist02[11] = {"Titel 02","ESC>","Zeile2","Zeile3","zu menu024"};
tMenu menu02(5,11, (char**)mlist02, &menu0);  // numEntries, lineLength, preMenu=menu0;
 
char * mlist024[11] = {"Titel 024","ESC >","Ja","Nein","foo","bas"}; 
tMenu menu024(6,11, (char**)mlist024, &menu02); // numEntries, lineLength, preMenu=menu02;

Ausgabe der Menüs, völlig korrekt (Ausgabe hier testweise nur immer max. 5 Einträge):

>Titel 0
 Zeile1
 zu menu02>
 Zeile3
 Zeile4

>Titel 02
 ESC>
 Zeile2
 Zeile3
 zu menu024

>Titel 024
 ESC >
 Ja
 Nein
 foo