结构体  

我们⽬前学习的变量，都是某⼀个单⼀的信息，⽐如  
- age  
- name  
- grade  
- studyID  




:::note{title="对于⼀个学⽣信息的话，是包含了这些的，我们怎么对这些信息进⾏⼀个整合呢？  "}
答案：结构体  
:::


**结构体**的作⽤就是把**某⼀类的变量进⾏整合，组成⼀个新的数据类型**，相当于⼀个新的信息。  
⽐如学⽣信息（包含了 年龄，姓名、年级、学号）  

创建10个学生的数组
```c#
StudentInfo[] students = new StudentInfo[10];
students[0].age = 30;

Console.WriteLine(students[0].age); //给1号学生年龄赋值

int[] stuAge = new int[10]; //创建10个学生年龄的数组
string[] stuName = new string[10]; //创建10个学生名字的数组
```  


怎么定义和使⽤结构体？  
```c#
struct <name>{
访问权限 type typename;
访问权限 type typename;
}
```  

❓学⽣信息的结构体  
```c#
struct StudentInfo{
public int age;  // public 权限 公开的
public String name;
public int grade;
public String studyID;
}
StudentInfo xiaoming;
xiaoming.age = 12;
xiaoming.name = "⼩明";
xiaoming.grade = 2;
xiaoming.studyID = "101214";
```  

❓定义⼀个表⽰三维坐标的结构体
```c#
struct Position{
public double x;
public double y;
public double z;
}
Position point1;
point1.x = point.y = 23.5；
point1.z = 1.5；
```  

结构体中的函数  
```c#
struct Position {
  public double x;
  public double y;
  public double z;

  public void PrintPosition() {
    Console.WriteLine(x + "," + y + "," + z);
  }
}
static void PrintPosition(Position p) {
  Console.WriteLine(p.x + "," + p.y + "," + p.z);
}

Position p1; //调用
p1.x = 23.3;
p1.y = 3.4;
p1.z = 1;
p1.PrintPosition();

Position p2; //调用
p2.x = 1;
p2.y = 2;
p2.z = 3;
p2.PrintPosition();
```
结构体中不但可以定义属性，也可以定义函数。  
```c#
struct CustomerName{
public string firstName;
public string lastName;
}
CustomerName myName;  

myName.firstName = "siki";
myName.lastName = "Liang";
Console.WriteLine("My name is "+myName.firstName+" "+myName.lastName);  

// 在结构体中定义函数，实现得到名字
struct CustomerName{
public string firstName;
public string lastName;
public string GetName(){
return firstName+" "+lastName;
}
Console.WriteLine("My name is "+ GetName);  
}
```

:::tip{title="提示"}
当我们在结构体中定义⼀个函数的时候，这个函数就可以通过结构体声明的变量来调⽤，
这个函数可以带有参数，那么调⽤的时候必须传递参数，
这个函数，可以使⽤结构体中的属性。
:::
❓结构函数训练：  
定义⼀个Vector3的类（这个类可以⽤来表⽰坐标，可以表⽰向量），在⾥⾯定义⼀个Distance⽅法，⽤来取得⼀个向量的⻓度的
```c#
struct Vector3 {
  public double x;
  public double y;
  public double z;
  public double Distance() {
    double temp = x * x + y * y + z * z;
    return Math.Sqrt(temp);
  }
} // 主函数入口
static void Main(string[] args) {
  Vector3 v1;
  v1.x = 4;
  v1.y = 5;
  v1.z = 7;
  Console.WriteLine(v1.Distance());
}
```

结构体

枚举类型
开发⼀个游戏，游戏⾓⾊有法师（Mage）、射⼿（Archer）、刺客（Assassin）、坦克
（Tank）、辅助（Support）、战⼠（Warrior），等不同类型。  

如何存储游戏的⾓⾊？  
1、使⽤int类型  
```c#
  //函数 - 定义 使用
 1法师（Mage）、2射⼿（Archer）、3刺客（Assassin）、4坦克 （Tank）、5辅助（Support）、6战⼠（Warrior）
 int roleType = 4;
 roleType = 3;
```   

