LoginSignup
0
0

More than 5 years have passed since last update.

@h_okabe

演算子 (四週目の学習)

Last updated at Posted at 2018-10-12

モチベーションも大事だと思うので覚書として使用します。

三週目の感想
　四週目は、演算子というだけあって記号の意味・用法を中心に学習。
画像はエルビス演算子というジョーク…ですよね？可変が効いてるのでスペースでセンターに置いた。


　学習の方は&と&&の使い方に手こずった。
(&&の方が有能そうだが、変動的な場合は完全評価の&が吉)
最終的にif((ch>='a' && ch<='z') || (ch>='A' && ch<='Z'))
このような複雑な処理も出来る事が分かった。
ワンライナーなら有能なa?b:Cもif文という事がわかった。(ただしビット演算は苦手…)


とりあえず動くアプリ作りたいならJavaでもよかったかもしれない。
わざわざXamarinで全部作る必要があるか、1から似たソース参考に見て(この時点で他言語必要)
それでも何とか設計やライフサイクル学習しVisualStudio(Xamarin)とにらめっこして自分のC#に変換しつつ、
依存注入でiOSとAndroidに適用していく作業。

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


　　　　　　　　　　　　　　　

演算子Ⅰ

演算子 Operator

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

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)呼び出し
    }
}

・オーバーロード参考 引数異なる関数を複数定義できる(オーバーロード)上記コードのこと

・進数参考 0x0c=12 (0x=16進数、A~F=10~12、16進×0(=0x0) ＋c=12)
　　　　　 2進数がbit単位2進数は8桁(101は1より左00000を省略)

・ビット演算(bit演算)参考 bit は binary digitの略(=2進数の一桁) つまり0か1


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
論理演算子 ^　!　~　&　&&　|　||
シフト演算子 <<　>>

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

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

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

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

演算子Ⅱ

算術演算子 Arithmetic Operators

+　-　*　/　%　++　--

+-より*/優先、データ型より文字列型優先、数字同士は大きい型優先 
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)
    }

}

ｲﾝｸﾘﾒﾝﾄ/ﾃﾞｸﾘﾒﾝﾄ演算子 Increment/decrement operators

++　--

評価前後1加算減算 ++a(先代入)/a--(あとから代入) 

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

関係演算子、条件演算子 Relational Operators，Conditional Operators

==　!=　<　>　<=　>=　is　as

?a:bはワンライナー収まるならif文よりシンプル(諸説有)

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

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


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
    }
}


// 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();
        }
    }
}

is演算子の拡張[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格納
    (第二オペランドはここで宣言する新しい型の必要あり。以降よりスコープ発動)

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

論理演算子 Logical Operators

^　!　~　&　&&　|　||e

短絡評価。第一オペの時点でTrue OR Falseなら結果どうせ変わらないし第二オペランド評価する必要ない。
条件 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
||(左辺評価)ロード少なく済む


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

    }
}



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("#.##"));
    }
}



//?

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

int x = a 
      ? b 
      : 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;
    }            
}




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
    }
}

代入演算子 Assignment Operators

= *= /= %= += -= <<= >>= &= ^= |= &&=

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オペランドに移動

//<<=第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が捨てられた)

0
0
0

Register as a new user and use Qiita more conveniently

  1. You get articles that match your needs
  2. You can efficiently read back useful information
  3. You can use dark theme
What you can do with signing up
Sign upLogin
0
0