konstante Elemente in Struktur



  • Hm ich würde auch mal darauf tippen das Du den Konstruktor schreiben musst.

    const T * const t;

    soll ja verhindern das an dem Zeiger irgendwas gedreht werden kann.
    Sobald das NICHT per initialisieren passiert ist doch der sinn von dem const T* const weg ?!?

    const MENUE_VAR_TYP foo[] =
    {
      {1, 2, 0, 0, 0, 0}
    };
    

    Hier muss ich passen. Das sieht mir eher danach aus als sollten 6 MENUE_VAR_TYP in ein Array (foo) gepackt werden und nicht 1 mit initialisierung der Werte !?

    [ Dieser Beitrag wurde am 20.03.2003 um 09:13 Uhr von Knuddlbaer editiert. ]



  • Der kram WIRD initialisiert ^^ wieso kennt diese Weise keiner.
    Probiert dochmal folgenden Quellcode aus und lernt 😃 :

    struct bla
    {
      int wert1;
      char* wert2;
      char wert3;
    };
    
    bla blaarray[]=
    {
      {1, "hallo", 23},
      {2, "Welt", 34},
      {3, "kennt ihr mich?",45}
    };
    
    int main(void)
    {
      for(int i = 0; i< (sizeof(blaarray)/sizeof(bla));i++)
      {
        cout << blaarray[i].wert1<<". ";
        cout << blaarray[i].wert2<<" ";
        cout << blaarray[i].wert3<<" \n";
      }
    }
    

    oder ein vieleicht praktischeres Beispiel:

    #include <iostream>
    #include <conio>
    
    using std::cout;
    struct menu
    {
      int x;
      int y;
      const char* wert;
    };
    
    menu usermenu[]=
    {
      {10, 3, "Userverwaltung"},
      {2, 5, "1. Useruebersicht"},
      {2, 6, "2. User anlegen"},
      {2, 7, "3. User loeschen"},
      {2, 8, "----------------"},
      {2, 10, "4. User befoerdern"},
      {2, 11, "4. User fuettern"},
      {2, 12, "5. User waschen"},
      {2, 13, "6. Attentaeter anfordern"},
    };
    
    int main(int argc, char* argv[])
    {
      for(int i = 0; i< (sizeof(usermenu)/sizeof(menu));i++)
      {
        gotoxy(usermenu[i].x,usermenu[i].y);
        cout << usermenu[i].wert<<" \n";
      }
      getch();
      return 0;
    }
    //---------------------------------------------------------------------------
    

    und genau das geht auch mit Konstanten normalerweise also

    const char* const wert2
    

    , wo Borland aber nicht mitspielt

    *edit* syntaxfehler 😕

    [ Dieser Beitrag wurde am 20.03.2003 um 11:18 Uhr von dreaddy editiert. ]



  • du verwendest aber nicht die initialisierungsliste!

    der compiler macht daraus:

    const void* const p;
    p=foo;

    das geht nicht
    du musst p nunmal beim erstellen initialisieren
    und das geht nur mit der initialisierungsliste



  • und wo ist der Unterschied zwischen

    const char* const test = "hallo";
    

    (funktioniert)

    und

    struct zwei_charp
      {
        const char* const bla1;
        const char* const bla2;
      };
    
      zwei_charp = test {"hallo", "welt"};
    

    (funktioniert beim GNUC und VC aber nicht beim BCB)

    [ Dieser Beitrag wurde am 20.03.2003 um 11:25 Uhr von dreaddy editiert. ]



  • Da merkt man doch wie wenig man sich auskennt 🤡

    const char* const test = "hallo"; <- Zuweisung keine Initialisierung ?



  • Mir ist diese Arrayartige Initalisierung von structs neu. Gibts die im C++ oder/und C Standard?



  • const char* const test = "hallo";

    Das ist eine *Initialisierung*. Die Zeile ist legal.

    struct zwei_charp
    {
    const char* const bla1;
    const char* const bla2;
    };

    zwei_charp = test {"hallo", "welt"};

    Das müsste wenn überhaupt:

    struct zwei_charp
      {
        const char* const bla1;
        const char* const bla2;
      };
    
      zwei_charp test = {"hallo", "welt"};
    

    heißen. Der Code ist allerdings nicht legal. Wie man im C++ Standard Abschnitt 8.5.9 nachlesen kann. Eine Klasse mit const-Membern benötigt einen benutzerdefinierten Konstruktor. Hat eine Klasse erstmal einen solchen, ist die Initialisierung über eine brace-enclosed-intializer-list nicht mehr erlaubt.

    Mir ist diese Arrayartige Initalisierung von structs neu. Gibts die im C++ oder/und C Standard?

    Ja. Zu C kompatibel sind die sogenannten Aggregates = Array oder Klasse ohne bnutzerdefinierte Ctoren, ohne private/protected nonstatic Members, ohne Basisklassen und ohne virtuelle Funktionen.
    Relevante Regelen findest du in 8.5.1 und 12.6

    [ Dieser Beitrag wurde am 20.03.2003 um 13:22 Uhr von HumeSikkins editiert. ]



  • hm, vor Jahren hatten wir das anders gelöst und als dann der neue Standard (bzw eine neue Compilerversion mit diesem) rauskam lief es nicht mehr.
    Und nach etwas Forschung in den neuen Standards sind wir dann zu so einer Lösung gekommen.

    So sagt es der Historiker zu meiner Linken zumindest.

    [ Dieser Beitrag wurde am 20.03.2003 um 13:49 Uhr von dreaddy editiert. ]



  • Original erstellt von HumeSikkins:
    *[quote] const char const test = "hallo";
    **

    **
    Das ist eine *Initialisierung*. Die Zeile ist legal.
    **[/QUOTE]

    Ah jetzt ja! 🤡

    Danke schön!



  • Ok, danke Hume für die Mühe jetz ist eindeutig 😃 Kann man die Dinger eigentlich auch irgendwo im www nachlesen?

    Und ich hab mir das jetzt nochmal genauer angeschaut und festgesetellt das das zweite const wegfallen kann, daher gehts auch wieder mit beiden Compilern.

    Oh und bitte meine obige Antwort vor Humes denken, war etwas spät mit auf Antworten drücken.


Log in to reply