C#學習筆記--複雜資料型別、函式和結構體

暢知發表於2023-10-11
C#筆記資料型別函式結構體

C#基礎

複雜資料型別

特點：多個資料變數地一個集合體，可以自己命名

種類：列舉、陣列和結構體

  • 列舉：整型常量的集合
  • 陣列：任意變數型別的順序儲存的資料集合
  • 結構體：任意變數型別的資料組合成的資料塊

列舉：

列舉可以方便表示物件的各種狀態，本質還是一種變數。

例如我們可以用列舉來表示怪物的種類、玩家的動作狀態（靜止、戰鬥、受傷......）

列舉的宣告：

enum E_MonsterType//命名E_XXX
{
     Normal,//0
     Boss,//1 自動根據上一個數值順延
}
enum E_PlayerType
{ 
     Main,
     Other,
}

列舉型別的使用：

//自定義的列舉型別  變數名 = 預設值;(自定義的列舉型別.列舉項)
E_PlayerType playerType = E_PlayerType.Other;

if( playerType == E_PlayerType.Main )
{
    Console.WriteLine("主玩家邏輯");
}
else if(playerType == E_PlayerType.Other)
{
    Console.WriteLine("其它玩家邏輯");
}
//列舉也常常與switch語句做配合

 //列舉和switch是天生一對
E_MonsterType monsterType = E_MonsterType.Boss;
switch (monsterType)
{
    case E_MonsterType.Normal:
        Console.WriteLine("普通怪物邏輯");
        break;
    case E_MonsterType.Boss:
        Console.WriteLine("Boss邏輯");
        break;
    default:
        break;
}

列舉型別轉換：

  • 列舉與int互轉：
int i=(int) playerType;
playerType=0;
  • 列舉與string互轉：
playerType=(E_PlayerType)Enum.Paese(typeof(E_PlayerType),"other");
string str=playerType.ToSring();

陣列：

陣列是儲存同一種特定變數型別的有序資料集合，記憶體上的連續儲存。

一維陣列

//陣列宣告
int[] arr1;//未分配記憶體地址
int[] arr2=new int[5];//元素預設值0
int[] arr3=new int[5]{1,2,3,4,5};
int[] arr4=new int[]{1,2,3};
int[] arr5={1,2,3,4,5,6};

//陣列的使用
arr2.Length;//長度
arr2[0];//獲取陣列中的元素
arr2[2]=99;//修改內容
//陣列的遍歷
for(int i=0;i<arr2.Length;i++)
{
    //遍歷
     Console.WriteLine(arr2[i]);
}

//陣列的自定義擴容
//宣告新的大容量陣列，把舊有的進行復制轉移
int[] array2 = new int[6];
//搬家
for (int i = 0; i < array.Length; i++)
{
    array2[i] = array[i];
}
array = array2;

//自定義實現陣列的刪除元素
int[] array3 = new int[5];
//搬家 轉移
for (int i = 0; i < array3.Length; i++)
{
    array3[i] = array[i];
}
array = array3;


//查詢陣列中元素
//只有遍歷陣列 找到合適的則終止遍歷
int a = 3;
for (int i = 0; i < array.Length; i++)
{
    if( a == array[i] )
    {
        Console.WriteLine("和a相等的元素在{0}索引位置", i);
        break;
    }
}

多維陣列（二維陣列）

//二維陣列
//宣告
int[,] arr;
int[,] arr2=new int[3,4];
int[,] arr3=new int[3,4]{{0,1,2,3},//給元素內容  告訴維度 元素個數
                         {0,1,2,3},
                         {0,1,2,3}};
int[,] arr4=new int[,]{{0,1,2,3},//給元素內容 告訴維度
                         {0,1,2,3},
                         {0,1,2,3}};
int[,] arr5={{0,1,2,3},    //直接給元素內容
             {0,1,2,3},
             {0,1,2,3}};

//使用
//獲取長度
arr3.GetLength(0);//行的長度
arr3.GetLength(1);//列的長度

//獲取元素
arr3[1,1];//第一行第一列的元素
//遍歷二維陣列
for(int i=0;i<arr3.GetLength(0);i++)
{
    for(int j=0;j<arr3.GetLength(1);j++)
    {
        //訪問 具體元素
    }
}
//增加陣列元素
//思想：新建一個大容量的陣列，將小的陣列元素複製到大的陣列中
//最後修改小的陣列索引指向大的陣列 實現“陣列擴容”
//刪除陣列元素（同增加）
//查詢陣列中的元素（遍歷比對）

交錯陣列

交錯陣列區別於多維陣列，是陣列的陣列，一維陣列元素也是陣列，且長度不必完全相同。

//交錯陣列
//宣告
int [][] arr1;
int [][] arr2=new int[3][];//不可以規定列的長度
int [][] arr3=new int[3][]{
    new int[] {1,2,3,4},
    new int[] {1,2,3},
    new int[] {1}
};//體會陣列的陣列的含義！
int [][] arr4=new int[][]{
    new int[] {1,2,3,4},
    new int[] {1,2,3},
    new int[] {1}
};

