Typecasting - Revision history

SeriousBarbie: set red link to correction destination

2016-10-07T04:19:34Z

set red link to correction destination

Wormbo: /* Implicit type conversion */ added section for the 'coerce' keyword

2011-04-03T16:35:56Z

‎Implicit type conversion: added section for the 'coerce' keyword

Wormbo: /* Reference type conversions */ more examples

2010-09-20T06:55:38Z

‎Reference type conversions: more examples

Wormbo: /* Primitive casts */ coerce won't cast to enum

2010-05-08T11:53:10Z

‎Primitive casts: coerce won't cast to enum

Wormbo: /* Primitive casts */ casting to enum for numeric types and minor fixes

2010-05-08T11:48:05Z

‎Primitive casts: casting to enum for numeric types and minor fixes

Wormbo: /* Explicit conversion syntax */ mentioned other redundant casts and always failing casts

2010-02-11T19:42:47Z

‎Explicit conversion syntax: mentioned other redundant casts and always failing casts

Wormbo: Reverted edits by PhoenixWing (Talk) to last revision by Wormbo

2009-10-05T11:40:02Z

Reverted edits by PhoenixWing (Talk) to last revision by Wormbo

PhoenixWing: Messed up Link

2009-10-04T21:15:34Z

Messed up Link

PhoenixWing: Changed the DynamicLoadObject() function (Which led to a blank page) to the actual DynamicLoadObject wiki page

2009-10-04T21:14:32Z

Changed the DynamicLoadObject() function (Which led to a blank page) to the actual DynamicLoadObject wiki page

Wormbo: /* string to... */ mentioned DLO() for string->Object

2009-08-20T06:35:21Z

‎string to...: mentioned DLO() for string->Object

@@ Line 83: / Line 83: @@
 ; ...bool : Returns ''False'' if Pitch, Yaw and Roll components are zero, otherwise ''True''.
 ; ...string : Returns the string representations of the Pitch, Yaw and Roll components of the rotator, separated by commas. Each component value is normalized to the range of 0 to 65535. If you want the string representations of actual integer values, you need to typecast the components separately.
