View source for Mscr:System.Types.Int8

[[Category:Mscr:System.Types]]
{{note|Path| [[:Category:Mscr:System|System]].[[:Category:Mscr:System.Types|Types]].[[Mscr:System.Types.Int8|Int8]]}}

An signed 8-bit integral numeric.

Capable of storing values between -128 and 127.

= Details =
<syntaxhighlight lang="cs">
struct System.Types.Int8 : Object
</syntaxhighlight>

{| class="wikitable"
| '''Aliased as: ''' || {{code|int8}}
|-
| '''Object Type:''' || {{code|struct}} (Copy by Value)
|-
| '''Inherits From: ''' || [[Mscr:System.Types.Object|System.Types.Object]]
|}

= Unary Operators =

=== operator- (Negate)===
<syntaxhighlight lang="cs">Int8 operator -(Int8 a)</syntaxhighlight>
Returns the negative value of the operand.

=== operator+ (Positive)===
<syntaxhighlight lang="cs">Int8 operator +(Int8 a)</syntaxhighlight>
Returns the same value as the operand. Mostly used for alignment with the '-' operator.

=== operator-- (Decrement)===
<syntaxhighlight lang="cs">Int8 operator --(Int8 a)</syntaxhighlight>
Decrements the value contained in the operand.
If used as a prefix, will return the decremented value.
If used as a postfix, will return the original value before decrementing.

=== operator++ (Increment)===
<syntaxhighlight lang="cs">Int8 operator ++(Int8 a)</syntaxhighlight>
Increments the value contained in the operand.
If used as a prefix, will return the incremented value.
If used as a postfix, will return the original value before incrementing.

=== operator! (Logical NOT) ===
<syntaxhighlight lang="cs">Int8 operator !(Int8 a)</syntaxhighlight>
Logical NOT operation. Will return `false` if the operand is zero, and `true` if the operand is non-zero.

=== operator~ (Bitwise NOT) ===
<syntaxhighlight lang="cs">Int8 operator ~(Int8 a)</syntaxhighlight>
Bitwise NOT operation. Will return the inverted bits of the supplied operand.

{{code|00100101b}} would become {{code|11011010b}}

= Binary Operators =

=== operator+ (Add)===
<syntaxhighlight lang="cs">Int8 operator +(Int8 a, Int8 b)</syntaxhighlight>
Adds the value of both operands and returns the result.

=== operator- (Subtract)===
<syntaxhighlight lang="cs">Int8 operator -(Int8 a, Int8 b)</syntaxhighlight>
Subtracts operand `b` from operand `a` and returns the result.

=== operator* (Multiply)===
<syntaxhighlight lang="cs">Int8 operator *(Int8 a, Int8 b)</syntaxhighlight>
Multiplies operand `a` by operand `b` and returns the result.

=== operator/ (Divide)===
<syntaxhighlight lang="cs">Int8 operator /(Int8 a, Int8 b)</syntaxhighlight>
Divides operand `a` by operand `b` and returns the result.
{{note|warning|Dividing an Int8 by 0 will throw an exception.}}

=== operator% (Modulo) ===
<syntaxhighlight lang="cs">Int8 operator %(Int8 a, Int8 b)</syntaxhighlight>
Performs a modulo operation on operand `a`, dividing it by operand `b` and returning the remainder.
{{note|warning|Dividing an Int8 by 0 will throw an exception.}}

=== operator<< (Shift Left) ===
<syntaxhighlight lang="cs">Int8 operator <<(Int8 a, Int8 b)</syntaxhighlight>
Shifts the value of operand `a` left by `b` bits

=== operator>> (Shift Right) ===
<syntaxhighlight lang="cs">Int8 operator >>(Int8 a, Int8 b)</syntaxhighlight>
Shifts the value of operand `a` right by `b` bits

=== operator& (Bitwise AND)===
<syntaxhighlight lang="cs">Int8 operator &(Int8 a, Int8 b)</syntaxhighlight>
Performs a bitwise AND operation between operand `a` and `b`, where the resulting value will only have bits set if the corresponding bits in both operands are 1.

Example: {{code|01010101b & 00001111b == 00000101b}}

=== operator| (Bitwise OR)===
<syntaxhighlight lang="cs">Int8 operator |(Int8 a, Int8 b)</syntaxhighlight>
Performs a bitwise OR operation between operand `a` and `b`, where the resulting value will have bits set if either of the corresponding bits in both operands are 1.

