3. operator

operator

  • R

    Code:

    #include <iostream.h>
    #include <string.h>

    class Strig
    {
    public:
    // Konstruktoren

    Strig(const char * const);

    ~Strig();

    Strig& operator=(const Strig& rhs);

    // Allgemeine Zugriffsfunktionen
    unsigned short GetLen()const { return itsLen; }
    const char * GetStrig() const { return itsStrig; }

    private:

    char * itsStrig;
    unsigned short itsLen;
    };

    // Konvertiert ein Zeichenarray in einen String
    Strig::Strig(const char* const cStrig)
    {
    itsLen = strlen(cStrig);
    itsStrig = new char[itsLen+1];
    for (unsigned short i = 0; i<itsLen; i++)
    itsStrig[i] = cStrig[i];
    itsStrig[itsLen]='\0';
    }

    // Destruktor, gibt zugewiesenen Speicher frei
    Strig::~Strig ()
    {
    delete [] itsStrig;
    itsLen = 0;
    }

    Strig& Strig::operator=(const Strig & rhs)
    {
    if (this == &rhs)
    return *this;
    delete [] itsStrig;
    itsLen=rhs.GetLen();
    itsStrig = new char[itsLen+1];
    for (unsigned short i = 0; i<itsLen;i++)
    itsStrig[i] = rhs.itsStrig[i];
    itsStrig[itsLen] = '\0';
    return *this;
    }

    int main()
    {
    Strig s1("Erster Test");
    cout << "S1:\t" << s1.GetStrig() << endl;

    char * tempTwo =" schoen hier zu sein!";
    s1 = tempTwo;
    cout << "tempTwo:\t" << tempTwo << endl;
    cout << "S1:\t" << s1.GetStrig() << endl;

    return 0;

    }

    Wer kennt eine ausführliche Antwort auf meine Frage?
    Warum muß ich bei der Operator Deklaration und Definition const verwenden?
    Wen ich const weglasse bekomme ich vom Compiler folgende Fehlermeldung:
    error c2679:Binaerer Operator '=':Kein Operator definiert, der einen rechtsseitigen
    Operator vom Typ 'char *' akzeptiert (oder keine geeignete
    konfertierung möglich)

    0
  • B

    temptwo ist vom Typ char*, der Zuweisungsoperator benötigt jedoch eine const-Referenz auf Strig. Nun gibt mit dem Konstruktor Strig(const char*) eine Umwandlungsmöglichkeit von char* nach Strig. Der Aufruf des Zuweisungsoperator sieht jetzt intern im Detail so aus:

    1. Es wird ein temporäres Objekt vom Typ Strig mithilfe des genannten Konstruktors angelegt.
    2. die Referenz (das Argument des Zuweisungsoperators) wird an dieses Objekt gebunden
    3. die operator= Funktion wird aufgerufen

    Es gibt in C++ eine Regel, die besagt, dass temporäre Objekte nur an const-Referenzen gebunden werden können. Ist also das Argument des Zuweisungsoperators keine const-Referenz, dann funktioniert Schritt 2 nicht.

    0
  • R

    Vielen dank für die ausführliche Beschreibung.
    Jetzt habe ich es getscheckt.

    0
  • ?

    das sollte bestimmt String heißen oder?

    0
Anmelden zum Antworten