Operatoren auf typen zugeschnitten überladen

[Shade Of Mine]

Terranigma schrieb:

ich möchte die Operatoren jedoch nicht als globale Funktion implementieren sondern innerhalb der klasse. und das ist ja nun auch genau mein problem.

Exakt, das ist dein Problem.
Warum willst du das?

ist das innerhalb der klasse realisierbar, ja oder nein? wenn ja wäre ich über eine kleines implementierungsbeispiel von euch sehr dankbar.

Es ist möglich aber nicht sinnvoll.

[Terranigma]

Hallo ihr!

Das ganze soll innerhalb einer klasse gekapselt sein, da die klasse als dll breitgestellt werden soll.

wenn es möglich ist, könntet ihr mir doch bitte kurz ein kleines beipspiel posten.

Danke euch!

viele grüße, der erik

[r2d(-2)]

Terranigma schrieb:

Das ganze soll innerhalb einer klasse gekapselt sein, da die klasse als dll breitgestellt werden soll.

Und warum nicht die Funktion in der DLL bereitstellen?

Alles in Klassen packen ist eine üble Angelegenheit, die man hauptsächlich von Java-Programmierern kennt. Programmiere C++ so, wie es sinnvoll ist, sonst wird es sich früher oder später rächen.

[Terranigma]

Huhu!

Ok, ich will mich ja jetzt nicht beschweren und auch keine unnötige diskussion über die zweckmäßigkeit der implementierung inner- oder ausserhalb der klasse lostreten. ich hätte nur gerne ein kleines beispiel wie die implementierung aussieht, da ich selbst nirgends eine lösung finde. deshalb hoffe ich darauf noch eine antwort zu bekommen ohne ein für und wieder abzuwägen.

Danke:) grüße, der erik

P.S.: ich komme nicht aus dem java lager, und auch nicht von c# ich hab schon immer c++ verwendet und fühl mich damit auch wohl

[r2d(-2)]

Hauptsache nichts denken oder?

Und selbst suchen ist ja auch eine richtige Herausforderung. Erster Link:
http://lmgtfy.com/?q=c%2B%2B+operator+overloading

[Terranigma]

Hmm ich hab das gefühl, dass ich etwas missverstanden werde, und mich wohl etwas ungewählt ausgedrückt habe.

Ok, anders ausgedrückt:

Ich will nicht nur, dass die operatoren auf den rechten operanden spezialisiert überladen werden, sondern auch auf den linken.

es ist ja extern kein problem, z.b.

T operator+(dvec<idcst>& left,dvec<idcst>& right)
{
   // implentierung
}
T operator+(dvec<bdst>& left,dvec<bdst>& right)
{
   // implentierung
}

zu implementieren.

aber ich stoße an das problem, dass ich zb. die nachfolgenden beiden operatoren ja auch problemlos noch als externe funktion definieren kann, jedoch so nicht innerhalb der klasse

T operator+(dvec<idcst>& left,dvec<bdst>& right)
{
   // implentierung
}
T operator+(dvec<bdst>& left,dvec<idcst>& right)
{
   // implentierung
}

aber wie kann ich die ALLE in der klasse implementieren?
wenn ich die operatoren in der klasse implementiere, fehlt ja die typangabe des linken operators, und der compiler weis nicht welche funktion er nehmen soll zum addieren.

aka: wie kann den compiler mitteilen, dass er anhand des templateparameters die richtige funktion wählt?

struct idcst 
{ 
	int a,b; 
	double d; 
	char* st; 
}; 

struct bdst 
{ 
	bool on; 
	double val;
};

template <class T> class dvec
{
private:
	T* objekt;
protected:
public:
	dvec()
	{
		objekt = new T[10];
	}
	dvec& operator+(dvec<idcst>& right) // add1 , idcst+idcst
	{
		dvec<idcst> tmp;
		tmp.objekt->d = this->objekt->d + right.objekt->d;
		return tmp;
	}
	dvec& operator+(dvec<idcst>& right) // add2 , bdst+idcst
	{
		dvec<bdst> tmp;
		tmp.objekt->val = this->objekt->val + right.objekt->d;
		return tmp;
	}
	dvec& operator+(dvec<bdst>& rh) // add3 , idcst+bdst
	{
		dvec<idcst> tmp;
		tmp.objekt->d = this->objekt->d + rh.objekt->val; 
		return tmp;
	}
	dvec& operator+(dvec<bdst>& rh) // add4 , bdst+bdst
	{
		dvec<bdst> tmp;
		tmp.objekt->val = this->objekt->val + rh.objekt->val; 
		return tmp;
	}
};

add1 & add2 bzw. add3 und add4 sind hier von der parameterliste ja gleich, addieren aber unterschiedliche typen aufeinander. und dies möchte ich implementieren! ohne unterscheidung des templateparameters geht dies aber nicht, da die funktionen so ja für den compiler versucht werden neu zu definieren.

Wie kann ich dies implementieren, dass der compiler anhand des templateparameters z.b. korrekt zwischen add3 und add4 wählt?

Gruß, erik

[r2d(-2)]

Grundsätzlich finde ich es eine sehr schlechte Idee, die Addition nicht kommutativ zu machen. Oder welchen Typ willst du zurückgeben, wenn der linke Operand ein T und der rechte ein U ist? Du musst dich für einen entscheiden, wodurch a+b und b+a etwas ganz Anderes zurückgeben.

Nimm lieber benannte Funktionen, statt unintuitive Operatorüberladung zu erzwingen.

[Shade Of Mine]

Nimm die Funktion.
Es gibt keinen Grund warum du es in die Klasse packen wollen wuerdest. Du hast damit nur die Probleme die du schon bemerkt hast. Das lohnt sich nicht darum herum zu arbeiten. Das ist einfach dumm.

Ich denke du siehst in der freien Funktionen einen Nachteil den es nicht gibt. Du kannst es genausowenig in eine DLL packen wie wenn du es in die Klasse steckst. Klappt so oder so nicht.

Die Loesung waere konvertierungs Konstruktoren fuer die beiden Typen in deine Template Klasse zu packen. So dass bei
idcst + dvec<idcst>
der linke Operand zu einem dvec<idcst> mit einem Element wird und du den operator+(dvec,dvec) verwenden kannst

Ist aber baeh, deshalb: Freie Funktion.

Das ist wirklich die richtige Anwtort und nicht nur gesagt weils Cool ist. Sondern weil es wirklich die richtige Loesung fuer dein Problem ist. Alles andere ist pfusch.

[Terranigma]

hmm konvertierungs konstruktoren sind wirklich ne gerade schön.

Schade dass das nicht auch einfacher geht.

Aber hast recht, dass template in eine dll zu packen funktioniert natürlich nicht. ich wollte die klasse innerhalb einer dll verwenden. dies funktioniert aber mit den funktionen oder?

Gruß, erik

[hustbaer]

Wenn alle Typen bekannt sind, die als Template-Parameter in Frage kommen, kann man das wunderbar in eine DLL packen. Mit oder ohne "in der Klasse". -> explizit instanzieren

Man kann auch die Implementierung ganz normal im Header-File machen, wie bei Templates üblich, und das Template nur für die die am häufigsten verwendeten Typen in der DLL instanzieren (und diese Instanzen dann exportieren).

Zumindest mit MSVC geht das.
Wie es geht kann man sich u.a. in der Standard-Library vom MSVC angucken. std::basic_string<char>, std::basic_string<wchar_t> und einige häufig verwendete Container-Varianten sind z.B. in der Runtime DLL instanziert.