Scripting: Operators – Arma Reforger

From Bohemia Interactive Community
Jump to navigation Jump to search
m (Text replacement - "<syntaxhighlight lang="C#">" to "<enforce>")
m (Fix PHP interferences, Some wiki formatting)
(8 intermediate revisions by the same user not shown)
Line 1: Line 1:
{{TOC|side}}
{{TOC|side}}
'''Operators''' are elements used to generate operations between two values.
'''Operators''' are elements used to generate operations between two values.
{{Feature|informative|Operators have a '''precedence''' order; see {{HashLink|#Precedence}} section below for more information.}}
{{Feature|informative|Operators have a '''precedence''' order; see {{Link|#Precedence}} section below for more information.}}




Line 8: Line 8:
=== Assignment ===
=== Assignment ===


<div style="font-family: monospace">
==== {{=}} ====
==== {{=}} ====
</div>
The "assign operator sets the righthand value to the lefthand variable.
The "assign operator sets the righthand value to the lefthand variable.
<enforce>
<enforce>
int five = 5;
int five = 5;
</syntaxhighlight>
</enforce>
{{Feature|important|This operator is '''NOT''' an equality check. For this, see {{HashLink|#{{=}}{{=}}}}.}}
{{Feature|important|This operator is '''NOT''' an equality check. For this, see {{Link|#{{=}}{{=}}}}.}}


<div style="font-family: monospace">
==== ++ ====
==== ++ ====
The increment operator adds 1 to the provided numerical variable. It only applies to int and float values.
</div>
The increment (or post-increment) operator adds 1 to the provided numerical variable. It only applies to int and float values.
<enforce>
<enforce>
int result = 5;
int result = 5;
result++; // result is 6
result++; // result is 6
</syntaxhighlight>
</enforce>


This operator can be used ''before'' the value as well (it is then called ''pre-increment'' operator):
<enforce>
int result = 5;
++result; // result is 6
</enforce>
The difference is that the ''returned'' value is incremented too: <!-- let's not talk about how ++i ''may'' be faster than i++ here -->
{|
| <enforce>
int result = 5;
Print(result++); // outputs 5, result is 6
</enforce>
| <enforce>
int result = 5;
Print(++result); // outputs 6, result is 6
</enforce>
|}
<div style="font-family: monospace">
==== -- ====
==== -- ====
The decrement operator removes 1 to the provided numerical variable. It only applies to int and float values.
</div>
The decrement (or post-decrement) operator removes 1 to the provided numerical variable. It only applies to int and float values.
<enforce>
<enforce>
int result = 5;
int result = 5;
result--; // result is 4
result--; // result is 4
</syntaxhighlight>
</enforce>
 
Same as {{Link|#++}}, this operator can be used ''before'' the value (then called ''pre-decrement'' operator):
<enforce>
int result = 5;
--result; // result is 4
</enforce>


{|
| <enforce>
int result = 5;
Print(result--); // outputs 5, result is 4
</enforce>
| <enforce>
int result = 5;
Print(--result); // outputs 4, result is 4
</enforce>
|}
<div style="font-family: monospace">
==== +{{=}} ====
==== +{{=}} ====
</div>
The "add to" operator adds the righthand value to the lefthand variable.
The "add to" operator adds the righthand value to the lefthand variable.
<enforce>
<enforce>
int result = 5;
int result = 5;
result += 3; // result is 8
result += 3; // result is 8
</syntaxhighlight>
</enforce>


<div style="font-family: monospace">
==== -{{=}} ====
==== -{{=}} ====
</div>
The "subtract from" operator subtract the righthand value to the lefthand variable.
The "subtract from" operator subtract the righthand value to the lefthand variable.
<enforce>
<enforce>
int result = 5;
int result = 5;
result -= 3; // result is 2
result -= 3; // result is 2
</syntaxhighlight>
</enforce>


<div style="font-family: monospace">
==== *{{=}} ====
==== *{{=}} ====
</div>
The "multiply with" operator multiplies the lefthand variable with the righthand value.
The "multiply with" operator multiplies the lefthand variable with the righthand value.
<enforce>
<enforce>
int result = 5;
int result = 5;
result *= 3; // result is 15
result *= 3; // result is 15
</syntaxhighlight>
</enforce>


<div style="font-family: monospace">
==== /{{=}} ====
==== /{{=}} ====
</div>
The "divide by" operator multiplies the lefthand variable with the righthand value.
The "divide by" operator multiplies the lefthand variable with the righthand value.
<enforce>
<enforce>
int result = 5;
int result = 5;
result /= 3; // result is 1 (floored int value)
result /= 3; // result is 1 (floored int value)
</syntaxhighlight>
</enforce>


=== Arithmetic ===
=== Arithmetic ===


<div style="font-family: monospace">
==== + ====
==== + ====
</div>
he "adds" operator does an addition between two numeric values, float and/or integer.
he "adds" operator does an addition between two numeric values, float and/or integer.
<enforce>
<enforce>
Line 65: Line 116:
5 + 2.5; // result is 7.5 (float)
5 + 2.5; // result is 7.5 (float)
3.25 + 1.75; // result is 5.0 (float)
3.25 + 1.75; // result is 5.0 (float)
</syntaxhighlight>
</enforce>


<div style="font-family: monospace">
==== - ====
==== - ====
</div>
The "subtract from" operator does a subtraction between two numerical values, float and/or integer.
The "subtract from" operator does a subtraction between two numerical values, float and/or integer.
<enforce>
<enforce>
Line 73: Line 126:
5 - 2.5; // result is 2.5 (float)
5 - 2.5; // result is 2.5 (float)
3.25 - 1.25; // result is 2.0 (float)
3.25 - 1.25; // result is 2.0 (float)
</syntaxhighlight>
</enforce>


<div style="font-family: monospace">
==== * ====
==== * ====
</div>
The multiplication sign does a multiplication between two numerical values, float and/or integer.
The multiplication sign does a multiplication between two numerical values, float and/or integer.
<enforce>
<enforce>
5 * 3; // result is 15
5 * 3; // result is 15
5 * 2.5; // result is 12.5 (float)
5 * 2.5; // result is 12.5 (float)
1.5 * 3.25; // result is 4.875 (float)
1.5 * 3.25; // result is 4.875 (float)
</syntaxhighlight>
</enforce>


<div style="font-family: monospace">
==== / ====
==== / ====
</div>
The "divided by" operator divides the left argument by the right one.<br>
The "divided by" operator divides the left argument by the right one.<br>
It can be applied to int, float or a mix of those.
It can be applied to int, float or a mix of those.
If both values are int, the return value will be a '''floored''' integer as well.
If both values are int, the return value will be a '''floored''' integer as well.
<enforce>
<enforce>
5 / 3; // result is 1 (int): 5/3 = 1.666(...), but integer floors the value
5 / 3; // result is 1 (int): 5/3 = 1.666(...), but integer floors the value
5 / 2.5; // result is 2.0 (float)
5 / 2.5; // result is 2.0 (float)
3.5 / 0.5; // result is 7.0 (float)
3.5 / 0.5; // result is 7.0 (float)
</syntaxhighlight>
</enforce>


<div style="font-family: monospace">
==== % ====
==== % ====
</div>
Modulo is an operator that gives the remainder of a division.<br>
Modulo is an operator that gives the remainder of a division.<br>
It only applies to integers.
It only applies to integers.
{{Feature|informative|See the [enfusion://ScriptEditor/scripts/Game/Global/Functions.c{{!}}SCR_Global].fmod}} method for a float modulo approximation.}}
{{Feature|informative|See the <enforce inline>Math.Repeat()</enforce> method for a float modulo approximation.}}
<enforce>
<enforce>
  5 % 3; // result is 2: 5 is one time 3, remaining 2
  5 % 3; // result is 2: 5 is one time 3, remaining 2
10 % 2; // result is 0: 10 is five times 2, remaining 0
10 % 2; // result is 0: 10 is five times 2, remaining 0
</syntaxhighlight>
</enforce>




=== Relational ===
=== Relational ===


<div style="font-family: monospace">
==== &gt; ====
==== &gt; ====
</div>
The "greater than" operator returns '''true''' if the left argument is strictly greater than the right argument, false otherwise.<br>
The "greater than" operator returns '''true''' if the left argument is strictly greater than the right argument, false otherwise.<br>
It can be applied to int, float or a mix of those.
It can be applied to int, float or a mix of those.
<enforce>
<enforce>
10 > 11; // false
10 > 11; // false
10 > 10; // false
10 > 10; // false
10 >  9; // true
10 >  9; // true


10 > 5; // true
10 > 5; // true
10 > 5.5; // true
10 > 5.5; // true
10.5 > 5; // true
10.5 > 5; // true
</syntaxhighlight>
</enforce>


<div style="font-family: monospace">
==== &lt; ====
==== &lt; ====
</div>
The "lesser than" operator returns '''true''' if the left argument is strictly smaller than the right argument, false otherwise.<br>
The "lesser than" operator returns '''true''' if the left argument is strictly smaller than the right argument, false otherwise.<br>
It can be applied to int, float or a mix of those.
It can be applied to int, float or a mix of those.
<enforce>
<enforce>
10 < 11; // true
10 < 11; // true
10 < 10; // false
10 < 10; // false
10 <  9; // false
10 <  9; // false


10 < 5; // false
10 < 5; // false
10 < 5.5; // false
10 < 5.5; // false
10.5 < 5; // false
10.5 < 5; // false
</syntaxhighlight>
</enforce>


<div style="font-family: monospace">
==== &gt;{{=}} ====
==== &gt;{{=}} ====
</div>
The "greater than or equal" operator returns '''true''' if the left argument is greater than or equal to the right argument, false otherwise.<br>
The "greater than or equal" operator returns '''true''' if the left argument is greater than or equal to the right argument, false otherwise.<br>
It can be applied to int, float or a mix of those.
It can be applied to int, float or a mix of those.
<enforce>
<enforce>
10 >= 11; // false
10 >= 11; // false
10 >= 10; // true
10 >= 10; // true
10 >=  9; // true
10 >=  9; // true


10 >= 5; // true
10 >= 5; // true
10 >= 5.5; // true
10 >= 5.5; // true
10.5 >= 5; // true
10.5 >= 5; // true
</syntaxhighlight>
</enforce>


<div style="font-family: monospace">
==== &lt;{{=}} ====
==== &lt;{{=}} ====
</div>
The "lesser than or equal" operator returns '''true''' if the left argument is smaller than or equal to the right argument, false otherwise.<br>
The "lesser than or equal" operator returns '''true''' if the left argument is smaller than or equal to the right argument, false otherwise.<br>
It can be applied to int, float or a mix of those.
It can be applied to int, float or a mix of those.
<enforce>
<enforce>
10 <= 11; // true
10 <= 11; // true
10 <= 10; // true
10 <= 10; // true
10 <=  9; // false
10 <=  9; // false


10 <= 5; // false
10 <= 5; // false
10 <= 5.5; // false
10 <= 5.5; // false
10.5 <= 5; // false
10.5 <= 5; // false
</syntaxhighlight>
</enforce>


<div style="font-family: monospace">
==== {{=}}{{=}} ====
==== {{=}}{{=}} ====
</div>
The "equals" operator returns '''true''' if the left argument is strictly equal to the right argument, false otherwise.
The "equals" operator returns '''true''' if the left argument is strictly equal to the right argument, false otherwise.


Applies to:
Applies to:
* boolean
* bool
* int
* int
* float
* float
Line 187: Line 256:
MyClass object2 = new MyClass();
MyClass object2 = new MyClass();
object1 == object2; // false - same type, different instance
object1 == object2; // false - same type, different instance
</syntaxhighlight>
</enforce>


<div style="font-family: monospace">
==== !{{=}} ====
==== !{{=}} ====
</div>
The "different" operator returns '''true''' if the left argument is different from the right argument, false otherwise.
The "different" operator returns '''true''' if the left argument is different from the right argument, false otherwise.


Applies to:
Applies to:
* boolean
* bool
* int
* int
* float
* float
Line 216: Line 287:
MyClass object2 = new MyClass();
MyClass object2 = new MyClass();
object1 != object2; // true - different instance
object1 != object2; // true - different instance
</syntaxhighlight>
</enforce>


=== Logical ===
=== Logical ===


<div style="font-family: monospace">
==== &amp;&amp; ====
==== &amp;&amp; ====
</div>
The "and" operator returns '''true''' if both left and right conditions are true.
The "and" operator returns '''true''' if both left and right conditions are true.
<enforce>
<enforce>
boolean a = false;
bool a = false;
boolean b = false;
bool b = false;
boolean result = a && b; // result is false
bool result = a && b; // result is false


boolean a = true;
bool a = true;
boolean b = false;
bool b = false;
boolean result = a && b; // result is false
bool result = a && b; // result is false


boolean a = true;
bool a = true;
boolean b = true;
bool b = true;
boolean result = a && b; // result is true
bool result = a && b; // result is true
</syntaxhighlight>
</enforce>


<div style="font-family: monospace">
==== {{!}}{{!}} ====
==== {{!}}{{!}} ====
</div>
The "or" logical operator returns '''true''' if left or right condition is true (or both).
The "or" logical operator returns '''true''' if left or right condition is true (or both).
<enforce>
<enforce>
boolean a = false;
bool a = false;
boolean b = false;
bool b = false;
boolean result = a || b; // result is false
bool result = a || b; // result is false


boolean a = true;
bool a = true;
boolean b = false;
bool b = false;
boolean result = a || b; // result is true
bool result = a || b; // result is true


boolean a = true;
bool a = true;
boolean b = true;
bool b = true;
boolean result = a || b; // result is true
bool result = a || b; // result is true
</syntaxhighlight>
</enforce>


<div style="font-family: monospace">
==== ! ====
==== ! ====
The "not" logical operator inverts a boolean value: {{hl|true}} becomes {{hl|false}} and {{hl|false}} becomes {{hl|true}}.<br>
</div>
The "not" logical operator inverts a bool value: {{hl|true}} becomes {{hl|false}} and {{hl|false}} becomes {{hl|true}}.<br>
It can also be used on:
It can also be used on:
* int or float (0 comparison)
* int or float (0 comparison)
Line 259: Line 336:
* object (null comparison)
* object (null comparison)
<enforce>
<enforce>
boolean a = true;
bool a = true;
boolean result = !a; // result is false
bool result = !a; // result is false


boolean a = false;
bool a = false;
boolean result = !a; // result is true
bool result = !a; // result is true


boolean isAlive = player.IsAlive();
bool isAlive = player.IsAlive();
boolean isDead = !isAlive;
bool isDead = !isAlive;


int health = 0;
int health = 0;
if (!health) // same as if (health == 0)
if (!health) // same as if (health == 0) - not recommended
{
Print("dead");
Print("dead");
}


float fHealth = 0.0;
float fHealth = 0.0;
if (!fHealth) // same as if (fHealth == 0)
if (!fHealth) // same as if (fHealth == 0) - not recommended
{
Print("dead");
Print("dead");
}


string data = "";
string data = "";
if (!data) // same as if (data.IsEmpty()) and if (data == "")
if (!data) // same as if (data.IsEmpty()) and if (data == "") - not recommended
{
Print("empty string");
Print("empty string");
}


MyClass instance = null;
MyClass instance = null;
if (!instance) // same as if (instance == null)
if (!instance) // same as if (instance == null)
{
Print("instance is null!");
Print("instance is null!");
}


// note that if (value) to check an object is -not- null works too
// note that if (value) to check an object is -not- null works too
if (instance) // same as if (instance != null)
if (instance) // same as if (instance != null)
{
Print("instance is NOT null!");
Print("instance is NOT null!");
}
</enforce>
</syntaxhighlight>


=== Bitwise ===
=== Bitwise ===


<div style="font-family: monospace">
==== &amp; ====
==== &amp; ====
</div>
The "bitwise AND" operator applies a AND operation between values bits - both bits must be 1 to return 1, otherwise 0 is returned.
The "bitwise AND" operator applies a AND operation between values bits - both bits must be 1 to return 1, otherwise 0 is returned.
<enforce>
<enforce>
Line 308: Line 377:
int result = a & b; // 00001001 in binary
int result = a & b; // 00001001 in binary
// result is 9
// result is 9
</syntaxhighlight>
</enforce>


<div style="font-family: monospace">
==== {{!}} ====
==== {{!}} ====
</div>
The "bitwise OR" operator applies a OR operation between values bits - one of the bits must be 1 to return 1, otherwise 0 is returned.
The "bitwise OR" operator applies a OR operation between values bits - one of the bits must be 1 to return 1, otherwise 0 is returned.
<enforce>
<enforce>
Line 317: Line 388:
int result = a | b; // 00001111 in binary
int result = a | b; // 00001111 in binary
// result is 15
// result is 15
</syntaxhighlight>
</enforce>


<div style="font-family: monospace">
==== ~ ====
==== ~ ====
</div>
The "bitwise NOT" operator reverts all bits of the provided value: 1 becomes 0 and vice-versa.
The "bitwise NOT" operator reverts all bits of the provided value: 1 becomes 0 and vice-versa.
<enforce>
<enforce>
Line 325: Line 398:
int result = ~a; // 1111 1111 1111 1111 1111 1111 1111 1000 in binary
int result = ~a; // 1111 1111 1111 1111 1111 1111 1111 1000 in binary
// result is -8
// result is -8
</syntaxhighlight>
</enforce>


<div style="font-family: monospace">
==== &lt;&lt; ====
==== &lt;&lt; ====
</div>
The left shift operator moves all bits of the provided value to the left.
The left shift operator moves all bits of the provided value to the left.
<enforce>
<enforce>
Line 336: Line 411:
// result is 00000100
// result is 00000100
// result is 4
// result is 4
</syntaxhighlight>
</enforce>


<div style="font-family: monospace">
==== &gt;&gt; ====
==== &gt;&gt; ====
</div>
The right shift operator moves bits of the provided value to the right.
The right shift operator moves bits of the provided value to the right.
<enforce>
<enforce>
Line 347: Line 424:
// result is 00000001
// result is 00000001
// result is 1
// result is 1
</syntaxhighlight>
</enforce>


=== String ===
=== String ===


<div style="font-family: monospace">
==== + ====
==== + ====
</div>
The "adds" operator used with strings concatenates them.
The "adds" operator used with strings concatenates them.
When it is used with string and another type, it will stringify (calling its .ToString() method) the other value.
When it is used with string and another type, it will stringify (calling its .ToString() method) the other value.
Line 361: Line 440:
string result = a + " " + b; // result is "Hello there"
string result = a + " " + b; // result is "Hello there"


string stringifiedBoolean = "string " + true; // result is "string true"
string stringifiedBool = "string " + true; // result is "string true"
string stringifiedInt = "string " + 42; // result is "string 42"
string stringifiedInt = "string " + 42; // result is "string 42"
string stringifiedFloat = "string " + 4.0; // result is "string 4"
string stringifiedFloat = "string " + 4.0; // result is "string 4"
Line 374: Line 453:
string ok2 = "test" + 3 + true + false + 4; // will return "test3104"
string ok2 = "test" + 3 + true + false + 4; // will return "test3104"
string error = 3 + "test"; // will throw a parsing error
string error = 3 + "test"; // will throw a parsing error
</syntaxhighlight>
</enforce>


=== Indexing ===
=== Indexing ===


<div style="font-family: monospace">
==== <nowiki>[]</nowiki> ====
==== <nowiki>[]</nowiki> ====
The "get index" operator is used on arrays to get an element by its '''zero-based''' index (e.g 0 is first element, 1 is second, etc).
</div>
The "get index" operator is used on arrays to get an element by its '''zero-based''' index (e.g 0 is first element, 1 is second, etc). It is '''very''' efficient on '''static''' arrays.
It can also be used on strings, as strings are arrays of characters.
It can also be used on strings, as strings are arrays of characters.
<enforce>
<enforce>
int staticNumbers[5] = { 1, 2, 3, 4, 5 };
int thirdStaticNumber = staticNumbers[2]; // result is 3, lightning fast on static arrays
array<int> numbers = { 1, 2, 3, 4, 5 };
array<int> numbers = { 1, 2, 3, 4, 5 };
int thirdNumber = letters[2]; // result is 3
int thirdNumber = letters[2]; // result is 3


array<string> letters = { "A", "B", "C", "D", "E" };
array<string> letters = { "A", "B", "C", "D", "E" };
string thirdLetter = letters[2]; // result is "C"
string thirdLetter = letters[2]; // result is "C"


string text = "ABCDE";
string text = "ABCDE";
string thirdLetter = text[2]; // result is "C"
string thirdLetter = text[2]; // result is "C"
</syntaxhighlight>
</enforce>
 
{{Feature|important|
The {{hl|[i]}} operator is equivalent to a <enforce inline>.Get(i)</enforce> method call for anything else than static arrays;
in order to save unrequired method calls, either use {{Link|Arma Reforger:Scripting: Keywords#foreach|foreach}} or cache the call result whenever possible.
<enforce>
// bad
for (int i, count = myArray.Count(); i < count; i++)
{
if (myArray[i].IsEmpty()) // .Get(i) equivalent
Print("#" + i + " is empty");
else
Print("trimmed '" + myArray[i] + "' is '" + myArray[i].Trim() + "'"); // .Get(i) equivalent, twice
}
 
// good
for (int i, count = myArray.Count(); i < count; i++)
{
string value = myArray[i]; // .Get(i) equivalent
if (value.IsEmpty())
Print("#" + i + " is empty");
else
Print("trimmed '" + value + "' is '" + value.Trim() + "'");
}
 
// best
foreach (int i, string value : myArray)
{
if (value.IsEmpty())
Print("#" + i + " is empty");
else
Print("trimmed '" + value + "' is '" + value.Trim() + "'");
}
</enforce>
}}




== Precedence ==
== Precedence ==


Operators precedence (one having execution priority over another) in Enforce Script is identical to the C language: see the {{Wikipedia|Operators_in_C_and_C%2B%2B#Operator_precedence|Wikipedia article section}}.
Operators precedence (one having execution priority over another) in Enforce Script is identical to the C language:
see the {{Link|https://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B#Operator_precedence|Wikipedia article section}}.
<!--
TODO: remove things that do not exist in Enforce Script
 
{| class="wikitable"
! Precedence
! Operator
! Description
! Associativity
|-
! 1
<small>highest</small>
| <code>::</code>
| [[:en:Scope_resolution_operator#C.2B.2B|Scope resolution]] (C++ only)
| None
|-
! rowspan="11" | 2
| <code>++</code>
| Postfix increment
| rowspan="11" | Left-to-right
|-
| <code>--</code>
| Postfix decrement
|-
| <code>()</code>
| Function call
|-
| <code>[]</code>
| Array subscripting
|-
| <code>.</code>
| Element selection by reference
|-
| <code>-></code>
| Element selection through pointer
|-
| <code>typeid()</code>
| [[:en:Run-time_type_information|Run-time type information]] (C++ only) (see [[:en:Typeid|typeid]])
|-
| <code>const_cast</code>
| Type cast (C++ only) (see [[:en:Const_cast|const_cast]])
|-
| <code>dynamic_cast</code>
| Type cast (C++ only) (see [[:en:Dynamic_cast|dynamic cast]])
|-
| <code>reinterpret_cast</code>
| Type cast (C++ only) (see [[:en:Reinterpret_cast|reinterpret_cast]])
|-
| <code>static_cast</code>
| Type cast (C++ only) (see [[:en:Static_cast|static_cast]])
|-
! rowspan="13" | 3
| <code>++</code>
| Prefix increment
| rowspan="13" |Right-to-left
|-
| <code>--</code>
| Prefix decrement
|-
| <code>+</code>
| Unary plus
|-
| <code>-</code>
| Unary minus
|-
| <code>!</code>
| Logical NOT
|-
| <code>~</code>
| Bitwise NOT (Ones' Complement)
|-
| <code>(''type'')</code>
| Type cast
|-
| <code>*</code>
| Indirection (dereference)
|-
| <code>&</code>
| Address-of
|-
| <code>sizeof</code>
| [[:en:Sizeof|Sizeof]]
|-
| <code>_Alignof</code>
| Alignment requirement (since C11)
|-
| <code>new</code>, <code>new[]</code>
| Dynamic memory allocation (C++ only)
|-
| <code>delete</code>, <code>delete[]</code>
| Dynamic memory deallocation (C++ only)
|-
! rowspan="2" | 4
| <code>.*</code>
| Pointer to member (C++ only)
| rowspan="2" | Left-to-right
|-
| <code>->*</code>
| Pointer to member (C++ only)
|-
! rowspan="3" | 5
| <code>*</code>
| Multiplication
| rowspan="3" | Left-to-right
|-
| <code>/</code>
| Division
|-
| <code>%</code>
| [[:en:Modulo_operation|Modulo]] (remainder)
|-
! rowspan="2" | 6
| <code>+</code>
| Addition
| rowspan="2" | Left-to-right
|-
| <code>-</code>
| Subtraction
|-
! rowspan="2" | 7
| <code><<</code>
| [[:en:Bitwise_operation|Bitwise]] left shift
| rowspan="2" | Left-to-right
|-
| <code>>></code>
| [[:en:Bitwise_operation|Bitwise]] right shift
|-
! rowspan="1" | 8
| <code><=></code>
| [[:en:Three-way_comparison|Three-way comparison]] (Introduced in [[:en:C++20|C++20]] - C++ only)
| rowspan="1" | Left-to-right
|-
! rowspan="4" | 9
| <code><</code>
| Less than
| rowspan="4" | Left-to-right
|-
| <code><=</code>
| Less than or equal to
|-
| <code>></code>
| Greater than
|-
| <code>>=</code>
| Greater than or equal to
|-
! rowspan="2" | 10
| <code>==</code>
| Equal to
| rowspan="2" | Left-to-right
|-
| <code>!=</code>
| Not equal to
|-
! 11
| <code>&</code>
| Bitwise AND
| Left-to-right
|-
! 12
| <code>^</code>
| Bitwise XOR (exclusive or)
| Left-to-right
|-
! 13
| <code><nowiki>| </nowiki></code>
| Bitwise OR (inclusive or)
| Left-to-right
|-
! 14
| <code>&&</code>
| Logical AND
| Left-to-right
|-
! 15
| <code><nowiki>|| </nowiki></code>
| Logical OR
| Left-to-right
|-
! rowspan="2" | 16
| <code>co_await</code>
| rowspan="2" |Coroutine processing (C++ only)
| rowspan="2" |Right-to-left
|-
| <code>co_yield</code>
|-
! rowspan="13" | 17
| <code>?:</code>
| [[:en:Ternary_conditional_operator|Ternary conditional operator]]
| rowspan="13" |Right-to-left
|-
| <code>=</code>
| Direct assignment
|-
| <code>+=</code>
| Assignment by sum
|-
| <code>-=</code>
| Assignment by difference
|-
| <code>*=</code>
| Assignment by product
|-
| <code>/=</code>
| Assignment by quotient
|-
| <code>%=</code>
| Assignment by remainder
|-
| <code><<=</code>
| Assignment by bitwise left shift
|-
| <code>>>=</code>
| Assignment by bitwise right shift
|-
| <code>&=</code>
| Assignment by bitwise AND
|-
| <code>^=</code>
| Assignment by bitwise XOR
|-
| <code><nowiki>|=</nowiki></code>
| Assignment by bitwise OR
|-
| <code>throw</code>
| Throw operator (exceptions throwing, C++ only)
|-
! 18
<small>lowest</small>
| <code>,</code>
| [[:en:Comma_operator|Comma]]
| Left-to-right
|}
-->




{{GameCategory|armaR|Modding|Guidelines|Scripting}}
{{GameCategory|armaR|Modding|Guidelines|Scripting}}

Revision as of 23:32, 20 June 2023

Operators are elements used to generate operations between two values.

ⓘ
Operators have a precedence order; see Precedence section below for more information.


Types

Assignment

=

The "assign operator sets the righthand value to the lefthand variable.

int five = 5;

⚠
This operator is NOT an equality check. For this, see ==.

++

The increment (or post-increment) operator adds 1 to the provided numerical variable. It only applies to int and float values.

int result = 5; result++; // result is 6

This operator can be used before the value as well (it is then called pre-increment operator):

int result = 5; ++result; // result is 6

The difference is that the returned value is incremented too:

int result = 5; Print(result++); // outputs 5, result is 6
int result = 5; Print(++result); // outputs 6, result is 6

--

The decrement (or post-decrement) operator removes 1 to the provided numerical variable. It only applies to int and float values.

int result = 5; result--; // result is 4

Same as ++, this operator can be used before the value (then called pre-decrement operator):

int result = 5; --result; // result is 4

int result = 5; Print(result--); // outputs 5, result is 4
int result = 5; Print(--result); // outputs 4, result is 4

+=

The "add to" operator adds the righthand value to the lefthand variable.

int result = 5; result += 3; // result is 8

-=

The "subtract from" operator subtract the righthand value to the lefthand variable.

int result = 5; result -= 3; // result is 2

*=

The "multiply with" operator multiplies the lefthand variable with the righthand value.

int result = 5; result *= 3; // result is 15

/=

The "divide by" operator multiplies the lefthand variable with the righthand value.

int result = 5; result /= 3; // result is 1 (floored int value)

Arithmetic

+

he "adds" operator does an addition between two numeric values, float and/or integer.

5 + 3; // result is 8 (int) 5 + 2.5; // result is 7.5 (float) 3.25 + 1.75; // result is 5.0 (float)

-

The "subtract from" operator does a subtraction between two numerical values, float and/or integer.

5 - 3; // result is 2 (int) 5 - 2.5; // result is 2.5 (float) 3.25 - 1.25; // result is 2.0 (float)

*

The multiplication sign does a multiplication between two numerical values, float and/or integer.

5 * 3; // result is 15 5 * 2.5; // result is 12.5 (float) 1.5 * 3.25; // result is 4.875 (float)

/

The "divided by" operator divides the left argument by the right one.
It can be applied to int, float or a mix of those. If both values are int, the return value will be a floored integer as well.

5 / 3; // result is 1 (int): 5/3 = 1.666(...), but integer floors the value 5 / 2.5; // result is 2.0 (float) 3.5 / 0.5; // result is 7.0 (float)

%

Modulo is an operator that gives the remainder of a division.
It only applies to integers.

ⓘ
See the Math.Repeat() method for a float modulo approximation.

5 % 3; // result is 2: 5 is one time 3, remaining 2 10 % 2; // result is 0: 10 is five times 2, remaining 0


Relational

>

The "greater than" operator returns true if the left argument is strictly greater than the right argument, false otherwise.
It can be applied to int, float or a mix of those.

10 > 11; // false 10 > 10; // false 10 > 9; // true 10 > 5; // true 10 > 5.5; // true 10.5 > 5; // true

<

The "lesser than" operator returns true if the left argument is strictly smaller than the right argument, false otherwise.
It can be applied to int, float or a mix of those.

10 < 11; // true 10 < 10; // false 10 < 9; // false 10 < 5; // false 10 < 5.5; // false 10.5 < 5; // false

>=

The "greater than or equal" operator returns true if the left argument is greater than or equal to the right argument, false otherwise.
It can be applied to int, float or a mix of those.

10 >= 11; // false 10 >= 10; // true 10 >= 9; // true 10 >= 5; // true 10 >= 5.5; // true 10.5 >= 5; // true

<=

The "lesser than or equal" operator returns true if the left argument is smaller than or equal to the right argument, false otherwise.
It can be applied to int, float or a mix of those.

10 <= 11; // true 10 <= 10; // true 10 <= 9; // false 10 <= 5; // false 10 <= 5.5; // false 10.5 <= 5; // false

==

The "equals" operator returns true if the left argument is strictly equal to the right argument, false otherwise.

Applies to:

  • bool
  • int
  • float
  • int / float, float / int
  • string (case-sensitive)
  • vector (value)
  • array (reference)
  • object (reference)

true == true; // true true == false; // false 10 == 11; // false 10 == 10; // true 10 == 9; // false 10 == 10.0; // true 10 == 10.1; // false MyClass object1 = new MyClass(); MyClass object2 = object1; object1 == object2; // true - same type, same instance MyClass object1 = new MyClass(); MyClass object2 = new MyClass(); object1 == object2; // false - same type, different instance

!=

The "different" operator returns true if the left argument is different from the right argument, false otherwise.

Applies to:

  • bool
  • int
  • float
  • int / float, float / int
  • string (case-sensitive)
  • vector (value)
  • array (reference)
  • object (reference)

10 != 11; // true 10 != 10; // false 10 != 9; // true 10 != 10.0; // false 10 != 10.1; // true MyClass object1 = new MyClass(); MyClass object2 = object1; object1 != object2; // false - same instance MyClass object1 = new MyClass(); MyClass object2 = new MyClass(); object1 != object2; // true - different instance

Logical

&&

The "and" operator returns true if both left and right conditions are true.

bool a = false; bool b = false; bool result = a && b; // result is false bool a = true; bool b = false; bool result = a && b; // result is false bool a = true; bool b = true; bool result = a && b; // result is true

||

The "or" logical operator returns true if left or right condition is true (or both).

bool a = false; bool b = false; bool result = a || b; // result is false bool a = true; bool b = false; bool result = a || b; // result is true bool a = true; bool b = true; bool result = a || b; // result is true

!

The "not" logical operator inverts a bool value: true becomes false and false becomes true.
It can also be used on:

  • int or float (0 comparison)
  • string (empty string comparison - usage of the string.IsEmpty() method is preferred)
  • object (null comparison)

bool a = true; bool result = !a; // result is false bool a = false; bool result = !a; // result is true bool isAlive = player.IsAlive(); bool isDead = !isAlive; int health = 0; if (!health) // same as if (health == 0) - not recommended Print("dead"); float fHealth = 0.0; if (!fHealth) // same as if (fHealth == 0) - not recommended Print("dead"); string data = ""; if (!data) // same as if (data.IsEmpty()) and if (data == "") - not recommended Print("empty string"); MyClass instance = null; if (!instance) // same as if (instance == null) Print("instance is null!"); // note that if (value) to check an object is -not- null works too if (instance) // same as if (instance != null) Print("instance is NOT null!");

Bitwise

&

The "bitwise AND" operator applies a AND operation between values bits - both bits must be 1 to return 1, otherwise 0 is returned.

int a = 13; // 00001101 in binary int b = 11; // 00001011 in binary int result = a & b; // 00001001 in binary // result is 9

|

The "bitwise OR" operator applies a OR operation between values bits - one of the bits must be 1 to return 1, otherwise 0 is returned.

int a = 13; // 00001101 in binary int b = 11; // 00001011 in binary int result = a | b; // 00001111 in binary // result is 15

~

The "bitwise NOT" operator reverts all bits of the provided value: 1 becomes 0 and vice-versa.

int a = 7; // 0000 0000 0000 0000 0000 0000 0000 0111 in binary (integer is 32 bits) int result = ~a; // 1111 1111 1111 1111 1111 1111 1111 1000 in binary // result is -8

<<

The left shift operator moves all bits of the provided value to the left.

int a = 1; // 00000001 in binary int result = a << 2; // shift 'a' bits 2 steps to the left // leftmost bits are pushed "out" // rightmost bits are filled with zeros // result is 00000100 // result is 4

>>

The right shift operator moves bits of the provided value to the right.

int a = 6; // 00000110 in binary int result = a >> 2; // shift 'a' bits 2 steps to the left // leftmost bits are filled with zeros // rightmost bits are pushed "out" // result is 00000001 // result is 1

String

+

The "adds" operator used with strings concatenates them. When it is used with string and another type, it will stringify (calling its .ToString() method) the other value. The left argument must be of string type for it to happen.

string a = "Hello"; string b = "there"; string result = a + b; // result is "Hellothere" string result = a + " " + b; // result is "Hello there" string stringifiedBool = "string " + true; // result is "string true" string stringifiedInt = "string " + 42; // result is "string 42" string stringifiedFloat = "string " + 4.0; // result is "string 4" string stringifiedFloat = "string " + 4.2; // result is "string 4.2" string stringifiedArray = "string " + myArray; // result is e.g "string 0x000002820B75EA68 {0,1,2,3,4}" string stringifiedVector = "string " + myVector; // result is e.g "string <0.000000, 0.500000, 1.000000>" string stringifiedEnum = "string " + MyEnum.B; // result is e.g "string 1" string stringifiedObject = "string " + myObject; // result is e.g "string MyClass<0x00000282360ECFD0>" string stringifiedTypename = "string " + MyClass; // result is e.g "string MyClass" string ok1 = "test" + 3; // will return "test3" string ok2 = "test" + 3 + true + false + 4; // will return "test3104" string error = 3 + "test"; // will throw a parsing error

Indexing

[]

The "get index" operator is used on arrays to get an element by its zero-based index (e.g 0 is first element, 1 is second, etc). It is very efficient on static arrays. It can also be used on strings, as strings are arrays of characters.

int staticNumbers[5] = { 1, 2, 3, 4, 5 }; int thirdStaticNumber = staticNumbers[2]; // result is 3, lightning fast on static arrays array<int> numbers = { 1, 2, 3, 4, 5 }; int thirdNumber = letters[2]; // result is 3 array<string> letters = { "A", "B", "C", "D", "E" }; string thirdLetter = letters[2]; // result is "C" string text = "ABCDE"; string thirdLetter = text[2]; // result is "C"

⚠
The [i] operator is equivalent to a .Get(i) method call for anything else than static arrays;

in order to save unrequired method calls, either use foreach or cache the call result whenever possible.

// bad for (int i, count = myArray.Count(); i < count; i++) { if (myArray[i].IsEmpty()) // .Get(i) equivalent Print("#" + i + " is empty"); else Print("trimmed '" + myArray[i] + "' is '" + myArray[i].Trim() + "'"); // .Get(i) equivalent, twice } // good for (int i, count = myArray.Count(); i < count; i++) { string value = myArray[i]; // .Get(i) equivalent if (value.IsEmpty()) Print("#" + i + " is empty"); else Print("trimmed '" + value + "' is '" + value.Trim() + "'"); } // best foreach (int i, string value : myArray) { if (value.IsEmpty()) Print("#" + i + " is empty"); else Print("trimmed '" + value + "' is '" + value.Trim() + "'"); }


Precedence

Operators precedence (one having execution priority over another) in Enforce Script is identical to the C language: see the Wikipedia article section.

Retrieved from "https://community.bistudio.com/wiki?title=Arma_Reforger:Scripting:_Operators&oldid=341732"