Hallo,

Sie hatten in einen anderen Thread von einer var Klasse gesprochen um eine Automatische Konvertierung von var zu int usw. vorzunehmen.
Ich bräuchte dies dringend für mein eigenes Projekt, daher werde ich das einfach mal selber probieren. Leider kenne ich mich in Operator Overloading (und C++ im Generellen) nicht perfekt aus. Meinten Sie die Klasse (im absoluten Grobaufbau) so:

Code:

---

class var {
private:
	long value;
public:
	var::var(int a) { value=_VAR(a); }
	var::var(float a) { value=_VAR(a); }
	var::var(double a) { value=_VAR(a); }
	var::var(long a) { value=a; }
	var::var() { value=0; }
	var operator+(long);
	var operator+(int);
	var operator+(double);
	var operator+=(long);
	var operator+=(int);
	var operator+=(double);
	var operator-(long);
	var operator-(int);
	var operator-(double);
	var operator-=(long);
	var operator-=(int);
	var operator-=(double);
	var operator>>(int);
	var operator=(int);
	var operator=(long);
	var operator=(double);
	long operator=(var);
	operator long(); 
	operator int(); 
	operator double(); 
	inline long getvalue() { return(value); }
};


var var::operator+(long summand)
{
	this->value = this->value+((long)summand);
    return *this;
}

var var::operator+(int summand)
{
	this->value += _VAR(summand);
    return *this;
}

//...

---

Code wie:

var a = 2;
a += 1;
a += 0.12;
a >>= 2;

Funktioniert so tadellos, auch unter C++. Zusätzlich könnte man über einen Konstruktur die Variable bei keiner Initalisierung auf 0 setzten (und so gewissermaßen #pragma_zero von C-Lite simulieren). Ich bin mir aber nicht ganz sicher, ob das oben die intelligenteste Lösung ist. Meinten Sie ihre Aussage zu einer var Klasse überhaupt so?

Gibt ne Menge warnungen ("'ang' hat C-Bindung angegeben, aber gibt UDT 'var' zurück, was mit C inkompatibel ist"), aber hierfür müsste man einfach nur überall var mit long ersetzten. Die Frage ist eigentlich nur, wie schnell so eine Klasse wie die da oben ist. Ich kenn mich hier in C++ nicht aus, aber wirken sich die vielen definierten Operator zuweisungen auf die Geschwindigkeit des Codes aus?

Sorry für die vielen Fragen hier (und nicht im Higher Languages), aber ich glaube nicht, dass diese hier jemand beantworten kann (bzw. die es können lesen den Post nicht ).

mfg
Timo

PS: Wenn ich das oben richtig gemacht habe, dann kann ich ihnen am Ende die Klasse gerne zu Verfügung stellen.

Ihr obiger Ansatz ist völlig korrekt und die Klasse ist auch ausreichend schnell. Zum Multiplizieren und Dividieren von var können Sie Assemblerfunktionen verwenden:

fixed fixmul(fixed r1,fixed r2)
{
__asm {
mov eax,r1
mov edx,r2
imul edx
shrd eax,edx,10
adc eax,0
}
}

fixed fixdiv(fixed dividend, fixed divisor)
{
__asm {
mov eax,dividend
mov ecx,divisor
mov edx,eax
sar edx,22
shl eax,10
idiv ecx
}
}

Leider ist dies noch nicht die ganze Lösung, denn z.B. die Engine-Funktionen sind ja im C-Stil definiert und kennen diese Klasse nicht. Hier muss man noch etwas tricksen, damit die var Klasse sauber funktioniert und es keine Compilerwarnings gibt. Das hatte ich mir für eine der nächsten Überarbeitungen der SDKs vorgenommen.

Danke für die Funktionen, werde ich nutzen. Sollte es bei den Engine Funktionen nicht reichen, jedes "var" durch ein "long" zu ersetzten?

Das schaltet mögliche Compilerwarnungen aus.

Ein weiteres kleines Problem. Ich kann immer nur ein Rückgabetyp definieren. Beispiel:

//error message!
long operator=(var);
float operator=(var);

(Funktionen unterscheiden sich nur durch Rückgabetyp o.ä.)

Oder kann hier C++ selbstständig von long zu float usw. konvertieren (so das dann sowohl long a = var; und float a = var; funtkioniert?)?.

Edit: Bei dem ASM Code hackt es bei mir ehrlich gesagt.

Code:

---

long r1;
long r2;
var var::operator*(int i1)
{
	r1 = this->value;
	r2 = (long)_VAR(i1);
	__asm {
	mov eax,r1
	mov edx,r2
	imul edx
	shrd eax,edx,10
	adc eax,0
	}
    return *this;
}

---

Ist das 1) nicht eher langsamer als die direkte multiplizierung? Und 2) Es verändert sich nichts an der Variable. Mache ich an der Einbindung was falsch?

