struct Zuweisung ->mühsam!



  • tag leute,

    ich möchte einer bestehenden struct Variablen gleich alle Werte zuweisen.

    struct person {
          char name[20];
          char vorname[20];
          int alter;
    } p1, p2;
    

    bei der initialisiern / instanzierung(?) geht das:

    struct person p_noch_eine = { "Krause", "Anton", 44 };
    

    aber bei

    p1 = { "Krause", "Anton", 44 }; // Synatxfehler!
    

    hingegen

    struct person p_schon_wieder_eine = p_noch_eine;
    

    //geht

    stimmt das so?
    wenn ja, wird so eine struct zuweisung ja richtig mühsam wenn mehrere Felder hat, denn ich muss jedes mit struct.feld = .. ansprechen.

    habe eben einen struct mit structs drin.

    die einzige möglichkeit sehen ich noch darin bei programm start alle zuweisungsmöglichkeiten zu erstellen und dann bei laufzeit zuweisen:

    also

    person aktuellePerson;
    person p1, p2, p3,.... ;

    dann laufzeit:
    aktuellePerson = p1;
    später aktuellePerson = p2;

    g



  • Möchtest du C oder C++ programmieren?

    Je nach dem sieht die Lösung anders aus - aber iwie hab ich gerade den Verdacht, dass du in C programmieren möchtest oder aber in deinem (veralteten) Buch gerade mal 20 Seiten gelesen hast und jz keine Lust mehr hast?!

    bb



  • nö, nö sollt schon c++ sein.

    mit deiner bemerkung sprichst du wohl klassen an.

    habe da eine sammlung von gerätedaten die fix sind und keine schöne schnittstellen benötigen. auch vererbung, polymorphie ist kein thema.

    mein buch ist ein jahrgang 99 😉

    falls die erneute = {, , , } zuweisung nicht geht werd ichs wohl mit klassen und anständigen Settern / Gettern machen.

    g



  • Dir ist schon bekannt, dass es keinen Unterschied machst, ob du struct oder class verwendest? (ma vom default-access abgesehen)

    und für so ne initialisierung baut man einen konstruktor - kannst ja ma danach googlen oder in deinem buch gucken - allerdings scheint es mir so, als obs kein gutes wäre... ^^

    bb



  • danke für deine antwort

    keinen Unterschied machst, ob du struct oder class

    ist mir schon bekannt (public <-> private), aber auch bzgl Vererbung brauch ich nix. Geht ja mit struct nicht, oder irr ich mich?

    habs jetzt auch mal jetzt mit "richtigen" klassen umgesetzt:
    Bitte kommentiere meinen ansatz:

    alle Felder sind public-> kein Get() nötig, sondern Objekt.Feld direkt
    es hat ein Set(), ich kann alle Felder auf einmal schreiben 🙂
    -> du schlägst hier nen konstruktor vor.. ok, ich brauch aber nur ein Objekt, da reichts / ists einfacher mit setten.

    class CMotorDatenSatz
    {	
    public:
    	CMotorDatenSatz();
    	~CMotorDatenSatz();
    	int PrepareMotorDataSet( eMotorTypen Typ );
    
    	CMotorDaten MotorDaten;
    	CKompensation Kompensation;
    	CStromRegler StromRegler;
    	CNichtlineareKennlinie NichtLineareKennlinie;
    	CBegrenzungen Begrenzungen;
    	CGeberDaten GeberDaten;
    };
    

    und hier noch ein bsp für unterobjekt:

    class CStromRegler
    {
    public:
    	int Verstaerkung;
    	int Nachstellzeit;
    	// inline:
    	Set(int Verstaerkung_, int Nachstellzeit_)
    	{
    		Verstaerkung = Verstaerkung_;
    		Nachstellzeit = Nachstellzeit_;
    	}
    };
    


  • mathias_f schrieb:

    mein buch ist ein jahrgang 99 😉

    OMG... Noch heute sind viele "neue" C++ Bücher nicht "aktuell", aber 99, ein Jahr nach der Verabschiedung des C++ Standards? Dann greif lieber zu einem aktuellen Buch (Thinking in C++, C++ Primer...). Zumal sich in den letzten 10 Jahren auch vieles im Programmierstil geändert hat.



  • aber auch bzgl Vererbung brauch ich nix. Geht ja mit struct nicht, oder irr ich mich?

    Ja, Du irrst Dich.
    Simon



  • mathias_f schrieb:

    danke für deine antwort

    keinen Unterschied machst, ob du struct oder class

    ist mir schon bekannt (public <-> private), aber auch bzgl Vererbung brauch ich nix. Geht ja mit struct nicht, oder irr ich mich?

    Weist du jz warum ich geschrieben habe, dass sie komplett gleich sind - bis auf einen Unterschied?

    class CMotorDatenSatz
    {	
    public:
    	CMotorDatenSatz();
    	~CMotorDatenSatz();
    	int PrepareMotorDataSet( eMotorTypen Typ );
    
    	CMotorDaten MotorDaten;
    	CKompensation Kompensation;
    	CStromRegler StromRegler;
    	CNichtlineareKennlinie NichtLineareKennlinie;
    	CBegrenzungen Begrenzungen;
    	CGeberDaten GeberDaten;
    };
    

    sieht ganz iO aus - obwohl es so aussieht, als ob der destruktor nicht gebraucht wird...

    class CStromRegler
    {
    public:
    	int Verstaerkung;
    	int Nachstellzeit;
    	// inline:
    	Set(int Verstaerkung_, int Nachstellzeit_)
    	{
    		Verstaerkung = Verstaerkung_;
    		Nachstellzeit = Nachstellzeit_;
    	}
    };
    

    naja - ist hier sehr hinderlich, wenn man beides auf einmal ändern muss... außerdem fehlt nen void vor Set...

    Davon abgesehen ist es ein Sinn der Klassen, die Daten zu kapseln - und keine Änderungen von außen zuzulassen, weil man idR nicht einfach alles ändern kann/darf/... ohne das man bestimmte Abhängigkeiten beachten muss...
    Also ich würde variablen _immer_ als private machen und Getter und Setter anbieten - klar ist es mehr zu tippen, aber naja - von den paar Zeilen sterb ich au nich gleich - und iwann treten halt wirklich mal Abhängigkeiten auf - und dann alles zu ändern, wäre mir zu viel Arbeit...

    bb



  • ok, danke dann bin ich langsam aufm richtgen weg.

    was ich jetzt nicht ganz verstanden hab ist:

    sehr hinderlich, wenn man beides auf einmal ändern muss

    mit dem Setter ändere ich beides auf einmal, ja.
    meintest du wenn ich nur einen Wert ändern möchte?
    dann zugriff per .feld (nur public, nicht idee der klasse)
    oder noch ne methode SetFeld(val).
    glücklicherweise werden beim ändern des datensatzes 90% der werte in einem rutsch geschrieben, also lass ich das "sammel-setten".

    ok, zu den gettern hab ich mich noch überreden lassen und mach die members private.

    lg



  • hey,

    da structs und classes ja nunmal ähnliche Funktionalität vorweisen,
    könntest du auch einfach deine Struktur mit einem Konstruktor versehen:

    struct point // nur als Beispiel
    {
        int x;
        int y;
        point(int X, int Y) : x(X), y(Y) {}
    };
    

    dann kannst du bei Initialisierung immer noch:

    point p = { 10, 15 };
    

    und bei Zuweisung machst du halt einfach:

    p = point(10, 15);
    

    immer noch kürzer als alle Elemente einzeln anzusprechen.
    außerdem hast du keine Klasse mit public-Eigenschaften und wenn du nur einzelne Werte ändern möchtest, kann du die immer noch einzeln ansprechen.



  • DrakoXP schrieb:

    dann kannst du bei Initialisierung immer noch:

    point p = { 10, 15 };
    

    Nein, kannst du nicht mehr. Aber wenn du schon Konstruktoren hast, solltest du diese auch bei der Initialisierung einsetzen. Aggregats-Initialisierungslisten sind zu unsicher und zu wenig flexibel. Mit Konstruktoren kann man hingegen eine richtige Initialisierung erzwingen.

    point p(10, 15);
    

Log in to reply