proggen.org

#include <iostream>

class Test {
    public:
        std::string& operator[](std::string const & key) {
            // irgendwas
            std::string* s = new std::string(key);
            return *s;
        }
};

int main() {
    Test const t;
    std::string value = t["Hallo Welt"];
    std::cout << value << std::endl;
}

Fehler: Die Übergabe von »const Test« als »this«-Argument von »std::string& Test::operator[](const string&)« streicht Qualifizierer [-fpermissive]

std::string value = t["Hallo Welt"];

T_return& X::operator[](T_index const& index);

const T_return& X::operator[](T_index const& index) const;

Glocke hat geschrieben:Hi, folgendes Beispiel:

Code: Alles auswählen

#include <iostream>

class Test {
    public:
        std::string& operator[](std::string const & key) {
            // irgendwas
            std::string* s = new std::string(key);
            return *s;
        }
};

#include <iostream>

class Test {
    public:
        std::string& operator[](std::string const & key) {
            // irgendwas
            return std::string( value );
        }
};

Glocke hat geschrieben: Leider kann ich mit der Compiler-Meldung

Fehler: Die Übergabe von »const Test« als »this«-Argument von »std::string& Test::operator[](const string&)« streicht Qualifizierer [-fpermissive]

nicht umgehen. Btw zeigt sie genau auf die Zeile

Code: Alles auswählen

std::string value = t["Hallo Welt"];

Kann mir jemand sagen was ich falsch mache? t soll zwingend Test const sein.

/EDIT: Muss ich dann neben

Code: Alles auswählen

T_return& X::operator[](T_index const& index);

auch noch

Code: Alles auswählen

const T_return& X::operator[](T_index const& index) const;

implementieren, da mein Container (also mein t) konstant ist?

Xin hat geschrieben:Seeekunde... wenn Du ein neues Objekt anlegst, dann kostet das - egal ob Du es auf dem Stack oder im Freispeicher anlegst.
Ein Objekt, das Du mit new anlegst, musst Du auch wieder entsorgen! Also bleib mal beim Stack.

Code: Alles auswählen

#include <iostream>

class Test {
    public:
        std::string& operator[](std::string const & key) {
            // irgendwas
            return std::string( value );
        }
};

Fehler: ungültige Initialisierung einer nicht-konstanten Referenz des Typs »std::string& {aka std::basic_string<char>&}« von R-Wert des Typs »std::string {aka std::basic_string<char>}«

Xin hat geschrieben:Du kannst auch ausschließlich nur die Const-Variante implementieren. Dann darfst Du aber halt keine (nicht-const) Referenzen in das Objekt zurückgeben. Da Du in dem Fall hier aber sowieso eine Kopie anlegst, passt das.

Glocke hat geschrieben:Okay, danke Bleibt nur noch das Problem von oben

        std::string /* & */ operator[](std::string const & key) {