Unity C# 必須の演算子

Unity は、機能面で開発者向けに多くの "heavy-lifting" を実行し、開発プロセスに完全に集中できるようにするゲーム エンジンです。メインのプログラミング言語として C# を利用します。

他のプログラミング言語と同様、C# は特殊な関数、型、クラス、ライブラリなどの配列で構成されていますが、それぞれが独自の機能を持つ特殊な記号 (演算子) のリストもあります。この投稿では、次回スクリプトを開いたときに各部分の意味をすぐに理解できるように、これらの記号をリストし、その機能を説明します。

C# の演算子は、オペランドに対して何らかのアクションを実行する特殊なシンボルです。

C# には、算術演算子、比較演算子、ブール論理演算子、ビット単位およびシフト演算子、等価演算子、およびその他の演算子の 6 種類の組み込み演算子があります。これらをすべて理解すれば、すぐに優れたプログラマーになれるでしょう。

1. 算術演算子

次の演算子は、数値型のオペランドを使用して算術演算を実行します。

  • 単項 ++ (インクリメント)、-- (デクリメント)、+ (プラス)、および - (マイナス) 演算子
  • バイナリ * (乗算)、/ (除算)、% (剰余)、+ (加算)、および - (減算) 演算子

インクリメント演算子++

"add one" 演算子 (または ++) は += 1 を意味します。つまり、追加のコードを入力することなく、数値に 1 つの整数を加算する簡単な方法です。この演算子は値の前または後に追加できますが、その場合は動作が異なります。

//The result of x++ is the value of x before the operation, as the following example shows:
int i = 4;
Debug.Log(i);   // output: 4
Debug.Log(i++); // output: 4
Debug.Log(i);   // output: 5

//The result of ++x is the value of x after the operation, as the following example shows:
double a = 2.5;
Debug.Log(a);   // output: 2.5
Debug.Log(++a); // output: 3.5
Debug.Log(a);   // output: 3.5

デクリメント演算子 --

"subtract one" 演算子は ++ (-= 1) の逆で、数値から 1 つの整数を減算します。値の前後に追加することもできます。

The result of x-- is the value of x before the operation, as the following example shows:
int i = 4;
Debug.Log(i);   // output: 4
Debug.Log(i--); // output: 4
Debug.Log(i);   // output: 3

The result of --x is the value of x after the operation, as the following example shows:
double a = 2.5;
Debug.Log(a);   // output: 2.5
Debug.Log(--a); // output: 1.5
Debug.Log(a);   // output: 1.5

単項 + および - 演算子

単項 + 演算子はオペランドの値を返し、単項 - 演算子はオペランドの数値否定を計算します。

Debug.Log(+5);     // output: 5

Debug.Log(-5);     // output: -5
Debug.Log(-(-5));  // output: 5

uint a = 6;
var b = -a;
Debug.Log(b);            // output: -6
Debug.Log(b.GetType());  // output: System.Int64

Debug.Log(-double.NaN);  // output: NaN

乗算演算子 *

乗算演算子 * は、オペランドの乗算を計算します。

Debug.Log(6 * 3);         // output: 18
Debug.Log(1.5 * 3.5);     // output: 5.25
Debug.Log(0.1m * 24.4m);  // output: 2.44

除算演算子 /

除算演算子 / は、左側のオペランドを右側のオペランドで除算します。

オペランドの 1 つが 10 進数の場合、float も double も暗黙的に 10 進数に変換できないため、別のオペランドを float または double にすることはできません。float または double オペランドを 10 進数型に明示的に変換する必要があります。

Debug.Log(13 / 5);    // output: 2
Debug.Log(13 / 5.0);       // output: 2.6

int a = 13;
int b = 5;
Debug.Log((double)a / b);  // output: 2.6

Debug.Log(16.8f / 4.1f);   // output: 4.097561
Debug.Log(16.8d / 4.1d);   // output: 4.09756097560976
Debug.Log(16.8m / 4.1m);   // output: 4.0975609756097560975609756098