int [][] arr5={//也可以直接賦值
    new int[] {1,2,3,4},
    new int[] {1,2,3},
    new int[] {1}
};

//陣列的使用
//長度
arr3.GetLength(0);//行數
arr3[0].Length;//第0行的長度

//獲取元素
arr3[0][2];
//遍歷
for(int i=0;i<arr3.GetLength(0);i++)
{
    for(int j=0;j<arr3[i].Legth;j++)
    {
        //訪問元素
        Console.WriteLine(arr3[i][j]);
    }
}

值型別和引用型別

值型別的數值儲存在棧（系統分配，自動回收GC，小而快）中、引用型別的儲存在堆（大而慢，需手動分配與回收）中，棧中只儲存其指標；

值型別在賦值時候將數值複製，而引用賦值修改引用指向的記憶體位置。

值型別：（14+2(列舉、結構體)）

  • 無符號整型：byte ushort uint ulong
  • 有符號整型：sbyte short int long
  • 浮點數: float double decimal
  • 特殊型別：bool char
  • 結構體
  • 列舉：enum

引用型別：（5種）

string 、陣列、類、介面、委託

函式

函式本質是封裝的程式碼塊，提升程式碼的複用率，抽象出具體的執行過程。

函式只能存在 struct 與class中

//函式出現在stuct與class中
//函式種類
//1 無引數 無返回值
void sayHellow()
{
    Console.WriteLine("Hello World");
}
//2 有引數 無返回值
void sayHellow(string name)
{
    Console.WriteLine("Hello,"+name);
}
//3 有引數 有返回值
int Add(int a,int b)
{
    return a+b;
}
//4 無引數 有返回值
string getMyName()
{
    return "TonyChang";
}

ref 和 out

使用其可以解決在函式內部改變函式外部的變數的數值的問題。

（本質是傳引數過程中傳的是數值或引用是否完全繫結到同一個數值/記憶體空間中）

//ref的使用
using System;
namespace CSharpLearn1
{
    class Program
    {
        static void ChangeValue(int value)
        {
            value = 3;
        }
        static void ChangeArrayValue(int[] arr) 
        {
            arr[0] = 33;
        }
        static void ChangeArray(int[] arr)
        {
            arr = new int[] {666,777,888,999 };
        }
        static void ChangeValueRef(ref int value)
        {
            value = 3;
        }
        static void ChangeArrayValueRef(ref int[] arr)
        {
            arr[0] = 33;
        }
        static void ChangeArrayRef( ref int[] arr)
        {
            arr = new int[] { 666, 777, 888, 999 };
        }
        static void Main(string[] args)
        {
            
            int a1 = 1;
            Console.WriteLine("a1原數值{0}", a1);
            ChangeValue(a1);
            Console.WriteLine("呼叫ChangValue函式之後a1的數值{0}", a1);//未改變數值
            ChangeValueRef(ref a1);
            Console.WriteLine("a1呼叫ChangValueRef函式之後a1的數值{0}", a1);//改變數值
            Console.WriteLine("********************************");

            int[] arr1 = { 100, 200, 300 };
            Console.WriteLine("arr1[0]原數值{0}", arr1[0]);
            ChangeArrayValue(arr1);
            Console.WriteLine("呼叫ChangArrayValue函式之後arr1[0]的數值{0}", arr1[0]);//改變數值
            Console.WriteLine("********************************");

            int[] arr2 = { 100, 200, 300 };
            Console.WriteLine("arr2[0]原數值{0}", arr2[0]);
            ChangeArray(arr2);
            Console.WriteLine("呼叫ChangArrayValue函式之後arr2[0]的數值{0}", arr2[0]);//未變數值
            ChangeArrayRef(ref arr2);
            Console.WriteLine("呼叫ChangArrayValueRef函式之後arr2的數值{0}", arr2[0]);//改變數值
            Console.WriteLine("********************************");

            int[] arr11 = { 100, 200, 300 };
            Console.WriteLine("arr11[0]原數值{0}", arr11[0]);//改變數值
            ChangeArrayValueRef(ref arr11);
            Console.WriteLine("呼叫ChangArrayValueRef函式之後arr[0]的數值{0}", arr11[0]);//改變數值
            Console.WriteLine("********************************");
        }
    }
}

image

Out

//新增兩個OUt修飾引數的函式   
static void ChangeValueOut(out int value)
    {
        value = 3;
    }
    static void ChangeArrayOut(out int[] arr)
    {
        arr = new int[] { 666, 777, 888, 999 };
    }
//新增到Main函式中

 int a1 = 1;
            Console.WriteLine("a1原數值{0}", a1);
            ChangeValue(a1);
            Console.WriteLine("呼叫ChangValue函式之後a1的數值{0}", a1);//未改變數值
            ChangeValueOut(out a1);
            Console.WriteLine("a1呼叫ChangValueOut函式之後a1的數值{0}", a1);//改變數值
            Console.WriteLine("********************************");
            int[] arr1 = { 100, 200, 300 };
            Console.WriteLine("arr1[0]原數值{0}", arr1[0]);
            ChangeArray(arr1);
            Console.WriteLine("呼叫ChangArray函式之後arr1[0]的數值{0}", arr1[0]);//未改變數值
            ChangeArrayOut(out arr1);
            Console.WriteLine("呼叫ChangArrayOut函式之後arr1[0]的數值{0}", arr1[0]);//改變數值

