演算子 (四週目の学習)

<font color="limegreen">モチベーションも大事だと思うので覚書として使用します。
<details><summary><font color="DarkSlateBlue">三週目の感想</summary><div><font color="DarkSlateGray">　四週目は、演算子というだけあって記号の意味・用法を中心に学習。
画像はエルビス演算子というジョーク…ですよね？可変が効いてるのでスペースでセンターに置いた。

<br>　学習の方は`&`と`&&`の使い方に手こずった。
(&&の方が有能そうだが、変動的な場合は完全評価の&が吉)
最終的に`if((ch>='a' && ch<='z') || (ch>='A' && ch<='Z'))`
このような複雑な処理も出来る事が分かった。
ワンライナーなら有能な`a?b:C`もif文という事がわかった。(ただしビット演算は苦手…)
<br>
とりあえず動くアプリ作りたいならJavaでもよかったかもしれない。
わざわざXamarinで全部作る必要があるか、1から似たソース参考に見て(この時点で他言語必要)
それでも何とか設計やライフサイクル学習しVisualStudio(Xamarin)とにらめっこして自分のC#に変換しつつ、
依存注入でiOSとAndroidに適用していく作業。

一方、Javaなら作例は沢山あるから調べる時間短縮するし1つの言語なのでシンプル。
もしアプリを複数人で拡張するとしたらC#だと特殊だけど、Javaなら沢山いるだろう。
色々分かってきて悩む。逆にC#で良かったんだと思う時期も来るかもしれない…たぶん。
</font>
</details></div>








　　　　　　　　　　　　　　　<img src = https://img.devrant.com/devrant/rant/r_1778177_J4K6V.jpg width = 300 ％>






#<font color="SlateGray">演算子Ⅰ





##<font color="DimGray">演算子 Operator</font>

Operator (操作士、呪術師、演算子)、Operand  (演算項目)
演算子(=)やオペランド(a)が識別子(a)に影響を及ぼし値が評価される。
*/^(指数演算)等が先に評価される。


```c#
class Print
{
     public void maisu( int a )
    {
      //メソッド(1)の処理
    }

     public void maisu( char a )
    {
      //メソッド(2)の処理
    }

     public void maisu( int a , int b)
    {
      //メソッド(3)の処理
    }
}

class main_program
{
   public static void Main( ){
       Print pri = new Print( ); //オブジェクト作成
       pri.maisu( 5 ); //メソッド(1)呼び出し
       pri.maisu( 'a' ); //メソッド(2)呼び出し
       pri.maisu( 3 ,7 ); //メソッド(3)呼び出し
    }
}
```