-; ...vector : Returns a [[wp:unit vector|unit vector]] (i.e. VSize() == 1.0) pointing in the direction described by the Pitch and Yaw components of the rotator value. The zero rotator <code>rot(0,0,0)</code> corresponds to the unit vector pointing in positive X-axis direction <code>vect(1.0,0.0,0.0)</code>. The result is the same as the [[out parameter]] X of the GetAxes() function.
+; ...vector : Returns a [[wp:unit vector|unit vector]] (i.e. VSize() == 1.0) pointing in the direction described by the Pitch and Yaw components of the rotator value. The zero rotator <code>rot(0,0,0)</code> corresponds to the unit vector pointing in positive X-axis direction <code>vect(1.0,0.0,0.0)</code>. The result is the same as the [[Functions#out_parameter|out parameter]] X of the GetAxes() function.
 ===vector to...===

← Older revision		Revision as of 16:35, 3 April 2011
Line 29:		Line 29:

	For engine implementations that support [[interfaces]], object references can be implicitly converted to all implemented interfaces when assigning the reference to a variable of the interface type. Note that this does ''not'' apply to class limiters, those strictly follow the class hierarchy without respecting the "cross connections" created by implementing interfaces!		For engine implementations that support [[interfaces]], object references can be implicitly converted to all implemented interfaces when assigning the reference to a variable of the interface type. Note that this does ''not'' apply to class limiters, those strictly follow the class hierarchy without respecting the "cross connections" created by implementing interfaces!
		+
		+	===Parameters defined with ''coerce''===
		+	[[Functions]] and [[operators]] can apply the keyword [[coerce]] to their parameter declarations to instruct the compiler to automatically perform type conversion on values passed when the function or operator is called. That is only possible if an explicit type conversion exists from the value's type to the parameter's type. See the following section for a list of possible type conversions.
		+
		+	Usually the ''coerce'' keyword is only used for [[string]] parameters. It is widely used in the built-in string functions and operators and in the logging functions.

	==Primitive casts==		==Primitive casts==

@@ Line 97: / Line 97: @@
 ===Dynamic casts===
 A dynamic cast typecasts an object reference of a certain class, for example Actor, to a subclass, for example Inventory.
 Attempting to typecast to a class that is not a subclass of the original object reference type will be refused by the compiler, either for being redundant (i.e. casting to te same class or a parent class) or because the conversion would always fail. Examples of conversions that will always fail include Pawn to Inventory and Weapon to Ammo, or more generally all conversions between unrelated branches of the class tree.
 ===Metacasts===
 If the result of a type conversion is a [[class limiter]] type, the conversion is also called metacast. Metacasts are not limited to class references, but can also be used to convert from the most-generic type Object. Class references are special object references after all. Like for dynamic casts, metacasts between different class limiter types will only be accepted by the compiler if the target limiter metaclass is a subclass of the casted class limiter's metaclass. Typecasting to the same metaclass or one of its parent classes is refused for being redundant and typecasting to a metaclass in an unrelated branch of the class tree is refused because it will always fail.
 The most common use for metacasts is when loading classes with the [[DynamicLoadObject() function]]:
 <uscript>
@@ Line 110: / Line 149: @@
 </uscript>
 The above example only works because of the metacast. DynamicLoadObject() only returns a reference of type Object, so a typecast is definitely required. A simple dynamic cast to type Class (which would actually be a metacast to <code>class<Object></code>)will not work here, because the Spawn() function requires an Actor class as its parameter.
 ==Other conversions==

@@ Line 31: / Line 31: @@
 ==Primitive casts==
-Not all possible combinations of type conversions can actually be performed. For example, converting a floating point value to a class or a struct value to a name does not provide any meaningful result. This section lists all built-in primitive casts. These conversions will happen automatically when passing values to function parameters declared with the [[coerce]] modifier.
+Not all possible combinations of type conversions can actually be performed. For example, converting a floating point value to a class or a struct value to a name does not provide any meaningful result. This section lists all built-in primitive casts. These conversions will happen automatically when passing values to function parameters declared with the [[coerce]] modifier, unless the conversion requires casting to an [[enum]] type.
 Note that it might be a good idea to specify literals of the target type directly instead of typecasting from a different type. For example <code>rotator(vect(0.0,1.0,0.0))</code> should be written as <code>rot(0,16384,0)</code> instead.

@@ Line 36: / Line 36: @@
 ===bool to...===
-; ...byte, int or float : Returns 1 (or 1.0) for the value ''True'' and 0 (of 0.0) for the value ''False''.
+; ...byte, int or float : Returns 1 (or 1.0) for the value ''True'' and 0 (or 0.0) for the value ''False''.
 ; ...string : Returns the localized version of the strings "True" or "False" for the values ''True'' and ''False'' respectively.
 ===byte to...===
 ; ...bool : Returns ''False'' for the byte value 0 and ''True'' for any other value.
 ; ...string : Returns the decimal string representation of the byte value.
-All byte conversions also apply to values of [[enum]] types.
 ===int to...===
 ; ...byte : Int to byte conversion truncates the binary representation of the int value to the least significant eight bits. Negative int values are stored in [[wp:two's complement|two's complement]], so for example converting -1 to byte results in the value 255.
 ; ...float : Int to float conversion returns the nearest possible float value. This is unproblematic for values between -16777216 (0xFF000000) and +16777216 (0x1000000), but for larger positive or smaller negative values the float data type is not precise enough, so rounding will occur.
-; ...bool : Returns ''False'' for the int value 0 and ''True'' for any other value.
+; ...[[enum]] types : Performs conversion to byte, then returns the enum constant corresponding to the resulting numeric value. (0 -> first value, 1 -> second value, etc.)
 ; ...string : Returns the decimal string representation of the int value. Negative values are preceded by a minus sign, positive values do not have a sign in their string representation.
 ===float to...===
 ; ...bool : Returns ''False'' for the float value 0.0 and ''True'' for any other value.
 ; ...string : Returns the decimal string representation of the float value with a fixed number of digits after the decimal point and as many digits before the decimal point as necessary. Negative values are preceded by a minus sign. The number of digits after the decimal point is hard-coded and varies from game to game. For example, [[UT]] emits six digits, [[UT2003]] and [[UT2004]] only two. For obvious reasons this greatly limits the accuracy for small values. Scientific notation is not supported.
@@ Line 64: / Line 68: @@
 ===string to...===
 ; ...bool : The result is ''True'' for the string "true", both in the English and localized version, as well as any string that, when converted to int, stands for a number other than zero. Any other string results in the value ''False''.
 ; ...byte : Has the same result as string to int conversion, followed by int to byte conversion.
 ; ...name : This conversion is only allowed in [[Unreal Engine 3]] and returns a name value that case-insensitively equals the input string. If the name value was not used before, its capitalization is the same as the original string's, otherwise capitalization may differ.
 ; ...rotator : Expects a string containing at least two commas, which are used to divide the string. All three parts are converted as described for string to int conversion above. The first value becomes the rotator value's Pitch component, the second the Yaw component and the third the Roll component. If the string contains no or only one comma, only Pitch or Pitch and Yaw are filled, while the remaining components stay 0.

@@ Line 8: / Line 8: @@
 Typename is the type to convert the value to. As you can see, this syntax looks like a function call and is a good reason why your [[functions]] should not have the same name as any built-in or user-defined types. If a function and a type of the same name are found, the function call takes precedence over the typecast.
-'''Note:''' The compiler will throw an error message if the target type is identical to the value's type.
+'''Note:''' The compiler will throw an error message if the typecast is redundant, for example because the target type is identical to the value's type, or will always fail, for example when casting between classes from unrelated branches of the class tree.
 ==Implicit type conversion==

@@ Line 69: / Line 69: @@
 ; ...rotator : Expects a string containing at least two commas, which are used to divide the string. All three parts are converted as described for string to int conversion above. The first value becomes the rotator value's Pitch component, the second the Yaw component and the third the Roll component. If the string contains no or only one comma, only Pitch or Pitch and Yaw are filled, while the remaining components stay 0.
 ; ...vector : Expects a string containing at least two commas, which are used to divide the string. All three parts are converted as described for string to float conversion above. The values become the X, Y and Z components of the vector. If the string contains no or only one comma, only the X or X and Y components are filled, while the remaining components stay 0.
-Note that strings can't be converted to object references or name values (except for Unreal Engine 3) using the typecasting syntax. To load or find an object reference via the object's string name, use the [[Legacy:DynamicLoadObject]] function
+Note that strings can't be converted to object references or name values (except for Unreal Engine 3) using the typecasting syntax. To load or find an object reference via the object's string name, use the [[DynamicLoadObject() function]].
 ===rotator to...===