C#私的超入門#1

この記事は筆者のメモである。
主に以下のサイトを参考にC#をVisualStudioで学習する。

C# によるプログラミング入門
http://ufcpp.net/study/csharp/#index-intro

これからC#を研修したいとする方は上記サイトを閲覧するのが良い。

#目次
##C#基礎
コンソール表示
コメント
リテラル
式、文、ブロック
コンソール表示2
C#の型
代表的な組込型
単純型の使用例
定数
構造化
配列
メソッド
構造体
名前空間

#C#基礎
##コンソール表示

```csharp
static void Main(string[] args)
        {
            Console.WriteLine("ヨイデワ・ナイカ・パッション重点");
            //出力：ヨイデワ・ナイカ・パッション重点
        }
```

##コメント

```csharp
            // コメント
            /*
                複数行コメント、リーダブルコードを読んで備えよう。
            */
```

##リテラル

```csharp
        static void Main(string[] args)
        {
            bool   b = true;     // 論理値型
            int    n = 123;      // 整数型
            double x = 1.35;     // 実数型
            char   c = 'a';      // 文字型
            string s = "文字列"; // 文字列型
            var    v = 456;      // 型推論

            Console.WriteLine(b); //出力:True
            Console.WriteLine(n); //出力:123
            Console.WriteLine(x); //出力:1.35
            Console.WriteLine(c); //出力:a
            Console.WriteLine(s); //出力:文字列
            Console.WriteLine(v); //出力:456
        }
```

##式、文、ブロック

式 == a + b
文     == ;区切り
ブロック== {}区切り

```csharp
        static void Main(string[] args)
        {
            int a = 3, b = 5;
            int c, d; 
            
            Console.WriteLine(a); //出力:3
            Console.WriteLine(b); //出力:
            //Console.WriteLine(c); コンパイルエラー

            c = a * b;              // d に a と b の積を代入
            Console.WriteLine(c);   //出力:15

            d = (a + b) / 2;      // c に a と b の平均値を代入
            Console.WriteLine(d); // (3+5)/2 = 4

        }
```

##コンソール表示2

```csharp
        static void Main(string[] args)
        {
            int x = 1;
            int y = 2;

            Console.WriteLine("{0}",x);
            Console.WriteLine("{0}, {1}", x, y);

            //出力:1
            //出力:1，2
        }
```

##C#の型

値型
・組込型：単純型
・ユーザー定義型：構造体、列挙型
・他の型から合成：Null許容型

参照型
・組込型：文字列型、オブジェクト型
・ユーザー定義型：クラス、インターフェイス、デリゲート
・他の型から合成：配列

###代表的な組込型

単純型
・整数型　int
・浮動小数点型　float,double
・論理値型　bool

参照型
・文字列型 string
・オブジェクト型　object

##単純型の使用例

単純型
・整数型　int
・浮動小数点型　float,double
・論理値型　bool

f or F 浮動小数点
d or D 倍精度浮動小数点
e      指数表記

```csharp
        static void Main(string[] args)
        {
            double x = 0.123456789;  // 倍精度浮動小数点型
            float  y = 1.23f; // fかFを付けると単精度
            var d = 0.123456789012D; // dかDを付けるとdouble
            double s = 1.02e5; //指数表記　0がeの後ろの個数分付く、いいね？　1.02＊10^5
            double z = 6.02e23; // 指数表記 6.02×10^23
            // 指数表記の方法　[仮数部]e[指数部] (例えば、2.56×104は2.56e4と書く)

            Console.WriteLine(x);//出力:0.123456789
            Console.WriteLine(y);//出力:1.23
            Console.WriteLine(d);//出力:0.123456789012
            Console.WriteLine(s);//出力:102000
            Console.WriteLine(z);//出力:6.02E+23

            int a = 1;
            bool b = a == 1;  // x が 1 ならば true 、そうでなければ false になる。
            bool t = true;  // 直接 true を代入
            bool f = false; // 直接 false を代入
            //f = 1; コンパイルエラー 

            Console.WriteLine(b);//出力:True
            Console.WriteLine(t);//出力:True
            Console.WriteLine(f);//出力:False

        }
```

##定数 const
const　を用いることで変化しない変数を生成可能。
readonly というキーワードを用いて、読取り専用（read only）の変数も定義可能。

```csharp
public static void Main(string[] args)
        {
            const int num = 1;
            //num = 2; コンパイルエラーを起こす。
            
            Console.WriteLine(num);　//出力:1
        }
```


#構造化

構造化のポイント
1.プログラムを逐次処理、分岐、反復という3つの制御構造で表現する。
2.大きなプログラムを小さな部品に分割して見通しを良くする。

制御フロー

・条件分岐
if文
switch文
goto文

・反復処理
while文
do-while 文
for文
foreach文　配列の全ての要素にアクセスする

##配列
「ハイレツ」…何度も変数を書いたりするのは苦痛であるから
まとめて書きたい欲望が具現化した存在…。

配列の宣言
型名[] 変数名;

配列の実体化
配列型変数 = new 型名[配列の長さ];

配列名[x] で長さを指定

