Wie den Speicher verwalten?



  • OT: 😉 Urlaub war mal wieder nötig 😃 Nur am Wochende feiern ... wird langweilig 😉



  • // GetStringAbc liefert eine Kopie (std::string BY VALUE) zurück,
    // da muss nixe dynamisch angefordert werden
    std::string MyClass::GetStringAbc() { 
        return m_sAbc;
    }
    


  • (D)Evil schrieb:

    Was machst du da? Von welchem Typ ist m_sAbc? std::string?

    void MyClass::set_string_abc(const std::string& str)  // const da wir nur kopieren ... Referenz da wir sonnst eine Kopie zu viel haben ;)
    { m_sAbc = str; }
    
    std::string MyClass::get_string_abc() const // const da wir am Wert der Variable m_sAbc nichts ändern!
    {
        return m_sAbc; // Gibt eine KOPIE von m_sAbc zurück ... wenn du das nicht willst muss der return-Wert der Funktion eine Referenz oder ein Pointer sein!
    }
    

    hmm immer dieses vereinfachte erklären ^^

    C++ ist doch so einfach. Warum finden die Anfänger immer die komplizierten Wege?



  • tntnet schrieb:

    ...
    C++ ist doch so einfach. Warum finden die Anfänger immer die komplizierten Wege?

    Weil sie die falschen Ratgeber haben.

    ... z.B. weil ihnen eben keiner sagt, wie sie von ihrer bisherigen Vorgehensweise in anderen Programmiersprachen vernünftig zu C++ kommen (wo gibt's wirklich gute "C->C++"- oder "Java->C++"-Tutorials ? Wer nach sowas googlet landet man bei Milliarden "flame wars" und ihren Produkten)

    Gruß,

    Simon2.



  • tntnet schrieb:

    Warum finden die Anfänger immer die komplizierten Wege?

    Vermutlich weil sie vorher mit C und ähnlichem gearbeitet haben und die dort notwendigen Lösungen jetzt 1:1 auf C++ übertragen 😉



  • Erstmal vielen Dank für die Hilfe 🙂

    tntnet schrieb:

    C++ ist doch so einfach. Warum finden die Anfänger immer die komplizierten Wege?

    Das liegt auch daran das C++ als die Königsdisziplin im programmieren ist und man elegant und fehlerlos programmieren will. Da schießt man dann etwas über das Ziel hinaus...

    Eine Frage habe ich noch:

    // Ist dieses
    std::string MyClass::get_string_abc() const {
        return m_sAbc;
    }
    
    // Das gleiche wie dieses?
    const std::string MyClass::get_string_abc() {
        return m_sAbc;
    }
    
    // Der Kompiler sagt das keine relevanten Changes detected wurde...
    


  • Nein, das ist nicht das gleiche - die erste Version funktioniert für 'const MyClass' Objekte, die letzte nicht.



  • Aber bei dem Getter wird doch eine Objekt vom Typ MyClass gar nicht verändert. Wieso ist das const dann notwendig?

    std::string s = MyClassObj.get_string_abc()
    

    Hier wird doch wie Ihr sagt ein Kopie zurückgegeben.



  • Ja, der Getter verändert das Objekt nicht - aber bei Version 2 weiß der Compiler nichts davon. Und wenn du dein Objekt irgendwo als const-Referenz übergibst, wirst du den Unterschied bemerken:

    void print_status(const MyClass& obj)
    {
      ...
      cout<<obj.get_string_abc()<<endl;
      ...
    }
    

    Bei Variante 2 von oben wird sich hier der Compiler beschweren, daß der Methodenaufruf nicht zulässig ist.



  • Vielen Dank für die Erklärung 🙂



  • Hallo Forum,

    ich habe noch eine Frage. Das Prinzip funktioniert auch mit eigenen Datentypen? Wenn die Übergabe ByVal ist wird also immer eine Kopie des Objektes erstellt. (Ich habe so den Verdacht das bei String irgendwie der = Operator überladen ist.)

    Dieses würde also wie gewünscht funktionieren?

    // Ein beliebige Datenklasse:
    class MyData {
    public:
    	SetAbc(const std::string &s) {
    		m_sAbc = s;
    	}
    private:
    	std::string m_sAbc;
    }
    
    // Hauptklasse wo andere Datenklassen verwaltet werden:
    class MyClass {
    public:
    	SetHead(const MyData &oData) {
    		m_oData = oHead; // Werden hier die Daten von oHead nach m_oData kopiert?
    	}
    	MyData GetHead() const {
    		return m_oData; // Hier wird eine Kopie (ByVal) zurückgegeben?
    	}
    private:
    	MyData m_oData;
    }
    


  • Ja, das Prinzip funktioniert generell. Dein Compiler ist so freundlich, die wichtigen Methoden (Copy-Constructor und Zuweisung) für dich anzulegen, wenn du keine eigenen definierst - und damit kannst du deine Objekte problemlos übergeben.

    (Problematisch wird es erst, wenn das "Standardverhalten" der Methoden nicht das macht, was du von ihnen erwartest - dann mußt du sie selber schreiben)



  • Ok Danke 🙂


Anmelden zum Antworten