class mit übergebenen array Größen erstellen

[HaWe]

hmm, vielen lieben Dank, das klingt alles wirklich gut. Ich muss jetzt nur noch alles ineinander kriegen, tatsächlich ist dieses hier erst mein zweites C++ OOP Projekt überhaupt.

Erstmal, ist private besser als protected? Oder geht beides? Ist protected evtl flexibler für Zugriffe von "außen" und "innen"?

dann zu

Also statt tMenu * mymenu = new tMenu(); lieber tMenu myMenu;

ja: so hatte ich es ja auch vor als Instanz: tMenu myMenu;


Das wäre jetzt, was ich aus deinen Vorschlägen verstanden habe, mit int16_t als Kompromiss zw. char und int für die sizes,
allerdings völlig unklar wie der constructor jetzt aussehen muss , also wie genau ich den array samt seines Speicherbedarfs dynamisch erzeugen soll:

class tMenu{
   private :

       int16_t  MENULEN, CAPTLEN;      
       char list[MENULEN][CAPTLEN];

   public:      
    
     tMenu (int16_t menulen, int16_t captlen) // constructor
     {       
        MENULEN = menulen;
        CAPTLEN = captlen;

        // .... und wie weiter hier?
     }      

 
     ~tMenu() // destructor
     {
       // Dynamically delete the array we allocated earlier
       delete[] list ;
     }

};

Edit:
zusätzlich rechnen möchte ich ja nicht, weder innerhalb der Klasse noch außerhalb bei Verwendung von Instanzen.
Instanziierung würde ich auch am liebsten ohne template machen, wenn möglich, einfach per

tMenu mymenu(10,20);

für solche Manipulationen in main oder loop:

strcpy(mymenu.list[5], "5 new testline", sizeof(testline));
mymenu.list[5][0]='>';

[HaWe]

wie muss denn also dafür der construcor für den "echten" dynamischen 2-dim array aussehen?

denn diese beiden Methoden

char * list;
list = new char[menulen * captlen]

char ** list;
list = new char*[menulen];
for(int i = 0; i < captlen; i++)
{
   list[i] = new char[captlen];
}

//Zugriff auf stelle x, y
char val = list[x * captlen + y)

scheinen ja nur jew. einen 1-dim array zu erzeugen....?

[HaWe]

also dies funktioniert nicht

class tMenu {
  
  protected:    
        int16_t  MENULEN, CAPTLEN;     
        char    list[MENULEN][CAPTLEN];      
              
  
  public:      
    
     tMenu (int16_t menulen, int16_t captlen) // constructor
     {
        MENULEN = menulen;
        CAPTLEN = captlen;
       
        list = new char*[menulen];
        for(int i = 0; i < captlen; i++)
        {
          list[i] = new char[captlen];
        }
        
     }      

};

exit status 1
invalid use of non-static data member 'tMenu::MENULEN'

so auch nicht:

class tMenu {
  
  protected:    
        int16_t  MENULEN, CAPTLEN;                  
        char    **list;      
  
  public:      
      
     tMenu (int16_t menulen, int16_t captlen) // constructor
     {
        MENULEN = menulen;
        CAPTLEN = captlen;
       
        list = new char*[menulen];
        for(int i = 0; i < captlen; i++)
        {
          list[i] = new char[captlen];
        }
        
     }      
}; 

tMenu mymenu(20,10);
//...
  char test[15]="5 newline_";
  strcpy(mymenu.list[5], test);

exit status 1
'char** tMenu::list' is protected

dies funktioniert offenbar, von außen aufgerufen

class tMenu {
  
  protected:    
        int16_t  MENULEN, CAPTLEN;                  
          
  
  public:      
     char    **list;     
     tMenu (int16_t menulen, int16_t captlen) // constructor
     {
        MENULEN = menulen;
        CAPTLEN = captlen;
       
        list = new char*[menulen];
        for(int i = 0; i < captlen; i++)
        {
           list[i] = new char[captlen];
        }
        
     }      

 
     ~tMenu() // destructor
     {
       // Dynamically delete the array we allocated earlier
       delete[] list ;
     }

};
 

tMenu mymenu(20,10);

void setup(void)
{
  // Start Serial
  
  Serial.begin(115200);
  delay(2000); // wait for Serial()
  Serial.println("Serial started");
  
  char test[15]="5 newline_";
  strcpy(mymenu.list[5], test);
  Serial.println(mymenu.list[5]);
  mymenu.list[5][0]='>';
  Serial.println(mymenu.list[5]);
  //
}

- - - Aktualisiert - - -

was allerdings nicht funktioniert, ist die Benutzung der array Zellen intern,
z.B. per init cstrings reinkopieren:

class tMenu {
  
  protected:    
        int16_t  MENULEN, CAPTLEN; 
        char buf[20];                 
          
  
  public:      
     char    **list;     
     tMenu (int16_t menulen, int16_t captlen) // constructor
     {
        MENULEN = menulen;
        CAPTLEN = captlen;
       
        list = new char*[MENULEN];
        for(int i = 0; i < CAPTLEN; i++)
        {
          list[i] = new char[CAPTLEN];
        }        
     }      
     
     void init() {
        for(int i=0; i<MENULEN; i++) {
           sprintf(buf,"%d line %d", i);
           strcpy(list[i], buf);
        }
     }

 
     ~tMenu() // destructor
     {
       // Dynamically delete the array we allocated earlier
       delete[] list ;
     }

};

