如何在Delphi对象或字符串中隐式使用ToString（）？

Question

Delphi is like an England Queen Guard. It does not like ambiguity and may even kill to protect the hard code. But Java is almost a street corner woman. When I use this is java:

 Button button = new Button();
 String a = "This is a " + button;

I get This is a button

But if I do that in Delphi:

 ShowMessage('This is a ' + Button1);

I get an error, because Delphi has toString() method (now) but it does not implicitly calls it. Because literal strings are not objects in OP. The correct use is:

 ShowMessage('This is a ' + Button1.toString());

Is there any way to override this behave so it works like Java?

For reference: How an object will call toString method implicitly?

Answer 1

There's no way to enforce an implicit cast or method call on an object instance.

If this was a record that you controlled then you could implement an Implicit class operator that would perform a cast to string .

The issue discussed link that you refer to is simply an implementation detail of PrintStream.println() . That relies on the ability of String.valueOf() to come up with a string representation for any object which in turn relies on Object.toString() . In fact the discussion there concerning println() is unrelated to the way the + operator in Java works which is the pertinent issue in your question.

Delphi's TObject has a virtual ToString method that could be used to perform the same purpose. So it would be easy enough to use the exact same technique as PrintStream.println() in Delphi code.

Answer 2

If you had a special function that worked like Format , you could get that behavior. I wrote a function like that several years ago, back when the built-in function didn't support Unicode. I've now updated it to support calling ToString on an object when it's passed as the argument for the %s format string. You'd call it like this:

ShowMessage(WideFormat('This is a %s', [Button1]));

I'm sorry the code hasn't really been touched in several years, so it might not work as-is in newer Delphi versions. You'll have to decide whether it's worth the effort to update that code, although it was included in Project Jedi long enough that it did get a few nominal updates to support UnicodeString and 64-bit compilation.

Answer 3

Too bad that it works only on ARM compiler and Delphi.NET Great article by Nick Hodges in http://edn.embarcadero.com/article/34324

TMyClass = class
    class operator Add(a, b: TMyClass): TMyClass; // Addition of two operands of type TMyClass
    class operator Subtract(a, b: TMyClass): TMyclass; // Subtraction of type TMyClass
    class operator Implicit(a: Integer): TMyClass; // Implicit conversion of an Integer to type TMyClass
    class operator Implicit(a: TMyClass): Integer; // Implicit conversion of TMyClass to Integer
    class operator Explicit(a: Double): TMyClass; // Explicit conversion of a Double to TMyClass
end;

// Example implementation of Add class operator 
TMyClass.Add(a, b: TMyClass): TMyClass;
begin
  ...
end;

var
x, y: TMyClass
begin
  x := 12; // Implicit conversion from an Integer 
  y := x + x; // Calls TMyClass.Add(a, b: TMyClass): TMyClass 
  b := b + 100; // Calls TMyClass.Add(b, TMyClass.Implicit(100)) 
end;