剰余演算子 %

剰余演算子 % は、左側のオペランドを右側のオペランドで除算した後の剰余を計算します。

  • 整数型のオペランドの場合、a % b の結果は、a - (a / b) * b によって生成される値です。
Debug.Log(5 % 4);   // output: 1
Debug.Log(5 % -4);  // output: 1
Debug.Log(-5 % 4);  // output: -1
Debug.Log(-5 % -4); // output: -1
  • 10 進オペランドの場合、剰余演算子 % は System.Decimal 型の剰余演算子と同等です。
Debug.Log(-5.2f % 2.0f); // output: -1.2
Debug.Log(5.9 % 3.1);    // output: 2.8
Debug.Log(5.9m % 3.1m);  // output: 2.8

加算演算子 +

加算演算子 + は、オペランドの合計を計算します。+ 演算子を文字列の連結とデリゲートの組み合わせに使用することもできます。

Debug.Log(6 + 5);       // output: 11
Debug.Log(6 + 5.3);     // output: 11.3
Debug.Log(6.1m + 5.2m); // output: 11.3

減算演算子 -

減算演算子 - 左側のオペランドから右側のオペランドを減算します。- 演算子を使用してデリゲートを削除することもできます。

Debug.Log(48 - 4);      // output: 44
Debug.Log(6 - 5.3);     // output: 0.7
Debug.Log(8.5m - 3.3m); // output: 5.2

2. 比較演算子

< (less than), > (greater than), <= (less than or equal), and >= (以上) 比較 (関係演算子とも呼ばれます) 演算子はオペランドを比較します。これらの演算子は、すべての整数および浮動小数点数値型でサポートされています。

「より小さい」演算子 <

< 演算子は、左側のオペランドが右側のオペランドより小さい場合は true を返し、それ以外の場合は false を返します。

Debug.Log(8.0 < 6.1);   // output: False
Debug.Log(6.1 < 6.1);   // output: False
Debug.Log(1.0 < 6.1);   // output: True

Debug.Log(double.NaN < 6.1);   // output: False
Debug.Log(double.NaN >= 6.1);  // output: False

大なり演算子 >

> 演算子は、左側のオペランドが右側のオペランドより大きい場合は true を返し、それ以外の場合は false を返します。

Debug.Log(8.0 > 6.1);   // output: True
Debug.Log(6.1 > 6.1);   // output: False
Debug.Log(1.0 > 6.1);   // output: False

Debug.Log(double.NaN > 6.1);   // output: False
Debug.Log(double.NaN <= 6.1);  // output: False

以下演算子 <=

<= 演算子は、左側のオペランドが右側のオペランド以下の場合は true を返し、それ以外の場合は false を返します。

Debug.Log(8.0 <= 6.1);   // output: False
Debug.Log(6.1 <= 6.1);   // output: True
Debug.Log(1.0 <= 6.1);   // output: True

Debug.Log(double.NaN > 6.1);   // output: False
Debug.Log(double.NaN <= 6.1);  // output: False

以上演算子 >=

>= 演算子は、左側のオペランドが右側のオペランド以上の場合は true を返し、それ以外の場合は false を返します。

Debug.Log(8.0 >= 6.1);   // output: True
Debug.Log(6.1 >= 6.1);   // output: True
Debug.Log(1.0 >= 6.1);   // output: False

Debug.Log(double.NaN < 6.1);   // output: False
Debug.Log(double.NaN >= 6.1);  // output: False

3. ブール論理演算子

次の演算子は、bool オペランドを使用して論理演算を実行します。

  • 単項！(論理否定) 演算子。
  • バイナリ & (論理積)、| (論理 OR) および ^ (論理排他的 OR) 演算子。これらの演算子は常に両方のオペランドを評価します。
  • バイナリ && (条件付き論理 AND) および || (条件付き論理 OR) 演算子。これらの演算子は、必要な場合にのみ右側のオペランドを評価します。