Example: {{code|01010101b | 00001111b == 01011111b}}

=== operator^ (Bitwise Xor)===
<syntaxhighlight lang="cs">Int8 operator ^(Int8 a, Int8 b)</syntaxhighlight>
Performs a bitwise OR operation between operand `a` and `b`, where the resulting value will have bits set if either of the corresponding bits in both operands are 1.

Example: {{code|01010101b | 00001111b == 01011111b}}

=== operator== (Equal)===
<syntaxhighlight lang="cs">bool operator ==(Int8 a, Int8 b)</syntaxhighlight>
Returns {{code|true}} if operand `a` is exactly equal to operand `b`.

=== operator!= (Not Equal)===
<syntaxhighlight lang="cs">bool operator !=(Int8 a, Int8 b)</syntaxhighlight>
Returns {{code|true}} if operand `a` is NOT equal to operand `b`.

=== operator< (Less than)===
<syntaxhighlight lang="cs">bool operator <(Int8 a, Int8 b)</syntaxhighlight>
Returns {{code|true}} if operand `a` is less than operand `b`.

=== operator<= (Less than or Equal)===
<syntaxhighlight lang="cs">bool operator <=(Int8 a, Int8 b)</syntaxhighlight>
Returns {{code|true}} if operand `a` is less than or equal to operand `b`.

=== operator> (Greater than)===
<syntaxhighlight lang="cs">bool operator >(Int8 a, Int8 b)</syntaxhighlight>
Returns {{code|true}} if operand `a` is greater than operand `b`.

=== operator>= (Greater than or Equal)===
<syntaxhighlight lang="cs">bool operator >=(Int8 a, Int8 b)</syntaxhighlight>
Returns {{code|true}} if operand `a` is greater than or equal to operand `b`.

= Casting =

=== Implicit casts ===
Implicit casts happen automatically, except in the case that a method argument is marked as {{code|explicit}}.
Lower cost casts have a higher automatic precedence in the case of method overload resolution.

{| class="wikitable"
|+
!Type
!Additional Info
!Cost
|-
|[[Mscr:System.Types.Bool|System.Types.Bool (bool)]]
|Casts to {{Code|text=false}} if zero, {{Code|text=true}} if nonzero || 10
|-
|[[Mscr:System.Types.Char|System.Types.Char (char)]]
|Casts to the corresponding character in the general ASCII set || 1
|-
|[[Mscr:System.Types.Int16|System.Types.Int16 (int16)]]
|Casts to an 16-bit integer, padding the top 8 bits with zero || 2
|-
|[[Mscr:System.Types.Int32|System.Types.Int32 (int32)]]
|Casts to an 32-bit integer, padding the top 24 bits with zero || 3
|-
|[[Mscr:System.Types.Int64|System.Types.Int64 (int64)]]
|Casts to a 64-bit integer, padding the top 56 bits with zero || 4
|-
|[[Mscr:System.Types.Float|System.Types.Float (float)]]
|Casts to 32-bit floating point number. || 1
|-
|[[Mscr:System.Types.Double|System.Types.Double (double)]]
|Casts to 64-bit floating point number. || 2
|}

=== Explicit casts ===
Explicit casts will NOT happen automatically, and must use either C-style casts ({{code|(int8)Value}}) or C#-style casts ({{code|Value as int8}}).

{| class="wikitable"
|+
!Type
!Additional Info
|-
|[[Mscr:System.Types.UInt8|System.Types.UInt8 (uint8)]]
|Casts to an unsigned 8-bit integer
Negative values will end up as large positives
|-
|[[Mscr:System.Types.UInt16|System.Types.UInt16 (uint16)]]
|Casts to an unsigned 16-bit integer, padding the top 8 bits with zero.
Negative values will end up as large positives
|-
|[[Mscr:System.Types.UInt32|System.Types.UInt32 (uint32)]]
|Casts to an unsigned 32-bit integer, padding the top 16 bits with zero.
Negative values will end up as large positives.
|-
|[[Mscr:System.Types.UInt64|System.Types.UInt64 (uint64)]]
|Casts to an unsigned 64-bit integer, padding the top 32 bits with zero. 
Negative values will end up as large positives.
|}