Konstanten String in Klasse initialisieren?



  • Ich würde sagen: Geht nicht !
    Compiler sagt: "ISO C++ forbids assignment of arrays"

    Gruß,

    Simon2.



  • Boris hat wohl übersehen, das da nen 2Dim-Array ist. Bei einem 1Dim Char-Array sollte es so aber funktionieren.



  • KasF schrieb:

    Boris hat wohl übersehen, das da nen 2Dim-Array ist. Bei einem 1Dim Char-Array sollte es so aber funktionieren.

    Glaub' ich nicht ! 😉
    Hab's nämlich auch übersehen und mit einem 1D-Array getestet ... und die Fehlermeldung zeigt auch, dass der Compiler sich daran stört, dass es sich um ein Array handelt ... nicht daran, dass es ein char ist; ich wüsste also nicht, wo der Unterschied sein sollte, wenn man ein Array von char* statt eines von char nimmt.

    Gruß,

    Simon2.



  • class SomeClass
    {
        protected:
        const char *ConstantString[5];
    
        public:
        SomeClass() 
        {
            ConstantString[0] = "hallo";
            ConstantString[1] = "doof";
            // usw...
        }
    };
    

    😉



  • SomeClass(char *a,char *b,char *c,char *d,char *e) : ConstantString[0](a),
                                                             ConstantString[1](b),
                                                             ConstantString[2](c),
                                                             ConstantString[3](d),
                                                             ConstantString[4](e) {};
    

    würde das gehen?



  • (Kann sein das wir aneinander vorbeireden)

    Simon2 schrieb:

    ich wüsste also nicht, wo der Unterschied sein sollte, wenn man ein Array von char* statt eines von char nimmt.

    char* arr1[4]; // "ein Array von char*" ( 2 Dim-Array : char** )
    char  arr2[4]; // "ein Array von char"  ( 1 Dim-Array : char*  )
    

    Du meinst da ist kein Unterschied ?

    Und das würde nicht funktionieren ?

    class SomeClass{
    protected:
    // Sowohl der Zeiger als auch der Inhalt des char-Arrays sollen konstant
    // sein
    const char* ConstantString;
    public:
    // C'tors von Boris
    SomeClass() : ConstantString("Halo") {};
    SomeClass(const char *a) : ConstantString(a) {};
    };
    


  • KasF schrieb:

    Du meinst da ist kein Unterschied ?
    Und das würde nicht funktionieren ?

    Wie aus der Compilermeldung deutlich werden sollte, redet Simon vermutlich von Arrays, und nicht von Zeigern 😉

    class SomeClass{
    const char ConstantStringA[5]; // as opposed to
    const char* ConstantStringB[5];
    };
    


  • KasF schrieb:

    (Kann sein das wir aneinander vorbeireden)

    Simon2 schrieb:

    ich wüsste also nicht, wo der Unterschied sein sollte, wenn man ein Array von char* statt eines von char nimmt.

    char* arr1[4]; // "ein Array von char*" ( 2 Dim-Array : char** )
    char  arr2[4]; // "ein Array von char"  ( 1 Dim-Array : char*  )
    

    Du meinst da ist kein Unterschied ?...

    Du hast den Zusammenhang meiner Aussage nicht beachtet: Wenn der Compiler sagt "Das geht mit Arrays nicht !", dann spielt es für ihn keine Rolle, ob es sich dabei um char[], char*[], int[], myType[], .... handelt, sondern es wird für alle gleich "nicht klappen".

    KasF schrieb:

    ...
    Und das würde nicht funktionieren ?
    ...

    "Ob Du Recht hast oder nicht, sagt Dir gleich .... der Compiler !" 😉
    Wenn es nicht durch den Compiler geht, geht's nicht (was nicht bedeutet, dass es Std-konform ist, wenn es der Compiler schluckt .... ist ein reiner Falsifizierungstest) !
    (Ausnahmen mit schlechten Compilern oder sehr komplizierten template-Kisten mal ausgelassen - solch eher einfachen Standardkonstrukte wie hier kriegen vernünftige Compiler ganz gut hin)

    Gruß,

    Simon2.



  • Einfachste Lösung:

    class SomeClass{
    public:
      SomeClass( char const * (&s)[5] )
        : ConstantString(s, s+5)
      { }
    
    protected:
      std::vector<std::string> const ConstantString;
    };
    
    // oder auch:
    
    // SomeClass.cpp
    
    namespace {
    vector<string> make_SomeClass_strings( /* params */ )
    {
      vector<string> result;
      // fill result
      return result;
    }
    } // anon namespace 
    
    SomeClass::SomeClass()
      : ConstantString(make_SomeClass_strings())
    {
    
    }
    

    Btw, const-Zeiger auf const sieht so aus:

    char const * const foo;
    // bzw
    const char * const foo;
    


  • Jetzt ist alles ganz durcheinander. Ich belass das mal hier so und lese das heute Abend nochmal langsam 😃


Anmelden zum Antworten