論理否定演算子 !

単項接頭辞 ! 演算子は、オペランドの論理否定を計算します。つまり、オペランドが false と評価された場合は true を生成し、オペランドが true と評価された場合は false を生成します。

bool passed = false;
Debug.Log(!passed);  // output: True
Debug.Log(!true);    // output: False

論理積演算子 &

& 演算子は、オペランドの論理 AND を計算します。x と y の両方が true と評価される場合、x & y の結果は true になります。それ以外の場合、結果は false になります。

& 演算子は、左側のオペランドが false と評価される場合でも両方のオペランドを評価するため、右側のオペランドの値に関係なく、演算結果は false になります。

bool SecondOperand()
{
    Debug.Log("Second operand is evaluated.");
    return true;
}

bool a = false & SecondOperand();
Debug.Log(a);
// Output:
// Second operand is evaluated.
// False

bool b = true & SecondOperand();
Debug.Log(b);
// Output:
// Second operand is evaluated.
// True

排他的論理和演算子 ^

^ 演算子は、オペランドの論理排他的 OR (論理 XOR とも呼ばれます) を計算します。x が true と評価され、y が false と評価される場合、または x が false と評価され、y が true と評価される場合、x ^ y の結果は true になります。それ以外の場合、結果は false になります。つまり、ブール オペランドの場合、^ 演算子は不等号演算子 != と同じ結果を計算します。

Debug.Log(true ^ true);    // output: False
Debug.Log(true ^ false);   // output: True
Debug.Log(false ^ true);   // output: True
Debug.Log(false ^ false);  // output: False

論理和演算子 |

| 演算子は、オペランドの論理和を計算します。x | の結果 x または y のいずれかが true と評価される場合、y は true になります。それ以外の場合、結果は false になります。

The | 演算子は、左側のオペランドが true と評価された場合でも両方のオペランドを評価するため、右側のオペランドの値に関係なく、演算結果は true になります。

bool SecondOperand()
{
    Debug.Log("Second operand is evaluated.");
    return true;
}

bool a = true | SecondOperand();
Debug.Log(a);
// Output:
// Second operand is evaluated.
// True

bool b = false | SecondOperand();
Debug.Log(b);
// Output:
// Second operand is evaluated.
// True

条件付き論理 AND 演算子 &&

条件付き論理 AND 演算子 && は、"short-circuiting" 論理 AND 演算子とも呼ばれ、オペランドの論理 AND を計算します。x && y の結果は、x と y の両方が true と評価される場合は true、そうでない場合は false になります。x が false と評価された場合、y は評価されません。

bool SecondOperand()
{
    Debug.Log("Second operand is evaluated.");
    return true;
}

bool a = false && SecondOperand();
Debug.Log(a);
// Output:
// False

bool b = true && SecondOperand();
Debug.Log(b);
// Output:
// Second operand is evaluated.
// True

条件付き論理 OR 演算子 ||

条件付き論理 OR 演算子 || は "short-circuiting" 論理 OR 演算子とも呼ばれ、オペランドの論理 OR を計算します。x の結果 || x または y のいずれかが true と評価された場合、y は true になります。それ以外の場合、結果は false になります。x が true と評価される場合、y は評価されません。

bool SecondOperand()
{
    Debug.Log("Second operand is evaluated.");
    return true;
}

bool a = true || SecondOperand();
Debug.Log(a);
// Output:
// True

bool b = false || SecondOperand();
Debug.Log(b);
// Output:
// Second operand is evaluated.
// True

4. ビット演算子とシフト演算子

次の演算子は、整数値型または char 型のオペランドを使用してビット単位の演算またはシフト演算を実行します。

  • 単項 ~ (ビット単位の補数) 演算子
  • バイナリ << (left shift) and >> (右シフト) シフト演算子
  • バイナリ & (論理積)、| (論理 OR) および ^ (論理排他的 OR) 演算子

ビット単位の補数演算子 ~

