Unity C#の演算子の使い方をマスターしよう

→ Unity入門の森オリジナル本格ゲーム制作講座はこちら
11種類の本格ゲームの全ソースコード公開・画像＆動画による解説付き

今回の記事では演算子について解説していきます。

演算子は簡単に言うと、足し算、掛け算、引き算、割り算などを意味する記号ですね。

プログラミングする上ではこうした四則演算以外でも演算子を利用することがあります。

以前の記事の中でも既にいくつか使用されてるので、あまり難しく考えずいきましょう。

前回の記事：

Unity C# 変数と型の使い方　宣言や代入・型変換について

前回はコンパイルエラーとその対処法について解説しました。前回の記事：今回の記事ではC#の文法についてみていきましょう！プログラミングにおいて最重要な変数と型についてしっかり解説しています。型については、初心者さんはいきなり全部を理解...

今回の記事では値を計算する時に使用される演算子について見ていきます。

【Line登録者限定のプレゼントもあるよ！】

Unity C#スクリプトで計算を行う方法
1. Sample.Start()の中の+=演算子
2. Sample.Update()の中、*演算子と=演算子
演算子とは
演算子の優先順位
【実践】実際にそれぞれの演算子をUnityで使ってみよう
まとめ

Unity C#スクリプトで計算を行う方法

早速ですが、次のようなスクリプトファイルを書いてみましょう！。

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Sample : MonoBehaviour
{
    public float Value = 0.1f;
    public Color Color = Color.white;
    public MeshRenderer Mesh;

    // Start is called before the first frame update
    void Start()
    {
        // Colorの赤色を強くして、Meshに設定してみるコード
        var color = Color;
        color.r += 0.5f;
        Mesh.material.color = color;
    }

    // Update is called once per frame
    void Update()
    {
        //Valueの1/10の速さで移動させてみるコード
        var offset = Value * 0.1f;
        transform.position += new Vector3(offset, 0, 0);
    }
}

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public class Sample : MonoBehaviour

