Syntax (Overload - Custom Format Expression): ToString(POINTER valuePtr, string formatString)

Parameters (Overload):

• valuePtr - POINTER - A pointer to the memory location of the value to be converted.
• formatString - string - A formatting expression in the form of "Result = [expression]" that manipulates the output before returning it.

Return:string - The string representation of the value at the specified address.

⚙️ How It Works

This overload of ToString is a powerful low-level utility that converts a raw value in memory into a human-readable string. Its behavior is dictated by the DataType object it is called on. For example, calling ToString on an Integer_8u DataType will interpret the byte at the given address as an unsigned 8-bit integer and format it accordingly.

This method is primarily used in advanced scenarios, especially within callbacks where you might receive a value's memory address via ArgAddr() instead of the value itself.

🎨 Output Formatting

ToString provides two primary approaches for controlling how the converted result is formatted:

1. FormatStyle Enum & Precision:For quick, standardized numeric formatting, you can pass a FormatStyle enum (such as FormatStyle.Fixed or FormatStyle.Hex) along with an optional precision integer.

   • FormatStyle.Default automatically applies any global user-defined formatting established via uCalc.Format() for this data type.
   • FormatStyle.None bypasses global formatters and returns the raw value.

2. Custom Format Expressions:For granular control over a specific conversion, you can pass a custom format expression (e.g., "Result = Format('${:.2f}', double(Result))"). Because Result holds the output in string form, numeric values should be converted when passed into numeric formatting specifiers.

🆚 Comparative Analysis

vs. Native .ToString() / std::to_string

In languages like C# or C++, string conversion is tied to the compile-time type of a variable. myInt.ToString() knows it's an integer because myInt was declared as one.

uCalc's DataType.ToString(pointer) is different; it's a form of dynamic dispatch. The formatting logic is determined at runtime by the DataType object you call it on, not by the type of the pointer. This allows you to interpret the same block of memory in different ways, which is impossible with static language features.

using uCalcSoftware;

var uc = new uCalc();

// Assume 'ptr' points to a 4-byte block in memory holding the integer 1000.
var int32Type = uc.DataTypeOf("Int32");

// Interpret the memory as a standard integer
Console.WriteLine(int32Type.ToString(ptr)); // Output: 1000

// If you had a custom Hex type, you could interpret the same memory differently:
// var hexType = uc.DataTypeOf("Hex");
// wl(hexType.ToString(ptr)); // Would output: 3E8

This demonstrates a level of runtime introspection and flexibility that goes beyond typical language-level string conversion.