~ 演算子は、各ビットを反転してオペランドのビット単位の補数を生成します。

uint a = 0b_0000_1111_0000_1111_0000_1111_0000_1100;
uint b = ~a;
Debug.Log(Convert.ToString(b, toBase: 2));
// Output:
// 11110000111100001111000011110011

左シフト演算子 <<

<< 演算子は、左側のオペランドを右側のオペランドで定義されたビット数だけ左にシフトします。右側のオペランドがシフト数を定義する方法については、「シフト演算子のシフト数」セクションを参照してください。

uint x = 0b_1100_1001_0000_0000_0000_0000_0001_0001;
Debug.Log($"Before: {Convert.ToString(x, toBase: 2)}");

uint y = x << 4;
Debug.Log($"After:  {Convert.ToString(y, toBase: 2)}");
// Output:
// Before: 11001001000000000000000000010001
// After:  10010000000000000000000100010000

右シフト演算子 >>

>> 演算子は、左側のオペランドを右側のオペランドで定義されたビット数だけ右にシフトします。

uint x = 0b_1001;
Debug.Log($"Before: {Convert.ToString(x, toBase: 2), 4}");

uint y = x >> 2;
Debug.Log($"After:  {Convert.ToString(y, toBase: 2), 4}");
// Output:
// Before: 1001
// After:    10

上位の空ビット位置は、左側のオペランドのタイプに基づいて次のように設定されます。

  • 左側のオペランドの型が int または Long の場合、右シフト演算子は算術シフトを実行します。左側のオペランドの最上位ビット (符号ビット) の値が上位の空のビットに伝播されます。ポジション。つまり、上位の空のビット位置は、左側のオペランドが負でない場合は 0 に設定され、負の場合は 1 に設定されます。
int a = int.MinValue;
Debug.Log($"Before: {Convert.ToString(a, toBase: 2)}");

int b = a >> 3;
Debug.Log($"After:  {Convert.ToString(b, toBase: 2)}");
// Output:
// Before: 10000000000000000000000000000000
// After:  11110000000000000000000000000000
  • 左側のオペランドの型が uint または ulong の場合、右シフト演算子は論理シフトを実行します。つまり、上位の空のビット位置は常に 0 に設定されます。
uint c = 0b_1000_0000_0000_0000_0000_0000_0000_0000;
Debug.Log($"Before: {Convert.ToString(c, toBase: 2), 32}");

uint d = c >> 3;
Debug.Log($"After:  {Convert.ToString(d, toBase: 2), 32}");
// Output:
// Before: 10000000000000000000000000000000
// After:     10000000000000000000000000000

論理積演算子 &

& 演算子は、整数オペランドのビット単位の論理 AND を計算します。

uint a = 0b_1111_1000;
uint b = 0b_1001_1101;
uint c = a & b;
Debug.Log(Convert.ToString(c, toBase: 2));
// Output:
// 10011000

排他的論理和演算子 ^

^ 演算子は、その整数オペランドのビット単位の論理排他的 OR (ビット単位の論理 XOR とも呼ばれます) を計算します。

uint a = 0b_1111_1000;
uint b = 0b_0001_1100;
uint c = a ^ b;
Debug.Log(Convert.ToString(c, toBase: 2));
// Output:
// 11100100

論理和演算子 |

| 演算子は、その整数オペランドのビット単位の論理和を計算します。

uint a = 0b_1010_0000;
uint b = 0b_1001_0001;
uint c = a | b;
Debug.Log(Convert.ToString(c, toBase: 2));
// Output:
// 10110001

5. 等価演算子

== (等価) 演算子と != (不等価) 演算子は、オペランドが等しいかどうかをチェックします。

等価演算子 ==

等価演算子 == は、オペランドが等しい場合は true を返し、そうでない場合は false を返します。

int a = 1 + 2 + 3;
int b = 6;
Debug.Log(a == b);  // output: True

char c1 = 'a';
char c2 = 'A';
Debug.Log(c1 == c2);  // output: False
Debug.Log(c1 == char.ToLower(c2));  // output: True