```csharp
        public static void Main(string[] args)
        {
            //宣言 型名[] 変数名;
            int[] arr;

            //実体化　配列型変数 = new 型名[配列の長さ];
            arr = new int[3];

            //省略形　int[] arr = new int[3];

            arr[0] = 1;
            Console.WriteLine(arr[0]);//出力:1
        }
```

###配列の初期化
以下のようにして初期化も可能。
new 配列型[] { x, y, z, };

```csharp
        public static void Main(string[] args)
        {
            int[] a = new int[] { 1, 3, 5, 7, 9 };

            for (int i = 0; i < a.Length; i++)
            {
                Console.WriteLine(a[i]);//出力:1 3 5 7 9
            }
        }
```

###暗黙的型付け配列
以下の場合、varで推論するので　aがintの配列型となる。

```csharp
        public static void Main(string[] args)
        {
            var a = new[] { 1, 2, 3 };

            for (int i = 0; i < a.Length; i++)
            {
                Console.WriteLine(a[i]);//出力:1 2 3
            }
```

###多次元配列

多次元配列
・四角い多次元配列
・配列の配列-ジャグ配列

四角い多次元配列

型名[,] 変数名; // 2次元配列
型名[,,] 変数名; // 3次元配列

```csharp
double[,] a = new double[,]{{1, 2}, {2, 1}, {0, 1}}; // 3行2列の行列
double[,] b = new double[,]{{1, 2, 0}, {0, 1, 2}};   // 2行3列の行列
double[,] c = new double[3, 3];                      // 3行3列の行列
```

配列の配列
ギザギザの配列が作れる

```csharp
double[][] a = new double[][]{  // 3行2列の行列
  new double[]{1, 2},
  new double[]{2, 1},
  new double[]{0, 1}
};
double[][] b = new double[][]{  // 2行3列の行列
  new double[]{1, 2, 0},
  new double[]{0, 1, 2}
};
```

##メソッド
メソッドはクラスに記述する。
何度も行う処理はメソッドで処理する。

引数＝メソッドに引き渡すもの。
返り値（戻り値）＝メソッドから返ってくるもの。

メソッドの記述
・返り値のないメソッドはvoidで記述
・返り値のあるメソッドは返り値の型を記述し、returnで返り値を設定する。

返り値の型 メソッド名(型1 引数1, 型2 引数2, ...)
{
    処理
    return 返り値;
}

メソッドの呼び出し方
関数名()
関数名(引数)
関数名（引数,引数,引数）
例：Add(1,2)

main関数もメソッド。
public static void Main(string[] args){}

###返り値のないメソッド、Print()を使用した例

```csharp
    class Program
    {
        public static void Main(string[] args)
        {
            Print();
            //出力:「俺は知能指数が高いから分かる」
        }

        static void Print()
        {
            Console.WriteLine("「俺は知能指数が高いから分かる」");
        }
    }
```

###返り値のあるメソッド addを使用した例
Add(1,2)でメソッドを呼び出し、
return sumで返り値が戻る。

```csharp
    class Program
    {
        public static void Main(string[] args)
        {
            int x;
            x = Add(1,2);
            Console.WriteLine(x);
　　　　　　　//出力:3
        }

        static int Add(int a, int b)
        {
            int sum;
            sum = a + b;
            return sum;
        }
    }
```

###メソッドのオーバーロード
メソッドは同じ名前で、引数の違うメソッドを複数定義出来る。
以下はAddの例。
Add(int a, int b)
Add(int a, int b, int c)

```csharp
    class Program
    {
        public static void Main(string[] args)
        {
            int x;
            x = Add(1,2);
            Console.WriteLine(x);
            //出力:3

            int y;
            y = Add(1, 2, 3);
            Console.WriteLine(y);
            //出力:6
        }

        static int Add(int a, int b)
        {
            int sum = a + b;
            return sum;
        }

        static int Add(int a ,int b,int c)
        {
            int sum = a + b + c;
            return sum;
        }
    }
```

##構造体
複数の異なるデータ型の変数を1まとめにして管理することが可能。
この構造体中の変数をメンバー変数(member variable)またはフィールド(field: 作業領域)と呼ぶ。

```csharp
    class Program
    {
        public static void Main(string[] args)
        {
            Person p = new Person(); // string とか配列と同じような感じで宣言＆初期化

            // 「 . 」 を使って各メンバーにアクセスする
            // 構造体変数名.メンバー名
            p.name = "名前";
            p.age = 20;
            p.address = "sapporo";

            Console.WriteLine(p.name);//出力:名前
            Console.WriteLine(p.age);//出力:20
            Console.WriteLine(p.address);//出力:sapporo
        }

        //構造体
        struct Person
        {
            public string name;    // 名前
            public int age;     // 年齢
            public string address; // 住所
        }
    }
```

##名前空間
クラスを種類ごとに分けて管理するための仕組み
C#の名前空間の区切りには「 . 」を使う。
名前空間を作るには namespace キーワードを用いる。
using ディレクティブを用いれば、
名前空間内にあるクラスを完全修飾名を書くことなく使える。


気が向いたら続くかも
C#私的超入門#2