{

public float Value = 0.1f;

public Color Color = Color.white;

public MeshRenderer Mesh;

// Start is called before the first frame update

void Start()

{

// Colorの赤色を強くして、Meshに設定してみるコード

var color = Color;

color.r += 0.5f;

Mesh.material.color = color;

}

// Update is called once per frame

void Update()

{

//Valueの1/10の速さで移動させてみるコード

var offset = Value * 0.1f;

transform.position += new Vector3(offset, 0, 0);

}

今回注目してもらいたい部分は２箇所ありますので、順に見ていきましょう！

Sample.Start()の中の+=演算子

// Start is called before the first frame update
void Start()
{
    // Colorの赤色を強くして、Meshに設定してみるコード
    var color = Color;
    color.r += 0.5f;
    Mesh.material.color = color;
}

// Start is called before the first frame update

void Start()

{

// Colorの赤色を強くして、Meshに設定してみるコード

var color = Color;

color.r += 0.5f;

Mesh.material.color = color;

}

まずは、Smaple.Start()の中にあるMeshの色を設定している部分です。

今までのはSample.Colorの値をそのまま設定していましたが、今回のサンプルコードではSample.Color.rの値に0.5f足したものを設定しています。

color.r += 0.5f;

1	color.r += 0.5f;

上の+=が今回の記事で説明する演算子というものになり、+=はそれの右側にある値(右辺値)を左側にある変数(左辺値)に足し合わせる加算演算子になります。

「<左辺値> += <右辺値>」

左辺値、右辺値と少し難しい言葉が出てきましたが、プログラミングの専門用語としてよく使われるものになります。

言葉として説明すると難しく感じますが、単純に変数に値を足し合わせる時は+=を使うと覚えていただければ大丈夫です。

Sample.Update()の中、*演算子と=演算子

// Update is called once per frame
void Update()
{
    //Valueの1/10の速さで移動させてみるコード
    var offset = Value * 0.1f;
    transform.position += new Vector3(offset, 0, 0);
}

// Update is called once per frame

void Update()

{

//Valueの1/10の速さで移動させてみるコード

var offset = Value * 0.1f;

transform.position += new Vector3(offset, 0, 0);

}

次はSample.Update()の中にあるTransform.positionの値を変更している部分です。

こちらも以前のものはSample.Valueの値を使ってTransform.positionを変更していただけですが、今回のサンプルコードではSample.Valueの値に0.1を掛けたものを使っています。

var offset = Value * 0.1f;

1	var offset = Value * 0.1f;

上の*が演算子で、*は掛け算を表しています。*演算子は左辺値に右辺値を掛ける乗算演算子になります。

「<左辺値> * <右辺値>」

*演算子自体に変数を変更する機能はないので注意して下さい。

ですが、サンプルコードを実行するとしっかりTransform.positionの値が変更されてますが、これは=演算子のおかげになります。

=演算子自体は以前の記事にも出てきました。代入演算子と呼びます。

使い方はこれまで見てきた中でなんとなくわかるかと思いますが、左辺値に右辺値を設定(代入)する演算子です。

「<左辺値> = <右辺値>」

といった形で使います。

演算子とは

ここまで上のサンプルコードの中で使われている演算子について見てきました。

演算子は値に対する操作を表しており、次のものがC#では用意されています。

代入演算子
算術演算子
比較演算子
論理演算子
条件演算子

演算子は基本的に次の形式をとります。

単項演算子 -> 「<演算子> <値>」
２項演算子 -> 「<左辺値> <演算子> <右辺値>」

代入演算子

代入演算子はその名の通り、代入を行う演算子になります。ここまで何度も使われている演算子です。

代入演算子は２項演算子の形をとります。「<左辺値> = <右辺値>」

int a = 10; // 変数aに値10を代入している。
string s = "ABC"; // 変数sに文字列"ABC"を代入している

int b = a; // 変数bにaを代入している。bにはaと同じ値が設定される。
s = a; // <- NG sとaの型が異なるためこの代入はC#では禁じられている。

//凝った書き方の例 (演算子の優先順位が関係している)
int c = a = b; // 変数aに変数bを代入した後に変数cに変数aの値を代入している。
//上のコードは次のコードと同じ意味になる
a = b;
int c = a;

int a = 10; // 変数aに値10を代入している。

string s = "ABC"; // 変数sに文字列"ABC"を代入している

int b = a; // 変数bにaを代入している。bにはaと同じ値が設定される。

s = a; // <- NG sとaの型が異なるためこの代入はC#では禁じられている。

//凝った書き方の例 (演算子の優先順位が関係している)

int c = a = b; // 変数aに変数bを代入した後に変数cに変数aの値を代入している。

//上のコードは次のコードと同じ意味になる

a = b;

int c = a;

上のサンプルコードの変数の値を出力したもの

算術演算子

算術演算子はその名の通り、四則演算を行うための演算子になります。

基本的には算数で習ったものと同じ使い方になります。

単項演算子

以下の算術演算子は単項演算子の形をとります。「<演算子> <値>」

これらは値に対して単純に数値の正負の指定するものになります。

+：+符号。数を正の数として明記する。
-：-符号。数を負の数として明記する。

int a = +1; // <- aは1になる。
int b = -2; // <- bは-2になる
int c = +1 + (-2); // <- cは-1になる。
int d = -a - (-b); // <- 変数にも使える。-(+1) - (-(-2))となり、dは-3になる。

int a = +1; // <- aは1になる。

int b = -2; // <- bは-2になる

int c = +1 + (-2); // <- cは-1になる。

int d = -a - (-b); // <- 変数にも使える。-(+1) - (-(-2))となり、dは-3になる。

上のサンプルコード内の変数の値を表示して見たもの

インクリメントとデクリメント

プログラミング特有の演算子としてインクリメントとデクリメントという操作があります。これらは対象の値の数を+1、-1する演算子になり、それらを省略した書き方になります。

++：インクリメント(increment)。対象の値の数を+1する。
--：デクリメント(decrement)。対象の値の数を-1とする。

また、これらの演算子には前置と後置の２通りの書き方があります。

前置：値の前に書く書き方。「++ <値>」、「-- <値>」。他の演算が行われる前に値が変更される。
後置：値の後に書く書き方。「<値> ++」、「<値> --」。他の演算が行われた後に値が変更される。

インクリメントはまだ解説していませんがループ処理などでよく利用されます。

int a = 1;
//前置の書き方
int b = ++a; // <- 先にaが2になった後に、bが2になる。
int c = --a; // <- 先にaが1になった後に、cが1になる。

//後置の書き方
int A = 1;
int B = A++; // <- Bが1になった後に、Aが2になる。
int C = A--; // <- Cが2になった後に、Aが1になる。

int a = 1;

//前置の書き方

int b = ++a; // <- 先にaが2になった後に、bが2になる。

int c = --a; // <- 先にaが1になった後に、cが1になる。

//後置の書き方

int A = 1;

int B = A++; // <- Bが1になった後に、Aが2になる。

int C = A--; // <- Cが2になった後に、Aが1になる。

上のサンプルコードの変数の値を表示したもの

２項演算子

以下の算術演算子は２項演算子の形をとります。「<左辺値> <演算子> <右辺値>」

専門用語だと難しく感じますが、これらは算数の四則演算と同じになりますので安心してください。

+：足し算。
-：引き算。
*：掛け算。XはアルファベットのXと被るため、*(アスタリスク)が使われています。
/：割り算。
%：あまり算。割ったものの余りが演算結果として使われます。

また、演算子の後に=がつくものも用意されています。こちらは代入演算子と組み合わさったものとなり、左辺値と右辺値を演算した結果を左辺値に代入するものになります。

+=：足し算。
-=：引き算。
*=：掛け算。Xではなく*(アスタリスク)が使われています。
/=：割り算。
%=：あまり算。割ったものの余りが演算結果として使われます。

int a = 1 + 1; // 足し算。aは２になる
int b = 2 - 1; // 引き算。bは１になる
int c = 3 * 3; // 掛け算。cは9になる
int d = 8 / 2; // 割り算。dは４になる。
int e = 12 % 10; // 余り算。eは2になる。

//代入演算子と組み合わせたもの
a += 10; // <- a = a + 10と同じ意味になる。
a -= 10; // <- a = a - 10と同じ意味になる。
a *= 10; // <- a = a * 10と同じ意味になる。
a /= 10; // <- a = a / 10と同じ意味になる。
a %= 10; // <- a = a % 10と同じ意味になる。

int a = 1 + 1; // 足し算。aは２になる

int b = 2 - 1; // 引き算。bは１になる

int c = 3 * 3; // 掛け算。cは9になる

int d = 8 / 2; // 割り算。dは４になる。

int e = 12 % 10; // 余り算。eは2になる。

//代入演算子と組み合わせたもの

a += 10; // <- a = a + 10と同じ意味になる。

a -= 10; // <- a = a - 10と同じ意味になる。

a *= 10; // <- a = a * 10と同じ意味になる。

a /= 10; // <- a = a / 10と同じ意味になる。

a %= 10; // <- a = a % 10と同じ意味になる。

上のサンプルコードの変数の値を表示したもの。(代入演算子のものは省いています)

使い方はとても簡単です。

しかし、以下の問題が発生するとバグの原因になるので注意してください。

値の桁あふれ
0除算
整数型と浮動小数点型を組み合わせた計算

計算結果がおかしい場合は上記を疑ってみてください。それぞれ説明します。

値の桁あふれ(オーバーフロー)について

値の桁あふれ(オーバーフロー)とは計算の結果、使用している型の値の範囲を超えてしまった時に発生するプログラミング特有の計算に関する問題になります。

特に整数型において発生しやすいです。

以前の記事で型について説明した時、数値には使用する型によって値の範囲が決められていると説明しました。
値の桁あふれはこのことが原因で発生する問題で、注意しないと正しい計算結果が得られなかったり、思わぬバグの原因となります。

桁あふれが発生した時は、C#側で自動的に使用している型の値の範囲に収まるように数値を変更します。

また、整数型の時に桁あふれが発生したことを知らせてほしい場合はcheckedキーワードとuncheckedキーワードというC#の機能を使用してください。
これらのキーワードを使用することで、System.OverflowExceptionという例外が発生し、桁あふれに対する処理をプログラミングすることができます。

例外処理に関しては講座の別記事で扱います。簡単に言うと、予想外な処理が行われた時にそれを知らせるためのものになります。

浮動小数点型で桁あふれが発生した場合は例外は発生しません。その代わりにfloat.Infinity など不明な値と表現されます。この値を含んだ計算は全てfloat.Infinityなどになり、意味のない計算になってしまうので注意してください。

浮動小数点型の意味のない値の一覧

Infinity：無限大を表す。 float.IsInfinity()メソッドなどで判定できる。
Nan：値ではないことを表す。float.IsNan()メソッドなどで判定できる。

※以下で使われる例外についてはまだ解説していません。

//公式ドキュメントから抜粋しています。
int a = int.MaxValue;
int b = 3;

//checked,uncheckedを指定していない時はuncheckedを指定している状態になります。
//なので、uncheckedは特に書く必要はありません。
Console.WriteLine(unchecked(a + b));  // output: -2147483646

//例外が発生するかもしれない部分には下のように
//  try {...} catch(発生するであろう例外の型) {...}
// と書く
try
{
    // checkedキーワードを使用することで、
    // a + bで桁あふれが発生したら例外が発生するようになる。
    int d = checked(a + b);
}
catch(OverflowException)
{
    UnityEngine.Debug.Log($"Overflow occurred when adding {a} to {b}.");
}

//公式ドキュメントから抜粋しています。

int a = int.MaxValue;

int b = 3;

//checked,uncheckedを指定していない時はuncheckedを指定している状態になります。

//なので、uncheckedは特に書く必要はありません。

Console.WriteLine(unchecked(a + b)); // output: -2147483646

//例外が発生するかもしれない部分には下のように

// try {...} catch(発生するであろう例外の型) {...}

// と書く

try

{

// checkedキーワードを使用することで、

// a + bで桁あふれが発生したら例外が発生するようになる。

int d = checked(a + b);

}

catch(OverflowException)

{

UnityEngine.Debug.Log($"Overflow occurred when adding {a} to {b}.");

}

0除算について

C#では整数型の計算の中で０除算が発生した時は System.DivideByZeroException という例外が発生します。

浮動小数点型の場合は、例外が発生しませんが、上で説明した不明な値を返します。

整数型と浮動小数点を組み合わせた計算の時の注意点

値を表現する型には整数型と浮動小数点型と異なるものがあると以前説明しましたが、これらを組み合わせて計算する時、型変換時に小数部分が切り捨てられ、その結果意図した計算結果とは異なるものになってしまうことがあります。

一般的に整数型から浮動小数点型へ変換した時は整数型の値そのままが実数に変換されます。

が、浮動小数点型から整数型に変換した時は、小数点以下の値は切り捨てられて整数型に変換されます。

そのような変換を望まない場合は全ての計算を浮動小数点型で行うか、四捨五入を行う処理を挟むか、C#の標準ライブラリであるSystem.Math.Floor()かSystem.Math.Ceiling()などのメソッドを利用してください。

int integer = 1.23f // <- 1が代入される

//System.Math.Floorは入力された値より小さい整数の中で一番大きいものを返してくれるメソッド
float a = System.Math.Floor(1.23f); // <- a == 1f

//System.Math.Ceilingは入力された値より大きい整数の中で一番小さいものを返してくれるメソッド
float b = System.Math.Ceiling(1.23f); // <- a == 2f

//四捨五入する時は以下のように+0.5、-0.5するといい
float c = System.Math.Floor(a + 0.5f);
float d = System.Math.Ceiling(a - 0.5f);

int integer = 1.23f // <- 1が代入される

//System.Math.Floorは入力された値より小さい整数の中で一番大きいものを返してくれるメソッド

float a = System.Math.Floor(1.23f); // <- a == 1f

//System.Math.Ceilingは入力された値より大きい整数の中で一番小さいものを返してくれるメソッド

float b = System.Math.Ceiling(1.23f); // <- a == 2f

//四捨五入する時は以下のように+0.5、-0.5するといい

float c = System.Math.Floor(a + 0.5f);

float d = System.Math.Ceiling(a - 0.5f);

比較演算子

比較演算子は二つの値の大小を判定したり、同じ値かどうかを比較するための演算子になります。

比較演算子は２項演算子の形をとります。「<左辺値> <演算子> <右辺値>」

比較演算子の演算結果はbool型になり、演算子の内容と同じならtrue、異なるならfalseが返されます。

数学との違いとして、C#では「0 <= a <= 100」というようには一度に3つ以上の値を比較することはできません。

「0 <= a && a <= 100」と論理演算子を使用して、必ず2つずつ比較するようにしてください。(プログラミング言語によってはできるものも存在しています。)

==：同じ値か？
!=：異なる値か？
<：左辺値の方が右辺値より小さいか？
>：左辺値の方が右辺値より大きいか？
<=：左辺値の方が右辺値より小さい、もしくは同じか？
>=：左辺値の方が右辺値より大きい、もしくは同じか？

//同値判定
bool e1 = 1 == 1; // <- true
bool e2 = 1 != 2; // <- true
bool e3 = 1 == 2; // <- false
bool e4 = 1 != 1; // <- false

// '<' 左辺値が右辺値より小さい時にtrueになる
// '>' 左辺値が右辺値より大きい時にtrueになる
bool b1 = 1 < 2; // <- true
bool b2 = 1 > 2; // <- false

// '<=' '>=' だと同じ値でもtrueになる
bool b3 = 1 <= 1; // <- true
bool b4 = 1 < 1; // <- false

bool b5 = 1 >= 1; // <- true
bool b6 = 1 > 1; // <- false

int a = 10;
bool B1 = 1 < a < 100; // <- NG このような書き方はできない
//上のコードは次のコードと同じになる。
bool tmp1 = a < 100;
bool B2 = 1 < tmp1; // <- コンパイルエラー int型とbool型の比較になってしまう。

//同値判定

bool e1 = 1 == 1; // <- true

bool e2 = 1 != 2; // <- true

bool e3 = 1 == 2; // <- false

bool e4 = 1 != 1; // <- false

// '<' 左辺値が右辺値より小さい時にtrueになる

// '>' 左辺値が右辺値より大きい時にtrueになる

bool b1 = 1 < 2; // <- true

bool b2 = 1 > 2; // <- false

// '<=' '>=' だと同じ値でもtrueになる

bool b3 = 1 <= 1; // <- true

bool b4 = 1 < 1; // <- false

bool b5 = 1 >= 1; // <- true

bool b6 = 1 > 1; // <- false

int a = 10;

bool B1 = 1 < a < 100; // <- NG このような書き方はできない

//上のコードは次のコードと同じになる。

bool tmp1 = a < 100;

bool B2 = 1 < tmp1; // <- コンパイルエラー int型とbool型の比較になってしまう。

上のサンプルコードの変数の値を表示したもの。コンパイルエラーになるものは省いています。

比較演算子には次の使用上の注意点がありますので、そちらについても簡単に説明していきます。

浮動小数点型の同値判定(==, !==)

実は浮動小数点型の同値判定は一般的にはあまり意味のない判定になります。

なぜなら浮動小数点型の計算では必ず誤差が生じるため、大体似通った値は取ることは保証できるのですが完全に一致することは滅多にありません。(もちろん、全く同じ計算を全て同じ順序で行った時は同じ値になります。)

そのため浮動小数点型では有効桁数という計算中でこの桁までなら誤差を含まない範囲を設け、その桁の範囲までが一致しているなら同じ値だと判定することが一般的です。

有効桁数は作っているアプリによって決めてください。float型だと大体小数点2桁ぐらいが信頼できる値になりますが、それも計算対象によってまちまちです。

// 浮動小数点型の計算を行うと、微妙に異なる値になってしまうことが大半。
float a = 0.1f;
float b = 0.100001f;
bool isSame = a == b; // <- false

// 有効桁数４桁にした時の同値処理。
// epsilonの値を変更すると有効桁数を変えることができます。
float epsilon = 1e-4f; // <- 0.0001f 以下の値は判定には含まない
bool isSame2 = System.Math.Abs(a - b) <= epsilon; // <- true

// 浮動小数点型の計算を行うと、微妙に異なる値になってしまうことが大半。

float a = 0.1f;

float b = 0.100001f;

bool isSame = a == b; // <- false

// 有効桁数４桁にした時の同値処理。

// epsilonの値を変更すると有効桁数を変えることができます。

float epsilon = 1e-4f; // <- 0.0001f 以下の値は判定には含まない

bool isSame2 = System.Math.Abs(a - b) <= epsilon; // <- true

実際のアプリ開発では有効桁数の同値判定処理はメソッドとしてまとめると便利でしょう。

参照型の同値判定

参照型に==演算子を使用すると、両方とも同じデータを参照している時のみ同じ値だと判定します。

これは、参照型の中身が

どのデータを指し示しているか(アドレス)
指し示しているデータ本体

の二つに分かれているためです。

参照型が指し示しているデータの内容までも一致しているかどうかを判定するためには、System.Object.Equals()メソッドを再定義(オーバーライド、override)して、こちらから同値判定処理を書く必要があります。

メソッドの再定義(オーバーライド)はC#のクラスの継承の機能の一つになりますので、詳しくは別の章で解説します。

UnityC# クラスの継承・抽象メソッドとオーバライド is, as, null, this, baseの使い方も解説

今回の記事ではクラスの継承についてみていきます。 Unityではコンポーネント自体がUnityEngine.MoneBehaviourを継承したものなので実は既に使用している機能になります。さらにUnityEngine.MonoBehav...

論理演算子

論理演算子はbool型の値に対する演算子になり、その計算結果はbool型になります。(bool型はtrueかfalseの２種類のどちらかを取る値になります。)

論理演算子は単項演算子の形(「<演算子> <値>」)をとるものと２項演算子の形(「<左辺値> <演算子> <右辺値>」)をとるものがあります。

論理演算子はbool型の値を変更したり、複数のbool型の値を組み合わせて新しいbool型を作る時に使われるため、一般的に条件文の中で使われます。

単行演算子の形を取る論理演算子

!：演算対象を反転する。trueならfalseに、falseならtrueになる。

２項演算子の形をとる論理演算子

&&、&：論理積。左辺値と右辺値の両方がtrueならtrueを、そうでないならfalseを返す。
||、|：論理和。左辺値と右辺値の両方または片方がtrueならtrueを、両方ともfalseならfalseを返す。
^：排他的論理和。左辺値と右辺値が異なる時はtrue、両方とも同じ値の時はfalseを返す。

&、|、^はビット演算子でも使用されています。

bool b1 = true;
bool b2 = false;

//!演算子
bool B1 = !b1; // <- B1 == false
bool B2 = !B1; // <- B2 == true

// &&, &演算子
bool A1 = b1 && b2; // <- A1 == false
bool A2 = true & true; // <- A2 == true

// ||, |演算子
bool O1 = b1 || b2; // <- O1 == true
bool O2 = false | false; // <- O2 == false

// ^演算子
bool E1 = b1 ^ b2; // <- E1 == true
bool E2 = true ^ true; // <- E2 == false

bool b1 = true;

bool b2 = false;

//!演算子

bool B1 = !b1; // <- B1 == false

bool B2 = !B1; // <- B2 == true

// &&, &演算子

bool A1 = b1 && b2; // <- A1 == false

bool A2 = true & true; // <- A2 == true

// ||, |演算子

bool O1 = b1 || b2; // <- O1 == true

bool O2 = false | false; // <- O2 == false

// ^演算子

bool E1 = b1 ^ b2; // <- E1 == true

bool E2 = true ^ true; // <- E2 == false

上のサンプルコードの変数の値を表示したもの。

ビット演算子 (少々上級者向け)

ビット演算子はビット演算という整数型に対する演算子になり、特にuint、ulongなどの符号無し整数型に対して使われます。

ビット演算子を用いた計算結果は先にあげた型(uint、ulong)だとその型に、それ以外の整数型だと基本的にint型になります。

ビット演算子には単項演算子の形(「<演算子> <値>」)をとるものと２項演算子の形(「<左辺値> <演算子> <右辺値>」)をとるものがあります。

また、ビット演算は整数型の値をコンピュータ寄りに解釈した時の演算になり、その演算はコンピュータの命令そのままを表すことが多い、低レベルな演算になります。

コンピュータでは全ての値を0と1の表す2進数として表現されています。そのためコンピュータ寄りの演算であるビット演算では整数型の値を2進数や16進数で表現されることが多いです。(2進数と16進数については下の方で補足しています。)

ビット演算はフラグ処理やアプリの実行速度を上げるためのコードの最適化にも使われます。

ただし、コードの最適化に関しましては現在ではコンパイラーによって行われることが多いため、その目的ではあまり使うことはお勧めしません。1900年代の古いコードを読むことがあった時、その中で使われているのを見ることがあるかもしれません。

また、ビット演算でも桁あふれが発生しますのでこちらでもcheckedキーワードを使用できます。

2進数と16真数について補足

以前の記事で解説しましたが、簡単な補足として、2進数は0と1だけで、16進数は0~9,A-Fの16個の文字で数値を表す書き方になります。

コード上での書き方は以下のものになります。

2進数：数値を0b、0Bから始じめ、0と1だけで表現する。_を挟むことができる。例： 0b0011、0B1100_1010

16進数：数値を0x、0Xから始め、0-9、a-f(またはA-F)だけで表現する。例：0x19af、0XFFFF9a4c

単行演算子の形を取る論理演算子

~：全てのビットを反転する。0b0101なら0b1010に、b1100なら0b0011になる。

２項演算子の形をとる論理演算子

&、&=：論理積。全ての同じ桁の値を比べ、両方の桁が1ならその桁を1に、そうではないなら0にする。
|、|=：論理和。全ての同じ桁の値を比べ、片方の桁に1を含んでいたらその桁を1に、そうではないなら0にする。
^、^=：排他的論理和。全ての同じ桁の値を比べ、両方の桁の値が異なるならその桁を1に、そうではないなら0にする。
<<、<<=：左シフト演算。ビットを右辺値の数分、左にずらす。* (2^n)と同じ意味合いになる。
>>、>>=：右シフト演算。ビットを右辺値の数分、右にずらす。/ (2^n)と同じ意味合いになる。

&、|、^は論理演算子でも使用されています。

<<と>>はシフト演算と呼ばれるものです。

シフト演算は値の中の桁をずらす操作になりますので、ずらした結果元々の値にあった桁が消えたり、新しい桁が生じることもあります。この際他の演算との整合性を保つため、新しく生じた桁には左シフトなら0が、右シフトなら1が生じます。

//uint型のサイズは32ビットなので32桁ある
uint n = 0b0000_0011_1100_1111;

//'~' ビット反転
uint b1 = ~n; // <- e1 == 0b1111_1111_1111_1111_1111_1100_0011_0000;

//`&` 論理積
uint a1 = 0b0000_0011_1100_1111;
uint a2 = 0b0000_0000_1100_1111;
uint A1 = a1 & a2; // <- A1 == 0b0000_0000_1100_1111;

//`|` 論理和
uint o1 = 0b0000_0011_1100_1111;
uint o2 = 0b0000_0000_1100_1111;
uint O1 = o1 & o2; // <- O1 == 0b0000_0011_1100_1111;

//`^` 排他的論理和
uint e1 = 0b0000_0011_1100_1111;
uint e2 = 0b0000_0000_1100_1111;
uint E1 = e1 ^ e2; // <- E1 == 0b0000_0011_0000_0000;

// <<, >> シフト演算
uint s1 = 0b0000_0011_1100_1111 << 4; // <- s1 == 0b0011_1100_1111_0000;
uint s2 = 0b0000_0011_1100_1111 >> 4; // <- s2 == 0b0000_0000_0011_1100;

//uint型のサイズは32ビットなので32桁ある

uint n = 0b0000_0011_1100_1111;

//'~' ビット反転

uint b1 = ~n; // <- e1 == 0b1111_1111_1111_1111_1111_1100_0011_0000;

//`&` 論理積

uint a1 = 0b0000_0011_1100_1111;

uint a2 = 0b0000_0000_1100_1111;

uint A1 = a1 & a2; // <- A1 == 0b0000_0000_1100_1111;

//`|` 論理和

uint o1 = 0b0000_0011_1100_1111;

uint o2 = 0b0000_0000_1100_1111;

uint O1 = o1 & o2; // <- O1 == 0b0000_0011_1100_1111;

//`^` 排他的論理和

uint e1 = 0b0000_0011_1100_1111;

uint e2 = 0b0000_0000_1100_1111;

uint E1 = e1 ^ e2; // <- E1 == 0b0000_0011_0000_0000;

// <<, >> シフト演算

uint s1 = 0b0000_0011_1100_1111 << 4; // <- s1 == 0b0011_1100_1111_0000;

uint s2 = 0b0000_0011_1100_1111 >> 4; // <- s2 == 0b0000_0000_0011_1100;

上のサンプルコードの変数の値を表示したもの。2進数ではなく16進数表記で出力しています。

演算子の優先順位

ここまで演算子について一つ一つ見てきました。ですが、実際のプログラミングでは色々な演算子を組み合わせて使用することが普通です。

コンピュータでは一度に複数の演算を行うことは基本的(※)にできません。そのため、一つの式の中にある演算子をどの順序で使用するかはコンパイラーによって決定されます。

その際、各演算子には優先順位というものが設定されており、優先順位が高い方から計算されます。優先順位が同じものが続く場合はコンパイラーによって自動的に決定されます。

もし、先に演算したいものがある場合はそれらを()で括ってください。そうすることで括弧の中の演算が先に計算されます。

※コンピュータの中には複数の演算を同時行えるように設計されたものも存在しますが、スマートフォンなど市販されているコンピュータはできないものが大半です。

演算子の優先順位の一覧

++、--、!、~
*、/、%
+、-
<<、>>
<、>、<=、>=
==、!=
&
^
|
&&
||
=、その他の代入を含める演算子(+=や<<=など)

なお、ここであげた演算子以外にも演算子があります。それらにも優先順位があります。

が、自然に使うことができるように優先順位が決定されているので、あまり意識せずにプログラミングしていけるでしょう。

【実践】実際にそれぞれの演算子をUnityで使ってみよう

ここまでで、色々な演算子、およびその優先順位について見てきました。

一度に覚える必要はありませんが、スクリプトの内容を読んで「この部分は演算子を使っている」となんとなくわかるようになればOKです。

それではちょっとした力試しで下のコードから演算子を使っている部分を見つけてみましょう！

サンプルコード自体には深い意味はないので、軽くコードを読む練習にでも使ってください。

既に書かれたコードが読めるようになることはとても重要なプログラマーのスキルになるので頑張って読んでみてください！

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Sample : MonoBehaviour
{
    public float Value = 0.1f;
    public Color Color = Color.white;
    public MeshRenderer Mesh = null;

    // Start is called before the first frame update
    void Start()
    {
        var c = Color;
        c.r = c.r * 0.5f + Value / 10f;
        c.g += (c.g * Value) + 1f - c.a;
        c.b /= 2f;
        Mesh.material.color = c;
    }

    // Update is called once per frame
    void Update()
    {
        var offset = Vector3.zero;
        offset.x = Value;
        offset.y += Value / 10f;
        offset.z = (offset.x + offset.y) * 0.1f;
        transform.position += offset;
    }
}