不等演算子 !=

不等演算子 != は、オペランドが等しくない場合は true を返し、等しくない場合は false を返します。組み込み型のオペランドの場合、式 x != y は式 !(x == y) と同じ結果を生成します。

int a = 1 + 1 + 2 + 3;
int b = 6;
Debug.Log(a != b);  // output: True

string s1 = "Hello";
string s2 = "Hello";
Debug.Log(s1 != s2);  // output: False

object o1 = 2;
object o2 = 2;
Debug.Log(o1 != o2);  // output: True

6. その他の演算子

一般的なその他の演算子は、条件チェック用の ?:、エイリアスされた名前空間のメンバーにアクセスするための::、文字列補間用の $ です。

?: 演算子

条件演算子 ?: (三項条件演算子とも呼ばれます) は、次の例に示すように、ブール式を評価し、ブール式が true と評価されるか false と評価されるかに応じて、2 つの式のいずれかの結果を返します。

bool condition = true;
Debug.Log(condition ? 1 : 2); // output: 1

:: 演算子

別名が付けられた名前空間のメンバーにアクセスするには、名前空間別名修飾子:: を使用します。:: 修飾子は 2 つの識別子の間でのみ使用できます。左側の識別子には、次のエイリアスのいずれかを使用できます。

  • using alias ディレクティブを使用して作成された名前空間エイリアス:
using forwinforms = System.Drawing;
using forwpf = System.Windows;

public class Converters
{
    public static forwpf::Point Convert(forwinforms::Point point) => new forwpf::Point(point.X, point.Y);
}
  • 外部エイリアス。
  • グローバル エイリアス。グローバル名前空間のエイリアスです。グローバル名前空間は、名前空間内で宣言されていない名前空間と型を含む名前空間です。:: 修飾子とともに使用すると、ユーザー定義のグローバル名前空間エイリアスがある場合でも、グローバル エイリアスは常にグローバル名前空間を参照します。
namespace MyCompany.MyProduct.System
{
    class Program
    {
        static void Main() => global::System.Console.WriteLine("Using global alias");
    }

    class Console
    {
        string Suggestion => "Consider renaming this class";
    }
}

$演算子

$ 特殊文字は、文字列リテラルを補間文字列として識別します。補間文字列は、補間式を含む可能性のある文字列リテラルです。補間された文字列が結果文字列に解決されると、補間式を含む項目は式の結果の文字列表現に置き換えられます。

補間文字列では、ドル記号 ($) を使用して、それに続く文字列が補間文字列として解釈されることを C# コンパイラに指示します。中括弧は、テキストに含める (変数の) 値をカプセル化します。

文字列リテラルを補間文字列として識別するには、先頭に $ 記号を付けます。文字列リテラルを開始する $ と " の間に空白を入れることはできません。

string name = "John";
var date = DateTime.Now;
Debug.Log($"Hello, {name}! Today is {date.DayOfWeek}, it's {date:HH:mm} now.");
// Output:
// Hello, John! Today is Wednesday, it's 19:40 now.
UnityUnity3dCSharpプログラミングオペレーターマイクロソフトWindowsドットネット
おすすめの記事
関数とメソッド呼び出しを理解する
Unity C# スクリプト言語の概要
Unity コードでの基本的な算術演算の実装
Unity でより優れたプログラマーになる方法
Unity でインタラクティブなオブジェクトを作成する
Unity でのキネティック インタラクションの実装
Unity で特定のキーを使用して引き出しや食器棚を開ける
他の投稿 »
人気の記事
Unity ゲームの画面解像度を変更する方法
Unityで足音を実装する
Unity で UI ドラッグ アンド ドロップを使用した簡単な在庫システムをコーディングする
Unity コードでの例外処理とエラー処理
Unityでのインベントリとアイテム作成システムの作成
Unity でゲームを一時停止する方法
Unity でのキーボードとマウス入力の実装