sie machen etwas falsch. eax enthält bei funktionsaufrufen den rückgabewert für 32-bit werte (bei __stdcall und __cdecl afaik). das heißt, sie können sich das letzte return sparen... und natürlich müssen sie vorher den wert sichern, z.b. mit

...
mov r1, eax
}

this->value = r1;

dann wäre aber wieder das problem, dass nicht mehr gesichert ist, dass eax noch r1 enthält.

Code:

---

long var::operator*(double d1)
{
	long r2 = this->value;
	long r1 = _VAR2(d1);
	__asm {
	mov eax,r1
	mov edx,r2
	imul edx
	shrd eax,edx,10
	adc eax,0
	mov r1, eax
	}
    return r1;
}

---

So klappt es jetzt theoretisch.. natürlich nicht sehr schnell, denke ich mal oder?

schneller, wie wenn du eine fixed-point-multiplikation in c schreiben würdest. natürlich kann der compiler viel optimieren, aber manchmal ist man von hand einfach schneller... du könntest die ersten beiden operationen auch in assembler schreiben. und lass' das mit mov r1, eax... return r1 weg.

Weißt du zufällig ob es einen "Default" Konvertierbefehl gibt? Bsp: die var klasse soll zu MATERIAL* "konvertiert" werden. Klappt natürlich nicht ==> Fehler des Compilers. Kann ich ihn hier anweisen, dass wenn er nicht weiß was zu machen ist, einfach erstmal die Variable zu long zu konvertieren?

Noch eine Sache. Bei der Konvertierung die ich habe komme ich bei folgendem Code zu problemen:

Code:

---

if(material_model_skintargetnormal + 1 > material_model_skins)
...

---

Als erstes wird hier material_model_skintargetnormal zu (long) "konvertiert" (also eigentlich nur der Klassenwert zurückgeliefert). Jetzt weißt er nicht zu was er material_model_skins "konvertieren" soll, da ich nur regeln festgelegt habe wenn var links steht und long/int/double usw. rechts. Mit einem (long) nach dem > Zeichen löst sich das Problem natürlich, aber ist das notwendig?

Edit: Hier sehe ich auch gleich den ersten Fehler dann. Ich muss material_model_skins zu (int) konvertieren, weil links ja auch int steht (die 1 ist int und nicht long).

Mit dem Rückgabetyp....

Kannst du nicht einfach den = Operator überladen für die verschiedenen Rückgavetypen? Oder hab ich dich da jetzt falsch verstanden?

Naja ich weiß nicht was du meinst.
Eigentlich ist das Problem ja recht einfach:

var a = 2;
var b = 2;
a = b+2;

Klappt ohne probleme (a+b wird zu long konvertiert + 2).

var a = 2;
var b = 2;
a = 2+b;

Klappt nicht (a = 2+(long)b;) ist nötig (Der compiler weiß nicht zu was er "var" konvertieren soll / also ob zu double/int/long usw.).
Kann man dieses nötige doppelcasting irgendwie verhindern?

Momentane "+" Überladungen:
Code:

---

long var::operator+(var r1) { return(value+r1.getvalue()); }
long var::operator+(long r1) { return(value+r1); }
long var::operator+(int r1) { return(value+_VAR2(r1)); }
long var::operator+(float r1) { return(value+_VAR2(r1)); }
long var::operator+(double r1) { return(value+_VAR2(r1)); }

---

mfg,
Timo