image

區別：

  1. ref傳入的變數必須初始化 out不必
  2. out傳入的變數必須在內部進行賦值 ref不必

理解：ref在傳入時候已經有初始值，所以在內部可以不作修改，

​ out在傳入時候可能未有初始值，所以要保證有效，在內部必須進行賦值。

函式的變長引數關鍵字 ---params

  1. 其後只能跟陣列
  2. 陣列型別可以為任意型別
  3. 函式引數列表中只能出現一個params，並且修飾的引數只能在末尾出現
//函式變長引數關鍵字 params後必須為陣列
//求n個int的和
int Sum(params int[] arr)
{
    int sum=0;
    for(int i=0;i<arr.Length;i++)
    {
        sum+=arr[i];
    }
    return sum;
}
void Chat(string name,params string[] things)
{
    //函式體...
}

函式的引數預設值

函式引數列表中可以有多個引數，有預設值的引數一定在普通引數的後面

void Speak(string thing="我沒什麼可說的了")
{
    Console.WriteLine(thing);
}
//呼叫
Speak();
Speak("我想說，，，，");

函式過載：

在同一語句塊中，函式名字相同，函式的引數列表不同（引數型別不同或引數的個數不同，二者均相同則引數順序不同）

//函式過載
//函式的引數數量不同 
int Sum(int a,int b)
{
    return a+b;
}
int Sum(int a,int b,int c)
{
    return a+b+c;
}
// 引數 數量相同 型別不同
float Sum(int a,int b)
{
    return a+b;
}
float Sum(float f1,float f2)
{
    return f1+f2;
}
//引數 數量相同 型別相同 順序不同
float Sum(float f,int i)
{
    return f+i;
}
float Sum(int i,float f)
{
    return f+i;
}
//ref 和 out 改變引數型別 與普通的函式構成過載
//ref 和out 算作一類 自身不可互相構成過載
int Sum(int a,int b)
{
    return a+b;
}
int Sum(ref int a,int b)
{
    return a+b;
}
//params 可以作為過載
//但是 引數預設值不可構成過載

遞迴函式

函式自己呼叫自己，遞迴有遞迴基與結束呼叫的條件.

//遞迴列印0-10
void Fun(int a)
{
    if(a>10)
        return;
    Console.WriteLine(a);
    a++;
    Fun(a);
}
//遞迴----求某一數的階乘
int getFactorial(int a)
{
    //結束條件
    if(a==1)
        return 1;
    //遞迴基
    return a*getFactorial(a-1);
}
//遞迴----求1！+2！+3！+···+10！
int getFactorialSum(int num)
{
    if(num==1)
        return 1;
    return getFactorial(num)+getFactorial(num-1);
}
//遞迴---
//一根竹竿長100m，每天砍掉一半，求第十天的長度是多少？
void getLong(float length,int day=0)
{
    length/=2;
    if(day==10)
    {
        Console.WriteLine("第十天砍後的竹子長度為{0}米"，length);
    }
    ++day;
    getLong(length,day);
}
//---遞迴列印1-200
//遞迴+短路
bool Fun5(int num)
{
    Console.WriteLine(num);
    return num==200||Fun5(num+1);//第一個為條件真 便會短路
}

結構體

結構體是資料與方法的集合，在namespace中

命名規則：帕斯卡命名法（首字母均大寫）

建構函式：

  1. 無返回值
  2. 必須與結構體名字相同
  3. 必須有引數
  4. 如有建構函式，必須把所有的變數進行賦值
//結構體
struct Student
{
    //不可以包含自身型別的結構體--Student  s; 報錯！
    //姓名:
    public string name;
    //年齡
    public int age;//數值變數不可以直接初始化
    public bool sex;
    //建構函式(預設有一個無參建構函式，若有建構函式則預設的建構函式不會失效，這點與類不同)
    //對變數進行初始化
    public Student(string name,int age,bool sex)
    {
        this.name=name;
        this.age=age;
        this.sex=sex;
    }
    //方法
    public void Speak()
    {
        Console.WriteLine("你好");
    }
}

//結構體的使用
Student s1;
s1.name="Tony";
s1.age=18;
s1.sex=true;
s1.Speak();

訪問修飾符

  1. public
  2. private（預設不寫算私有）
  3. protect 繼承的可以訪問
  4. internal - 內部的 只有在同一個程式集的檔案中，內部型別或者是成員才可以訪問

既然都看到這裡了，那就給個?吧！
小小一讚，給作者的莫大的鼓勵！
關注我，我會每天更新C#學習筆記，從入門到進階，一起來學習啊！！！

相關文章