2、使⽤枚举  
```c#
enum RoleType //枚举类型的名字
{
  Mage,Archer,Assassin,Tank,Support,Warrior //枚举类型的值
}
//主函数入口
static void Main(string[] args) {
  RoleType roleType = RoleType.Tank;
  if (roleType == RoleType.Archer) {

  }
}
```


如何声明枚举类型？  
```c#
enum <enum_name>
{
value1,
value2,
value3,
...
valuen
};

```  

如何声明  

```c#
<enum_name> varname;    
```
如何赋值  

```c#
varname = <enum_name>.<value>   
```
❓使⽤枚举类型，表⽰游戏的状态。（菜单、游戏中、暂停、失败、成功）  
```c#
enum GameState {
  Menu,Running,Pause,Fail,Success
}
//主函数入口  
static void Main(string[] args) {
  GameState gameState = GameState.Menu;
  gameState = GameState.Running;
  if (gameState == GameState.Menu) {

  }
  Console.WriteLine(gameState);
}
```

❓使⽤枚举类型，表⽰周⼀到周⽇。  

```c#
enum Days { Sun, Mon, Tue, Wed, Thu, Fri, Sat };  
Days day = Days.Mon;
day = Days.Tue;
```  
    
注意：  
枚举列表中的每个符号代表⼀个整数值，⼀个⽐它前⾯的符号⼤的整数值。默认情况下，第⼀个枚举符号的值是 0 ，可以修改默认的值  
```c#
enum Days
{
Sun, Mon=10, Tue, Wed, Thu, Fri=100, Sat
// 0    10      11   12   13     100    101
}
// int i = 1;//0-6 1-7
int number = (int)day;
Console.WriteLine(day);  //结果为 Tue
Console.WriteLine(number);  //结果为 2
```  


所以可以把枚举类型转成整数，来使⽤。  
```c#
1:
int i = (int)enum;
2:
enum GameSate{
Pause = 100,
Failed = 101,
Start
}
3:
enum GameSate:byte{
Pause = 100,
Failed = 101,
Start
}
```

枚举类型

常量  
常量是**固定值，程序执行期间不会改变**，它们的**值在定义后不能被修改**。  
合法常量
```c#
0213       /* 八进制 */
0x4b       /* 十六进制 */
30         /* int */  
30u        /* 无符号 int */
30l        /* long */
30ul       /* 无符号 long */
3.14159       /* 合法 */
314159E-5L    /* 合法 */
string a = "hello, world";                  // hello, world
string b = @"hello, world";               // hello, world
string c = "hello \t world";               // hello     world
```  
字符串常量是括在双引号 "" 里，或者是括在 @"" 里。  

非法常量
```c#
510E          /* 非法：不完全指数 */
210f          /* 非法：没有小数或指数 */
.e55          /* 非法：缺少整数或小数 */
078         /* 非法：8 不是一个八进制数字 */
032UU       /* 非法：不能重复后缀 */
```
怎么把⼀个变量变成常量  

```c#
const <data_type> <constant_name> = value;
```
为什么需要定义⼀个常量  
⽅便使⽤  
```c#
static void Main(string[] args) {
  Console.WriteLine("Hello World!");
  //变量 常量
  int i = 12;
  i = 20;
  const int j = 100;
  const double PI = 3.141592; //
  double temp = PI * 90;
  Console.WriteLine(PI);
}
```

常量

递归函数  

