Überladen von Operatoren :(



  • Ich kann mir schon vorstellen das es zu diesem Thema bestimmt schon viele Threads gibt, aber ich um ehrlich zu seien unter Zeitdruck stehe und mir nicht die Mühe gemacht habe zu suchen.
    Es geht um folgendes Ich habe mir zum lernen ein kleines Programm geschrieben und wollte nun 2 Objekte miteinander addieren, habe im Script dazu alles durchgelesen nur komme ich nicht so ganz mit der Syntax klar. Oder besser gesagt... wann ich zum Beispiel mit "const" arbeite usw und was ich returnen muss 😞

    Hier mein Beispiel :

    .cpp :

    /*
     * CCar.cpp
     *
     *  Created on: 20.07.2016
     *      Author: David
     */
    
    #include "CCar.h"
    
    #include <iostream>
    
    using namespace std;
    
    CCar::CCar(string name, int reifen, int achsen)
    {
    	cout << "Konstruktoraufruf von dem Auto." << endl << "Erstelle Objekt auf Adresse: " << this << endl;
    	this->set(name, reifen, achsen); //Verwendung des this Pointers ist optional
    
    }
    
    void CCar::set(string name, int reifen, int achsen)
    {
    	m_name=name;
    	m_reifen=reifen;
    	m_achsen=achsen;
    }
    
    string CCar::getName()
    {
    	return m_name;
    }
    
    int CCar::getReifen()
    {
    	return m_reifen;
    }
    
    int CCar::getAchsen()
    {
    	return m_achsen;
    }
    
    CCar::CCar(CCar& origin)
    {
    	cout << "Copy Konstruktor wird aufgerufen" << endl;
    
    	m_name = origin.m_name;
    	m_reifen = origin.m_reifen;
    	m_achsen=origin.m_achsen;
    }
    
    void CCar::print()
    {
    	cout << "Automarke: " << m_name <<  endl << "Anzahl der Reifen: " << m_reifen << endl << "Anzahl der Achsen: " << m_achsen << endl;
    }
    
    CCar CCar::operator +(const CCar& lop,const CCar& rop)
    {
    	CCar ret;
    	ret.m_achsen = lop.m_achsen + rop.m_achsen;
    	ret.m_name = lop.m_name + rop.m_name;
    	ret.m_reifen = lop.m_reifen + rop.m_reifen;
    
    	return ret;
    }
    

    .h:

    /*
     * CCar.h
     *
     *  Created on: 20.07.2016
     *      Author: David
     */
    
    #ifndef CCAR_H_
    #define CCAR_H_
    
    #include <string>
    
    using namespace std;
    
    class CCar
    {
    private:
    	string m_name;
    	int m_reifen;
    	int m_achsen;
    public:
    
    	CCar operator+ (const CCar& lop,const CCar& rop);
    
    	CCar(CCar& origin);
    	string getName();
    	int getReifen();
    	int getAchsen();
    	//Zuweisen der internen Daten
        void set(string name,int reifen,int achsen);
    
        //Konstruktor (Erzeuger)
        CCar(string name="NoName",int reifen=0,int achsen=0);
    
        //Ausgabe
        void print();
    };
    
    #endif /* CCAR_H_ */
    

    main.cpp:

    int main (void)
    {
    
    CCar wp5("Porsche",4,4);
    CCar wp6("Honda CRX",2,2);
    CCar wp7;
    
    wp7 = wp5 + wp6;
    
    	return 0;
    }
    

    Das mit dem linken und rechten Operand habe ich verstanden nur weiß ich nicht... wann ich zum Beispiel "const" Parameter übergebe und wann ich zum Beispiel ein *this zurückgebe ( im Skript gesehen ).

    Vielen Dank im Voraus



  • Das kann doch nicht einmal kompilieren, dat.
    Der Member operator+ ist unär, solange du ihn innerhalb der Klasse definierst.

    *this gibst du zurück wenn eine Methode der jeweiligen Klasse als Rückgabewert Class& erwartet. Also eine Referenz auf den Typ der Klasse. Google doch mal nach "user-defined copy assignement operator" oder so. Da müsstest du ein Beispiel finden.



  • Ich hab schon Zeit zum Suchen, ich mach es aber nicht.

    Und Autos addiere ich auch nicht.



  • CCar operator+ ( const CCar& rop);
    
    CCar CCar::operator +(const CCar& rop)
    {
    	CCar ret;
    	ret.m_achsen += rop.m_achsen;
    	ret.m_name += rop.m_name;
    	ret.m_reifen += rop.m_reifen;
    
    	return ret;
    }
    

    So kompiliert er aber es kommt nichts gescheites dabei raus 😞



  • buu2188 schrieb:

    So kompiliert er aber es kommt nichts gescheites dabei raus 😞

    Ja was erwartest du dir denn...
    Du addierst nen Porsche und nen Mercedes, hast schlussendlich nen PorscheMercedes.

    <joke>
    Mach sowas draus:

    m_name = m_name.substr(0, m_name.size()/2) + rhs.m_name.substr(rhs.m_name.size()/2);
    

    Dann haste am Ende nen Poredes. 😃
    </joke>



  • Es ist doch nur zu Übungszwecken ... Mir ist es im Endeffekt egal ob da ein MercedesPorscheBeetle heraus kommt, hauptsache es funktioniert zu Übungszwecken.

    Er soll einfach die strings addieren und die beiden int.



  • ganz einfach: in der klassen den operator += überladen, und dann den operator+ so definieren:

    class Auto { 
    //...
      friend Auto operator+ (Auto a, Auto const& b) {
        a += b;
        return a;
      }
    };
    


  • Danke für die Antwort 🙂
    Nun mal etwas anderes habe hier 2 Methoden warum muss die eine friend
    sein und die andere nicht? Sie greifen doch beide auf private Attribute zu oder?

    .h:

    CComplex operator+(CComplex const& rop);
    
    	//Beispiel: Linker operand ist vom Typ float
    	friend CComplex operator+(float lop, CComplex const& rop);
    

    .cpp:

    CComplex CComplex::operator+(CComplex const& rop)
    {
    	CComplex result(0,0);
    
    	result.m_real = this->m_real + rop.m_real;
    	result.m_imaginary = this->m_imaginary + rop.m_imaginary;
    
    	return result;
    }
    
    CComplex operator+(float lop, CComplex const& rop)
    {
    	CComplex result(0,0);
    
    	result.m_real = lop + rop.m_real;
    	result.m_imaginary = rop.m_imaginary;
    
    	return result;
    }
    

    Mfg



  • Muss nicht.



  • bub schrieb:

    Muss nicht.

    Weil ich bekomme einen Kompilerfehler wenn ich einfach mal das friend weg lasse und er sagt die Attribute sind privat aber warum?



  • Weil die Member der Klasse halt privat sind. Deswegen friend.
    Google is your friend.

    Du hast drei Möglichkeiten einen Operator für die Klasse zu definieren, entweder ein binäres operator+ außerhalb der Klasse oder ein unäres operator+ als Member der Klasse. Neulich - seit C++11 - kannst du auch den friend specifier benutzen um den Zugriff von privaten Membern der Klasse innerhalb einer globalen Funktion zu gewährleisten. Beachte, dass, wenn du den operator+ außerhalb der Klasse definierst (ganz ohne friend specifier), du auf den privaten Zugriff verzichtest.

    Aber weißt du schon, was dir am meisten fehlt?
    Ein gutes Grundlagenbuch.


Anmelden zum Antworten