・[オーバーロード参考](http://www.kisoplus.com/) 引数異なる関数を複数定義できる(オーバーロード)上記コードのこと

・[進数参考](http://ja0qon.my.coocan.jp/labo/pic_start/data/dec_hex_bin_conv.pdf) 0x0c=12 (0x=16進数、A~F=10~12、16進×0(=0x0) ＋c=12)
　　　　　 2進数がbit単位2進数は8桁(101は1より左00000を省略)

・[ビット演算(bit演算)参考](https://qiita.com/Ingward/items/43acda931c8a62c70d2f) bit は binary digitの略(=2進数の一桁) つまり0か1




```c#

namespace operate
{
    class Basic
    {
        public static void Main()
        {
            int a = 1;// operandなし (1と評価された)
            int b = a + 5;// operandあり (6と評価される)
            Console.WriteLine($"a={b-5}");// a=1
            Console.WriteLine($"a=1の値は{a}");// a=1の値は1 (と評価される)
        }
    }
}
```

| 名称 | 　　演算子　　 |
|:--|:--|
| 代入演算子 　　　　| =　+=　-=　*=　/=　%=　&= 　=^　 <<=　>>=　?? | 
| 算術演算子 | +　-　*　/　%　++　-- | 
| 連結演算子 | + (文字列連結string result = str1 + str2;)| 
| 比較演算子 | ==　!=　<　>　<=　>=　is　as | 
| 論理演算子 | ^　!　~　&　&&　&#124;　&#124;&#124;| 
| シフト演算子 | <<　>> | 

<b>特殊▶ドット演算子 プロパティ等のメンバ変数(この場合mx)にアクセスしようとすると、既に定義されてるエラー。既にNew演算子で定義しているとき、mx.a等としアクセス</b>

それぞれの意味
==	等しい
!=	等しくない
\>	より大きい
<	より小さい
\>=	以上
<=	以下

&&	かつ
||	または
!	否定（例　!ａは、ａでなければ）
&	論理積（例　1 & 1のみ、真）
|	論理和（例　1 | 0 、0 | 1、1 | 1ならば真）
^	排他的論理和（例　1^ 0 、0 ^ 1 ならば真）

is bool値返す。第二新しい型で第一から代入(varなら全True…何度も一時変数使える)、 equalsとしても使える
as      変換、キャストと違いnull返す。参照型のみ有効string、配列等。軽い
 

</details></div>




#<font color="SlateGray">演算子Ⅱ

##<font color="DimGray">算術演算子 Arithmetic Operators
<details><summary>+　-　*　/　%　++　--</summary><div>
<font color="crimson">+-より\*/優先、データ型より文字列型優先、数字同士は大きい型優先</font>

```c#
class OpeAdd
{
    public static void Main()
    {
        Console.WriteLine(3 + 6);// 9
        Console.WriteLine(3.0 + 6);// 9
        Console.WriteLine("3.5" + 6);// 3.56
        Console.WriteLine(3.5 + "6");// 3.56
        
        Console.WriteLine("(3.0+6)の型は{0}",(3.0+6).GetType());// (3.0+6)の型はSystem.Double
        Console.WriteLine("string 3.5+int 6の型は{0}",("3.5"+6).GetType());// string 3.5+int 6

        Console.WriteLine($"(3.0+6)の型は{(3.0 + 6).GetType()}");//文字列補間
        Console.WriteLine($"string 3.5+int 6の型は{("3.5" + 6).GetType()}");// 型はString
    }
}


class OpeDivision
{
    public static void Main()
    {
        Console.WriteLine($"10/3={10/3}");// 10/3=3 int/intなので小数点切捨(四捨五入ではない)で3と評価される
        Console.WriteLine($"10/3の型は{(10/3).GetType()}");// 10/3の型はSystem.Int32
        Console.WriteLine($"10/3.0={10/3.0}");// 3.333...int/doubleとなり評価も大きい方の型doubleで評価された
        Console.WriteLine($"10/3.0の型は{(10/3.0).GetType()}");//10/3.0の型はSystem.Double

        Console.WriteLine($"13.53%2={13.53%2}");// 13.53%2=1.53 %は余り(13.53÷2=6…1.53)
    }

}
```
</details></div>



##<font color="DimGray">ｲﾝｸﾘﾒﾝﾄ/ﾃﾞｸﾘﾒﾝﾄ演算子 Increment/decrement operators
<details><summary>++　--</summary><div>
<font color="crimson">評価前後1加算減算 ++a(先代入)/a--(あとから代入)</font>

```c#

char c1 = 'A';
c1++; // c1 is 'B' now
```

</details></div>



##<font color="DimGray">関係演算子、条件演算子 Relational Operators，Conditional Operators
<details><summary>==　!=　<　>　<=　>=　is　as</summary><div>
<font color="crimson">?a:bはワンライナー収まるならif文よりシンプル(諸説有)</font>

== 等しい
!= 否定か等しい
<=  以下 `if (number >= 1) timer = 10;` <と<=は第一第二オペ等しい場合もあればこっち
is 「オブジェクト is 型」でbool値返す(AがBと同じ型かTrue/False)。同じ型であればtrue、そうでなければ false
GetType()などがあるが、GetType()はオブジェクトがnullの場合使えないので、IS演算子の方を使ったほうがいい
equalsとしても使える


as キャストし、それが失敗した場合はnullを返す 軽いしnull返すし便利(但し参照型のみ)





```c#

class OpeConditional
{
    public static void Main()
    {
        int x = 10;
        int num = 4;
        x = (x > 5) ? num+1 : 0;
        Console.WriteLine(x);// 5

        int value = 100.ToString() == "100" ? 1 : -1;
        Console.WriteLine(value);// 1
    }
}
```





```c#

// IsAs

namespace isasoperators3
{
    class Student
    {
        public int stuNo { get; set; }
        public string Name { get; set; }
        public int Age { get; set; }

    }
    // Sample Employee Class
    class Employee
    {
        public int EmpNo { get; set; }
        public string Name { get; set; }
        public int Age { get; set; }
        public double Salary { get; set; }

    }
    class Program
    {

        static void Main(string[] args)
        {
            Student stuObj = new Student();
            stuObj.stuNo = 1;
            stuObj.Name = "Siva";
            stuObj.Age = 15;

            Employee EMPobj = new Employee();
            EMPobj.EmpNo = 20;
            EMPobj.Name = "Rajesh";
            EMPobj.Salary = 100000;
            EMPobj.Age = 25;

            // Is operator

            // Check Employee EMPobj is Student Type

            bool isStudent = (EMPobj is Student);
            // Student=(識別子EMPobjはNewインスタンスStudentと同じです)
            // 前者はユーザー定義型Employee属性、後者はユーザー定義型Student属性なので偽
            Console.WriteLine($"Empobj is a Student ?: {isStudent.ToString()}");// False
            //isStudent.ToString()で確認

            // Check Student stuObj is Student Typoe
            isStudent = (stuObj is Student);
            // Student=(識別子stiObjはNewインスタンスStudentと同じです)
            // 前者後者共にユーザー定義型Student属性なので真
            Console.WriteLine($"Stuobj is a Student ?: { isStudent.ToString()}");//True

            stuObj = null;
            // Check  null object Type
            isStudent = (stuObj is Student);
            // Student=(識別子stuObjはユーザー定義型Studentと同じです)
            // 前者後者共にユーザー定義型Student属性なので真
            // だが、stuObj=null;宣言によりnull(何にも属さない無効な値)になったので偽
            Console.WriteLine($"Stuobj(null) is a Student ?: {isStudent.ToString()}");
            Console.ReadLine();
        }
    }
}


```




<b>is演算子の拡張</b>[C#7]

1. 定数とのマッチング 従来 `if (object.Equals(o1, 123))` C#7 `if (o1 is 123)` isで比較可能


2. 型判定と同時にキャスト `if (o is string s)` 
(オペランドが同じ型なら)True返し第二オペランド(string s)にo格納
(第二オペランドは<b>ここで宣言する新しい型</b>の必要あり。以降よりスコープ発動)

3. 新しい変数に代入 上記、新しい型をvarにすると<b>常に同じ型となるのでtrue返し</b>第二オペランドに格納
   何度も一時変数使える。らしいけどまだ分からない範囲あるので後に理解
`if (DateTime.Today is var today
    && today.Day is 13 
    && today.DayOfWeek is DayOfWeek.Friday)
  WriteLine("今日は13日の金曜日です");`

</details></div>



##<font color="DimGray">論理演算子 Logical Operators
<details><summary>^　!　~　&　&&　|　||e</summary><div>
<font color="crimson">短絡評価。第一オペの時点でTrue OR Falseなら結果どうせ変わらないし第二オペランド評価する必要ない。</font>
条件 AND&&	左オペランドがfalseの場合、右オペランドは評価されません。
(Falseなら偽入った時点で真真にならないので左辺評価するだけ無駄で、逆にTrueなら第二段階として第二オペ評価する)
条件 OR||	左オペランドがtrueの場合、右オペランドは評価されません。
(どちらかでいいのでTrueならもうこの時点でクリアなので評価終了、逆にFalseなら第二段階として第二オペ評価する)
条件演算子?:	第1項がtrueなら第2項のみ、falseなら第3項のみが評価されます。
(x=a?b:c三項のうち一項がif条件式、二項が実行する式と同じ。三項はelseその他の実行する式)
null 合体演算子?? 左オペランドがfalseの場合、右オペランドは評価されません。

^(完全評価)1110 ^ 1010// 0100 異なる時true 読み方キャレット

~ビットごとの補数演算を実行し、各ビットを反転

!否定の値返す
 x = a ? b : c
 x ?? y  //xがNullならx返す、null以外ならy


&(完全評価)1110 & 1010// 0010 同じ時true 値変動的ならこっち
&&(左辺評価)どうせFalseなら評価せずFalse確定 ショートサーキット(短絡評価)
&と&&の違い(&&の方が有能そうだが、変動的な場合は完全評価の&が吉)

|(完全評価)1110 & 1010// 1110 どちらか同じ時true
||(左辺評価)ロード少なく済む



```c#

class XOR
{
    static void Main()
    {
        // Logical exclusive-OR

        // When one operand is true and the other is false, exclusive-OR 
        // returns True.
        Console.WriteLine(true ^ false);//True
        // When both operands are false, exclusive-OR returns False.
        Console.WriteLine(false ^ false);//False
        // When both operands are true, exclusive-OR returns False.
        Console.WriteLine(true ^ true);//False

    }
}

```

```c#

class ConvertToBinary
{
    static void Main()
    {
        int r = 50; // 2進数では 5=00000101
        Console.WriteLine(!true);// False
        Console.WriteLine(!false);// True

        Console.WriteLine((int)~r);// -51

        int number = 26, result;
        result = ~number;
        Console.WriteLine($"~{number} = {(long)result}");
        // ~26=-27 

        // ~はビットごとの補数演算を実行し、各ビットを反転
        // キャスト(byte8)ビットを反転 26→~00011010 = 11100101(2進数)←229(10進数)
        // キャスト(int64)ビットを反転 26→~00011010 = 11111111111111111111111111100110(2進数)←-26(10進数)
        // 補数表現     -(00011010 + 1) = -00011011 = -27
        // 2進数は2で割って出た余を1or0にしていき最後の除算1/2か1/1となって最終的に19は10011となる
        // メリット:ビット単位の演算は掛け算/除算より高速


        //値から進数、進数から文字列
        int num2 = System.Convert.ToInt32("0101", 2); // 2進数から10進数に変換(5)
        int num8 = System.Convert.ToInt32("222", 8); // 8進数から10進数に変換(146)
        int num16 = System.Convert.ToInt32("FF33", 16); //16進数から10進数に変換(65331)

        Console.WriteLine(num2.ToString("#.##"));// 文字変換して表示(小数点対応)
        Console.WriteLine(num8.ToString("#.##"));
        Console.WriteLine(num16.ToString("#.##"));
    }
}

```


```c#

//?

int x;
if (a)
  x = b;
else
  x = c;
//上記if文は下記と同じ

int x = a 
      ? b 
      : c;// 実際は長文の式

```



```c#

class OpeLogicalAnd
{
    static void Main()
    {
        // Each method displays a message and returns a Boolean value. 
        // Method1 returns false and Method2 returns true. When & is used,
        // both methods are called. 
        Console.WriteLine("Regular AND:");
        if (Method1() & Method2())
            Console.WriteLine("Both methods returned true.");
        else
            Console.WriteLine("At least one of the methods returned false.");

        // When && is used, after Method1 returns false, Method2 is 
        // not called.
        Console.WriteLine("\nShort-circuit AND:");
        if (Method1() && Method2())
            Console.WriteLine("Both methods returned true.");
        else
            Console.WriteLine("At least one of the methods returned false.");
    }

    static bool Method1()
    {
        Console.WriteLine("Method1 called.");
        return false;
    }

    static bool Method2()
    {
        Console.WriteLine("Method2 called.");
        return true;
    }            
}


```



```c#

class OpeLogical
{
    public static void Main(string[] args)
    {
        bool result;
        int firstNumber = 10, secondNumber = 20;

        // OR operator(|| または)
        result = (firstNumber == secondNumber) || (firstNumber > 5);
        Console.WriteLine(result);// True

        // AND operator{&& かつ}
        result = (firstNumber == secondNumber) && (firstNumber > 5);
        Console.WriteLine(result);// False
    }
}
```

</details></div>





##<font color="DimGray">代入演算子 Assignment Operators
<details><summary>=   *=   /=   %=   +=   -=   <<=   >>=   &=   ^=   |=  &&=</summary><div>

byte a＝10とint b、で違う型だった場合b=aで代入すると両方intなる(暗黙の型変換)

=　第1オペランドに第2オペランドの値を格納
+= 第2オペランドの値を足しその結果を第1オペランドに格納
-= 第2オペランドの値を引きその結果を第1オペランドに格納
*= 第2オペランドの値を掛けその結果を第1オペランドに格納
/= 第2オペランドの値で除算その結果を第1オペランドに格納
%= 第2オペランドの値で除算その余りを第1オペランドに格納


 
&= 第2オペランドの値で`AND`を`bit`単位で取得その結果を第1オペランドに格納
　　ステータス管理や乱数生成に使われる(ビットのクリアが可能となる)

^= 第2オペランドの値で`XOR`(排他的OR)を`bit`単位で取得その結果を第1オペランドに格納


|= 第2オペランドの値で`包括的OR`を`bit`単位で取得その結果を第1オペランドに格納

&&=移動代入演算子 第2オペランドの値でそのリソースを第1オペランドに移動



```c#
//<<=第2オペランドの値分左にシフトし、第1オペランドに格納
// \>>= 第2オペランドの値分右にシフトし、第1オペランドに格納
int a = 5;        // 二進数の 0000000000000101 (5)
 int b = a << 3;   // 二進数の 0000000000101000（左に3，十進数の40)
 int c = b >> 3;   // 二進数の 0000000000000101 (右に3，最初の値に戻った)
 int b = a << 14;  // 二進数の 0100000000000000 (左に14，1が捨てられた)
```


</details></div>