❓问题
f(n)=f(n-1)+f(n-2) f(0)=2 f(1)=3 ,⽤程序求得f(40）  

```c#
static int F(int n) {
  if (n == 0) {
    return 2;
  }
  if (n == 1) {
    return 3;
  }

  int res = F(n - 1) + F(n - 2);
  return res;
}
//主函数入口
static void Main(string[] args) {
  Console.WriteLine(F(40));
}
```  

:::tip{title="解决办法： "}
1、使⽤循环  
2、使⽤递归函数  

:::
 **调⽤⾃⾝的函数就是递归函数**
:::warning{title="注意"}
递归函数要有递归终⽌的条件
:::

 
  

✋编程题  
利⽤递归取得10!  即10的阶乘
```c#
static int F(int n) {
  if (n == 1) {
    return 1;
  }
  int result = n * F(n - 1);
  return result;
}
//主函数入口
static void Main(string[] args) {
  //10! = 10*9 ...   1

  int result = 1;
  for (int i = 1; i < 11; i++) {
    result = result * i;
  }
  Console.WriteLine(result);

  //10!
  f(n) = n * f(n - 1)
  // 10! = 10*9!
  // f(1)=1 
  Console.WriteLine(F(10)); //调用
}
```  


✋编程题
1+2!+3!+...+10!  
利⽤多个⽅法计算结果
```c#
//   方法1：    1+2!+3!+...+10!
int total = 0;
for (int i = 1; i < 11; i++) {
  int temp = 1;
  for (int j = 1; j < i + 1; j++) // i 的阶乘
  {
    temp = temp * j;
  }
  total = total + temp;
}
Console.WriteLine(total);
```  
```c#
//   方法2：    1+2!+3!+...+10!
static int F1(int n) {
  if (n == 1) {
    return 1;
  }
  int result = n * F1(n - 1);
  return result; //计算递归结果
}

static int F2(int n) {
    if (n == 1) {
      return 1;
    }
    return F2(n - 1) + F1(n）; //计算递归加法后的结果
    }
    //主函数入口
    static void Main(string[] args) {
      //f(n)=1+2!+3!+...+n!
      //f(n)=f(n-1) + n!
      //f1(n)=n!
      //f2(n)=f2(n-1) + n!
      Console.WriteLine(F2(10));
    }
```  

✋编程题
有关系式1\*1+2\*2+3\*3+...+k\*k<2000,编⼀个程序，求出满⾜此关系式的k的最⼤值
利⽤递归和循环解决这个问题  
```c#
 //f(n)=1 + 2 +..  n
//f(n)= f(n-1)+n
//f(1)=1
// 循环方式
int k = 1;
int result = 0;
while (true) {
  result += k * k;
  if (result >= 2000) {
    break;
  }
  k++;
}
Console.WriteLine(k - 1);
```
```c#
// 递归方式
static int F(int n) {
  if (n == 1) {
    return 1;
  }
  return F(n - 1) + n * n;
}
//主函数入口
static void Main(string[] args) {
  int i = 1;
  while (true) {
    if (F(i) >= 2000) {
      break;
    }
    i++;
  }
  Console.WriteLine(i - 1);
}
```

递归函数

函数的重载 - Overload  

为什么使⽤函数重载？  
假设我们有⼀个函数⽤来实现求得⼀个数组的最⼤值  
```c#
static int MaxValue(int[] intArray){
....
return;
}

```  


这个函数只能⽤于处理int数组，如果想处理double类型的话需要再定义⼀个函数  
```c#
static double MaxValue(double[] doubleArray){
...
return;
}

```  


**函数名相同，参数不同**，这个叫做**函数的重载**  
编译器通过不同的参数去识别应该调⽤哪⼀个函数 
```c#
static int MaxValue(int[] array) {
  int max = array[0];
  for (int i = 1; i < array.Length; i++) {
    if (max < array[i]) {
      max = array[i];
    }
  }
  return max;
}
static double MaxValue(double[] array) {
  double max = array[0];
  for (int i = 1; i < array.Length; i++) {
    if (max < array[i]) {
      max = array[i];
    }
  }
  return max;
}
static void Main(string[] args) {
  Console.WriteLine(MaxValue(new int[] {
    45,12,57,34,534,534,5323,324
  }));
  Console.WriteLine(MaxValue(new double[] {
    45,12,57,34,534,534,5323,324,23453.3
  }));
}
```



:::tip{title="提示"}
编译器会根据你传递过来的实参的类型去判定调⽤哪⼀个函数
:::

函数的重载

msvalidate.01

360-site-verification

sogou_site_verification

baidu-site-verification

95f521bf6bd97279d4c7d479ce66ad91_1745636273

shenma-site-verification

script

link

《千纸鹤》是一个关于个人成长、心灵探索和生活哲学的博客。通过结合纸鹤的象征意义，博客传递着希望、自由、勇气和梦想的理念，分享作者在人生旅途中所遇到的挑战与感悟。每一篇文章都如同一只飞翔的纸鹤，轻盈地载着思想与情感，带领读者在迷茫与困顿中找到属于自己的方向。