Implicit Cast und Operatoren

[Zacherl]

Hallo zusammen,

ich habe einen Record, bei welchem ich einen

Delphi-Quellcode:

class operator Implicit(A: TMyRecord): Integer

implementiert habe. Nachdem

Delphi-Quellcode:

IntVariable := MyRecord

nun auch wie erwartet funktioniert hat, probierte ich es mit

Delphi-Quellcode:

IntVariable := MyRecord * 4

. Von C++ her kenne ich es so, dass der Operator Multiply als nicht implementiert erkannt wird und dann aber auf den impliziten Cast zurückgefallen wird.

:?: Gibt es eine Möglichkeit dieses Verhalten auch in Delphi zu aktivieren?

Hintergrund ist, dass ich eine generische Wrapper Klasse für diverse Datentypen (Integer, Boolean, Floats) geschrieben habe. Die Momentane Implementierung besteht allerdings trotz identischem Basiscode aus 3 verschiedenen Records. Integer muss class operator Add, Subtract, Multiply, etc unterstützen, Boolean dahingegen braucht LogicalNot, LogicalAnd, etc. und die Floats noch Sachen wie Trunc oder Round.

Würde der implizite Cast funktionieren, wie ich mir das vorstelle, bräuchte ich keinen einzigen class Operator implementieren und käme mit nur einem Record aus.

Viele Grüße
Zacherl

[himitsu]

Beim Zuweisen weiß der Compiler, was für ein Typ nötig ist (Anhand des Ziels) und kann demnach einen passenden Cast suchen.

Bei einer Operation ist das nicht möglich, denn dabei sind nur die beiden Operatoren bekannt und noch nicht das Ziel.
Im Grunde ist noch nichtmal der Typ deiner untypisierten Konstante bekannt. (4 kann ja ein Byte, Word, Integer, Single oder sonstwas sein)
Man kann also

Delphi-Quellcode:

1 * 4

oder

Delphi-Quellcode:

1.0 * 4

rechnen und wenn ein Cast nach String existiert, könnte man auch auf die saublöde idee kommen und

Delphi-Quellcode:

'1' * 4

rechnen wollen.

Die Lösung ist also eine Operator für die gewünschten Operationen.

Delphi-Quellcode:

class operator Multiply(A: TMyRecord; B: Integer): TMyRecord;

Da der Compiler nicht einfach so die Operanten umdrehen kann/darf, müsste man auch noch das implementieren.

Delphi-Quellcode:

class operator Multiply(B: Integer; A: TMyRecord): TMyRecord;

Ja,

Delphi-Quellcode:

1 + 2 = 3

und

Delphi-Quellcode:

2 + 1 = 3

, aber

Delphi-Quellcode:

'1' + '2' = '12'

und

Delphi-Quellcode:

'2' + '1' = '21'

.

Wenn du aber einen impliziten Cast von Integer nach TMyRecord hast, dann würde auch Folgendes reichen.

Delphi-Quellcode:

class operator Multiply(A, B: TMyRecord): TMyRecord;

Hier würde der Integer umgewandelt, dann zusammengerechnet und anschließend wieder nach Integer gecastet, da das Ziel ja ein Integer ist. :stupid:

[Zacherl]

Zitat:

Zitat von himitsu (Beitrag 1295126)

Beim Zuweisen weiß der Compiler, was für ein Typ nötig ist (Anhand des Ziels) und kann demnach einen passenden Cast suchen.

Bei einer Operation ist das nicht möglich, denn dabei sind nur die beiden Operatoren bekannt und noch nicht das Ziel.

Ja, da ist der Delphi Compiler wohl leider ziemlich dumm :? MSVC parst sich den Typ des Ziels aus dem Code heraus. Funktionierendes Beispiel am Ende des Beitrags.

Zitat:

Zitat von himitsu (Beitrag 1295126)

Die Lösung ist also eine Operator für die gewünschten Operationen.

Genau, so funktioniert es momentan, aber hierdurch habe ich 3-fach redundanten und unschönen Code (da ich Records ja auch nicht vererben kann).

Zitat:

Zitat von himitsu (Beitrag 1295126)

Wenn du aber einen impliziten Cast von Integer nach TMyRecord hast, dann würde auch Folgendes reichen.

Delphi-Quellcode:

class operator Multiply(A, B: TMyRecord): TMyRecord;

Leider nicht möglich bei meinem Anwendungsszenario, da Delphi keine Referenzen / Pointer bei den class operators unterstüzt :evil: Darf leider meinen Wert nicht in einer temporären RValue ablegen. Würde eventuell gehen, wenn ich intern auf Pointer umstellen würde, aber dann müsste ich den Record vor Verwendung noch initialisieren, was auch höchst unschön wäre.

Hier noch das C++ Beispiel:

Code:

template <typename T>
class Test
{
private:
    T x;
public:
    // Constructor
    Test(T value)
    {
        x = value;
    }
    // Implicit cast
    operator T ()
    {
        return x;       
    }
};

int _tmain(int argc, _TCHAR* argv[])
{
    // Compiliert
    Test<int> test1(90);
    int x1 = test1 * 4;
    // Compiliert
    Test<float> test2(13.5f);
    float x2 = test2 * 4;
    // Fehler, da * nicht implementiert für char*
    Test<char*> test3(nullptr);
    char* x3 = test3 * 4;
    return 0;
}