C#學習筆記--複雜資料型別、函數和結構體
2023-10-11 18:00:39
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("********************************");
}
}
}
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]);//改變數值
區別：
- ref傳入的變數必須初始化 out不必
- out傳入的變數必須在內部進行賦值 ref不必
理解：ref在傳入時候已經有初始值，所以在內部可以不作修改，
out在傳入時候可能未有初始值，所以要保證有效，在內部必須進行賦值。
函數的變長引數關鍵字 ---params
- 其後只能跟陣列
- 陣列型別可以為任意型別
- 函數參數列中只能出現一個
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中
命名規則：帕斯卡命名法（首字母均大寫）
建構函式：
- 無返回值
- 必須與結構體名字相同
- 必須有引數
- 如有建構函式，必須把所有的變數進行賦值
//結構體
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();
存取修飾符
- public
- private（預設不寫算私有）
- protect 繼承的可以存取
- internal - 內部的 只有在同一個程式集的檔案中，內部型別或者是成員才可以存取