//
  tMenu mymenu;
  mymenu.init();

Exception (29):
epc1=0x40205d7b epc2=0x00000000 epc3=0x00000000 excvaddr=0x00000000 depc=0x00000000

ctx: cont
sp: 3fff0250 end: 3fff0550 offset: 01a0

>>>stack>>>
3fff03f0: 00000022 3ffef4fc 00000028 402025a3
3fff0400: 3ffe9d80 4010560e feefeffe feefeffe
3fff0410: feefeffe feefeffe 00000000 4000050c
3fff0420: 3fffc278 40105464 3fffc200 00000022
3fff0430: 3fff0440 feefeffe feefeffe feefeffe
3fff0440: 402040f9 00000030 0000001e ffffffff
(usw...)
<<<stack<<<

- - - Aktualisiert - - -

auch so geht es nicht:

   void init() {
        for(int i=0; i<MENULEN; i++) {
           sprintf(buf,"%d line %d", i);
           strcpy(list[i*CAPTLEN], buf);
        }
     }

wie muss man jetzt stattdessen this->init() richtig codieren?

[HaWe]

also noch mal 1 Schritt zurück:
offenbar lässt sich list[MENULEN][CAPTLEN] intern noch nicht richtig ansprechen, indem man Werte für die Zellen , z.B. cstrings, in die Zellen reinkopiert, genau wie man es von außen per Aufruf einer Instanz können soll:

  strcpy(mymenu.list[5], test);  
  Serial.println(mymenu.list[5]);
  mymenu.list[5][0]='>';
  Serial.println(mymenu.list[5]);

wie muss man intern in der class einen 2-dim array
list[MENULEN][CAPTLEN]
erzeugen, damit man auch intern mit Objekt-Methoden seine Zellen einzeln ansprechen und manipulieren kann?
Noch nicht einmal mit "rechnen"
list[i*CAPTLEN]...
geht es ja bisher...?

class tMenu{
   private :

       int16_t  MENULEN, CAPTLEN;      
      

   public:      
    
     tMenu (int16_t menulen, int16_t captlen) // constructor
     {       
        MENULEN = menulen;
        CAPTLEN = captlen;

        // .... wie ist public list[MENULEN][CAPTLEN] zu erzeuen?     }      


};

[HaWe]

niemand eine Idee, warum die Funktion
mymenu.init();
oben die runtime errors produziert,

warum man anscheinend damit keine strings intern kopieren/initialisieren kann,

warum selbst beim "rechnen" per
list[i*CAPTLEN]...
der runtime error passiert,

und wie man stattdessen korrekt einen einen intern adressierbaren und beschreibbaren 2-dim array konstruieren kann?

[shedepe]

Testest du das am PC? Dann kompilier es mit Debug informationen (-g bei gcc) und führe es mit einem Debugger aus. Dann siehst du genau das Problem.

char ** list;
list = new char*[menulen];
for(int i = 0; i < captlen; i++)
{
   list[i] = new char[captlen];

Dann solltest du auch sehen, dass du in der For Schleife die falsche Variable verwendest

for(int i = 0; i < captlen; i++)

zu:
for(int i = 0; i < menulen; i++)

[HaWe]

danke,
habe es geändert,
trotzdem sofort nach mymenu.init wieder der selbe runtime error mit der exeption

Exception (29):
epc1=0x40205d63 epc2=0x00000000 epc3=0x00000000 excvaddr=0x00000000 depc=0x00000000

ctx: cont
sp: 3fff0280 end: 3fff0560 offset: 01a0

>>>stack>>>
3fff0420: feefeffe 00000028 3ffef250 402025a1
3fff0430: feefeffe feefeffe feefeffe feefeffe
3fff0440: feefeffe feefeffe feefeffe feefeffe
3fff0450: feefeffe feefeffe feefeffe feefeffe

tMenu mymenu(20,10);

void setup(void)
{

  Serial.begin(115200);
  delay(2000); // wait for Serial()
  Serial.println("Serial started");
  
  char test[15]="5 newline_";
  strcpy(mymenu.list[5], test);
  Serial.println(mymenu.list[5]);
   
  mymenu.list[5][0]='>';
  Serial.println(mymenu.list[5]);
  Serial.println();
  for(byte i=0; i<10; i++) {
     Serial.print("-");
     Serial.println(mymenu.list[i]);
  }

  // bis hierhin no problem


  mymenu.init();  // >>> runtime error, exeption
  // ...
}

 
class tMenu {
  
  protected:    
        int16_t  MENULEN, CAPTLEN; 
        char buf[20];                 
          
  
  public:      
     char    **list;     
     tMenu (int16_t menulen, int16_t captlen) // constructor
     {
        MENULEN = menulen;
        CAPTLEN = captlen;
       
        list = new char*[MENULEN];
        for(int i = 0; i < MENULEN; i++)
        {
          list[i] = new char[CAPTLEN];
        }        
     }      
     
     void init() {
        for(int i=0; i<MENULEN; i++) {
           sprintf(buf,"%d line %d", i);
           strcpy(list[i*MENULEN], buf);
        }
     }

 
};

(habe keinen debugger, nur die Arduino IDE)