CSharp_base
C# 基础篇github仓库：https://github.com/EanoJiang/CSharp_base
枚举(enum)
枚举是一个被命名的整形常量的集合
用于表示： 状态 类型
申明枚举：创建一个自定义的枚举类型
申明枚举变量：使用申明的自定义的枚举类型，来创建一个枚举变量
语法
//语法：枚举名 以E或E_开头，作为命名规范
enum E_自定义枚举名{
自定义枚举项名字1,//枚举中的第一个默认值是0，也可以赋值，下面依次累加。
自定义枚举项名字2,//1
自定义枚举项名字3,//2
}在哪里申明枚举
[*]namespace语句块中
[*]class语句块中
[*]struct语句块中
枚举不能在函数语句块中声明
#region 在哪里申明枚举
//namespace语句块中
//class语句块中
//struct语句块中
//枚举不能再函数语句块中声明
enum E_MonsterType{
Normal,
Boss,
}
enum E_PlayerType{
Main,
Other,
}
#endregion
枚举的用法
[*]申明枚举变量： 前面自定义的 变量名 = 默认值;
[*]枚举和switch配套使用
#region 枚举的用法
//申明枚举变量
//前面自定义的 变量名 = 默认值;
// (这里的默认值的格式：自定义的枚举类型.枚举项)枚举类型
E_MonsterType monsterType = E_MonsterType.Normal;
E_PlayerType playerType= E_PlayerType.Main;
if(playerType == E_PlayerType.Main){
Console.WriteLine("主角的逻辑");
}
else if(playerType == E_PlayerType.Other){
Console.WriteLine("其他角色的逻辑");
}
//枚举很适合和switch配套使用
//也可以贯穿，两种情况使用同一个逻辑
switch (monsterType){
case E_MonsterType.Normal:
Console.WriteLine("普通怪物的逻辑");
break;
case E_MonsterType.Boss:
Console.WriteLine("BOSS的逻辑");
break;
}
#endregion枚举的类型转换
#region 枚举的类型转换
//枚举转int——括号强转
int i1 = (int)playerType;
Console.WriteLine(i1);
//int 转枚举——隐式转换
playerType = 0;
Console.WriteLine(playerType);
//枚举转string——ToString()方法
string s1 = playerType.ToString();
Console.WriteLine(s1);
//string 转枚举——Parse()方法 + 自定义枚举类型括号强转
//语法：(自定义枚举类型)Enum.Parse(typeof(自定义枚举类型), "要转换的字符串");
//注意要转换的字符串必须是枚举里有的常量
playerType = (E_PlayerType)Enum.Parse(typeof(E_PlayerType), "Main");
Console.WriteLine(playerType);
#endregion(总结)枚举的作用
在游戏开发中，对象通常会有很多状态
每个状态需要一个变量 / 标识 来表示，以便于后续使用时的判断(该对象当前处于什么状态)
不要去用int 表示他的状态 ，1走路 2空闲 3跑步 4跳跃
枚举的使用可以很好的分清楚各状态的含义，提高代码可读性
习题
/// <summary>
/// 状态
/// </summary>
enum E_StateOnlineType{
Offline,
Online,
Busy,
Invisible,
} #region 题目1 用户状态
try
{
Console.WriteLine("请输入状态(0-3):");
E_StateOnlineType state = (E_StateOnlineType)Enum.Parse(typeof(E_StateOnlineType), Console.ReadLine());
Console.WriteLine(state);
}
catch{
Console.WriteLine("输入错误,请输入0-3的数字!");
}
#endregion
/// <summary>
/// 咖啡类型
/// </summary>
enum E_CoffeeType{
/// <summary>
/// 中杯
M,
/// <summary>
/// 大杯
/// </summary>
L,
/// <summary>
/// 特大杯
/// </summary>
XL,
} #region 题目2 coffee
try{
Console.WriteLine("请输入咖啡类型(M/L/XL):");
E_CoffeeType coffeeType = (E_CoffeeType)Enum.Parse(typeof(E_CoffeeType), Console.ReadLine());
switch(coffeeType){
case E_CoffeeType.M:
Console.WriteLine("中杯咖啡");
break;
case E_CoffeeType.L:
Console.WriteLine("大杯咖啡");
break;
case E_CoffeeType.XL:
Console.WriteLine("特大杯咖啡");
break;
default:
Console.WriteLine("输入错误!");
break;
}
}
catch{
Console.WriteLine("输入错误,请输入M/L/XL!");
}
#endregion
数组
一维数组(数组)
一维、多维、交错数组
namespace 数组;
class Program
{
static void Main(string[] args)
{
#region 数组声明
//只声明数组名，不初始化
//变量类型[] 数组名;
int[] arr1;
//声明并初始化数组的长度，元素默认值是0
//变量类型[] 数组名 = new 变量类型[数组长度];
int[] arr2 = new int;
//声明并初始化数组的长度和元素值
//变量类型[] 数组名 = new 变量类型[数组长度] {元素值1, 元素值2, 元素值3...};
int[] arr3 = new int { 1, 2, 3, 4, 5 };
//声明并初始化数组的元素值，数组长度自动计算
//变量类型[] 数组名 = new 变量类型[] {元素值1, 元素值2, 元素值3...};
int[] arr4 = new int[] { 1, 2, 3, 4};
//声明并初始化数组——最简单的方法
int[] arr5 = { 1, 2, 3, 4, 5 };
bool[] arr6 = new bool[] { true, false, true, false };
#endregion
#region 数组使用
int[] arr = { 1, 2, 3, 4, 5 };
//1. 获取数组长度
//数组名.Length
Console.WriteLine("数组长度：" + arr.Length);
//2. 获取数组元素
//数组名[索引]
//注意不要越界
Console.WriteLine("数组第一个元素：" + arr);
//3. 修改数组元素
//数组名[索引] = 新值;
arr = 10;
Console.WriteLine("修改后的数组第一个元素：" + arr);
//4. 遍历数组
for(int i = 0; i < arr.Length; i++){
Console.WriteLine("数组第" + i + "个元素：" + arr);
}
//5. 增加数组元素(先拷贝数组)
int[] array2 = new int;
for(int i = 0; i < arr.Length; i++){
array2 = arr;
}
arr = array2;
arr = 6;
Console.WriteLine("增加后的数组：" + string.Join(",", arr));
//6. 删除数组元素(先拷贝数组)
int[] array3 = new int;
for(int i = 0; i < 4; i++){
array3 = arr;
}
arr = array3;
Console.WriteLine("删除后的数组：" + string.Join(",", arr));
//7. 查找数组元素
int elem = 3;
for(int i = 0; i < arr.Length; i++){
if(arr == elem){
Console.WriteLine("元素" + elem + "在数组的索引为：" + i);
break;
}
}
#endregion
}
}用来批量存储游戏中同一类型的所有对象，比如所有的enemy和player
习题
#region 1
int[] arr1 = new int;
for(int i = 0; i < arr1.Length; i++){
arr1 = i;
}
Console.WriteLine(string.Join(",", arr1));
#endregion#region 2
int[] arr2 = new int;
for(int i = 0; i < arr2.Length; i++){
arr2 = arr1 * 2;
}
Console.WriteLine(string.Join(",", arr2));
#endregion#region 3
Random r1 = new Random();
int[] arr3 = new int;
for(int i = 0; i < arr3.Length; i++){
arr3 = r1.Next(0, 101);
}
Console.WriteLine(string.Join(",", arr3));
#endregion#region 4
Random r = new Random();
int[] arr = new int;
for(int i = 0; i < arr.Length; i++){
arr = r.Next(0, 101);
}
Console.WriteLine("原数组："+string.Join(",", arr));
//MAX MIN
int max = arr;
int min = arr;
int sum = 0;
for(int i = 0; i < arr.Length - 1; i++){
max = (max >= arr)? max : arr;
min = (min <= arr)? min : arr;
sum += arr;
}
Console.WriteLine("最大值："+max);
Console.WriteLine("最小值："+min);
Console.WriteLine("和："+sum);
double avg = (double)sum / arr.Length;
Console.WriteLine("平均值："+avg);
#endregion#region 5
Random r2 = new Random();
int[] arr4 = new int;
for(int i = 0; i < arr4.Length; i++){
arr4 = r2.Next(0, 101);
}
Console.WriteLine("原数组："+string.Join(",", arr4));
for(int i = 0; i < arr4.Length /2; i++){
arr4 = arr4 + arr4;
arr4 = arr4 - arr4;
arr4 = arr4 - arr4;
}
Console.WriteLine("反转后："+string.Join(",", arr4));
#endregion#region 6
Random r3 = new Random();
int[] arr5 = new int;
for(int i = 0; i < arr5.Length; i++){
arr5 = r3.Next(-100, 101);
}
Console.WriteLine("原数组："+string.Join(",", arr5));
for(int i = 0; i < arr5.Length; i++){
if(arr5>0) arr5++;
else if(arr5<0) arr5--;
}
Console.WriteLine("变化后："+string.Join(",", arr5));
#endregion#region 7
int[] arr6 = new int;
//输入
try{
for(int i = 0; i < arr6.Length; i++){
Console.Write("请输入第{0}个元素：", i+1);
arr6 = Convert.ToInt32(Console.ReadLine());
}
}
catch{
Console.WriteLine("输入有误，程序退出");
}
Console.WriteLine("原数组："+string.Join(",", arr6));
//MAX MIN
int max = arr6;
int min = arr6;
int sum = 0;
for(int i = 0; i < arr6.Length - 1; i++){
max = (max >= arr6)? max : arr6;
min = (min <= arr6)? min : arr6;
sum += arr6;
}
Console.WriteLine("最大值："+max);
Console.WriteLine("最小值："+min);
Console.WriteLine("平均值："+(double)sum / arr6.Length);
#endregion交错数组
数组的数组
特点：存储 确定行数，不确定列数的数据
#region 8
string[] arr7 = new string;
for(int i = 0; i < arr7.Length; i++){
arr7 = (i%2 == 0)? "■": "□";
}
for(int i = 0; i < arr7.Length; i++){
Console.Write(arr7);
if((i+1)%5 == 0 && i!= 0){
Console.WriteLine();
}
}
#endregion值类型和引用类型
引用类型：string、数组、(class)类
值类型：其他数据类型，结构体
区别：
值类型：在相互赋值的时候把内容拷贝给对方，一个变另一个不会变
引用类型：两者指向同一个值，一个变另一个也变
namespace 二维数组;
class Program
{
static void Main(string[] args)
{
#region 二维数组的申明
//申明但不初始化：
//变量类型[,] 二维数组变量名
int[,] arr1;
//变量类型[,] 二维数组变量名 = new int[行数,列数];
int[,] arr2 = new int;
//申明+初始化：
//变量类型[,] 二维数组变量名 = new int[行数,列数] { {元素1,元素2,元素3...}, {元素1,元素2,元素3...},... };
int[,] arr3 = new int { { 1, 2, 3 },
{ 4, 5, 6 },
{ 7, 8, 9 }};
//行列自动计算
int[,] arr4 = new int[,] { { 1, 2, 3 },
{ 4, 5, 6 },
{ 7, 8, 9 }};
#endregion
#region 二维数组的使用
//1.二维数组的长度
int[,] array1 = new int[,]{ {1,2,3},
{4,5,6},
{7,8,9}};
//二维数组名.GetLength(dimesion)，dimesion为0表示行，为1表示列
//行
Console.WriteLine(array1.GetLength(0));
//列
Console.WriteLine(array1.GetLength(1));
//2.获取二维数组的元素
//二维数组名[行,列]
Console.WriteLine(array1);
//3.修改二维数组的元素
//二维数组名[行,列] = 元素值
array1 = 10;
Console.WriteLine(array1);
//4.遍历二维数组
for (int i = 0; i < array1.GetLength(0); i++)
{
for (int j = 0; j < array1.GetLength(1); j++)
{
Console.Write(array1 + " ");
}
Console.WriteLine();
}
Console.WriteLine("**************");
//5.增加数组元素
int[,] array2 = new int;
//先拷贝原数组元素
for (int i = 0; i < array1.GetLength(0); i++)
{
for (int j = 0; j < array1.GetLength(1); j++)
{
array2 = array1;
}
}
array1 = array2;
array1 = 100;
array1 = 101;
array1 = 102;
for(int i = 0; i < array1.GetLength(0); i++)
{
for(int j = 0; j < array1.GetLength(1); j++)
{
Console.Write(array1 + " ");
}
Console.WriteLine();
}
Console.WriteLine("***************");
//6.删除数组元素
//先拷贝原数组元素
int[,] array3 = new int;
for (int i = 0; i < array3.GetLength(0); i++)
{
for (int j = 0; j < array3.GetLength(1); j++)
{
array3 = array1;
}
}
array1 = array3;
for(int i = 0; i < array1.GetLength(0); i++)
{
for(int j = 0; j < array1.GetLength(1); j++)
{
Console.Write(array1 + " ");
}
Console.WriteLine();
}
//7.查找数组元素
for(int i = 0; i < array1.GetLength(0); i++)
{
for(int j = 0; j < array1.GetLength(1); j++)
{
if(array1 == 6)
{
Console.WriteLine("元素6的位置为：{0},{1}", i, j);
}
}
}
#endregion
}
}WHY？
值类型存储在栈空间——系统分配，自动回收，小而快
引用类型存储在堆空间——手动申请释放，大而慢
值类型每次申明相当于开了一个栈空间，赋值的时候互不影响。
引用类型申明的时候开的栈空间存放的是一个指针(地址)，指向一块堆内存，赋值的时候其实赋的是地址。
习题
[*]10
[*]20
[*]"123"
string——特殊的引用类型
每次重新赋值的时候在堆内存重新分配空间，地址也会重新分配
#region 1
int[,] arr1 = new int;
int count = 1;
Console.WriteLine("1到10000的二维数组：");
for (int i = 0; i < arr1.GetLength(0); i++){
for (int j = 0; j < arr1.GetLength(1); j++){
arr1 = count;
count++;
Console.Write(arr1 + " ");
}
Console.WriteLine();
}
#endregion习题
#region 2
int[,] arr2 = new int;
Random r = new Random();
Console.WriteLine("随机生成的4x4二维数组：");
for (int i = 0; i < arr2.GetLength(0); i++){
for (int j = 0; j < arr2.GetLength(1); j++){
arr2 = r.Next(1, 101);
Console.Write(arr2 + " ");
}
Console.WriteLine();
}
Console.WriteLine("将数组的右上角区域清零：");
for (int i = 0; i < arr2.GetLength(0); i++){
for (int j = 0; j < arr2.GetLength(1); j++){
if(i < arr2.GetLength(0) / 2 && j >= arr2.GetLength(1) / 2){
arr2 = 0;
}
Console.Write(arr2 + " ");
}
Console.WriteLine();
}
#endregion总结
只要是整体重新赋值（像new int[]）地址就会改变
而单独改一个元素，地址不会改变
函数(方法)
函数基础
作用：
[*]封装代码
[*]提高代码复用率
[*]抽象行为
写在哪儿？
[*]class(类)语句块中
[*]struct(结构体)语句块中
语法
#region 3
int[,] arr3 = new int;
Random r = new Random();
Console.WriteLine("随机生成的3x3二维数组：");
for (int i = 0; i < arr3.GetLength(0); i++){
for (int j = 0; j < arr3.GetLength(1); j++){
arr3 = r.Next(1, 11);
Console.Write(arr3 + " ");
}
Console.WriteLine();
}
Console.WriteLine("对角线:");
int sum = 0;
for (int i = 0; i < arr3.GetLength(0); i++){
for (int j = 0; j < arr3.GetLength(1); j++){
if(i == j || i+j == 3-1){
sum += arr3;
Console.Write(arr3 + " ");
}
}
Console.WriteLine();
}
Console.WriteLine("对角线的和为：" + sum);
#endregion
[*]在学习类和结构体之前，static必须写
[*]函数名用帕斯卡命名法，比如：MyName()
[*]参数名用驼峰命名法
[*]即使函数返回类型是void，也可以选择性使用return
使用
#region 4
int[,] arr4 = new int;
Random r = new Random();
//记录最大值的位置
int maxRow = 0, maxCol = 0;
Console.WriteLine("随机生成的5x5二维数组：");
for (int i = 0; i < arr4.GetLength(0); i++){
for (int j = 0; j < arr4.GetLength(1); j++){
arr4 = r.Next(1, 11);
Console.Write(arr4 + " ");
if(arr4 < arr4){
maxRow = i;
maxCol = j;
}
}
Console.WriteLine();
}
Console.WriteLine("最大值{0}的位置：({1},{2})" , arr4, maxRow, maxCol);
Console.WriteLine("****所有最大值元素{0}的位置****");
for(int i = 0; i < arr4.GetLength(0); i++){
for(int j = 0; j < arr4.GetLength(1); j++){
if(arr4 == arr4){
Console.WriteLine("最大值{0}的位置：({1},{2})" , arr4, i, j);
}
}
}
#endregion关于return
#region 5
int[,] arr5 = new int { { 0,0,0,0,0},
{ 0,0,0,0,0},
{ 0,0,1,1,0},
{ 0,0,0,0,0},
{ 0,0,0,0,0}};
void transArray(int[,] arr){
//用来记录行和列是否有1的真值数组
bool[] boolRow = new bool;
bool[] boolCol = new bool;
//标记行和列
for(int i = 0; i < arr.GetLength(0); i++){
for(int j = 0; j < arr.GetLength(1); j++){
if(arr == 1){
boolRow = true;
boolCol = true;
}
}
}
//转置
for(int i = 0; i < arr.GetLength(0); i++){
for(int j = 0; j < arr.GetLength(1); j++){
if(boolRow == true || boolCol == true){
arr = 1;
}
}
}
}
transArray(arr5);
Console.WriteLine("转置后的数组：");
for (int i = 0; i < arr5.GetLength(0); i++){
for (int j = 0; j < arr5.GetLength(1); j++){
Console.Write(arr5 + " ");
}
Console.WriteLine();
}
#endregion习题
namespace 交错数组;
class Program
{
static void Main(string[] args)
{
#region 交错数组的申明
//只申明
//变量类型[][] 交错数组名;
int[][] arr1;
//申明+初始化
//变量类型[][] 交错数组名 = new int[行数][];
int[][] arr2 = new int[];
//变量类型[][] 交错数组名 = new int[行数][] { 一维数组1, 一维数组2, 一维数组3 };
//注意：{一维数组的数据类型要和交错数组的类型一致}
int[][] arr3 = new int[] { new int[] { 1, 2 },
new int[] { 3, 4},
new int[] { 5 } };
//变量类型[][] 交错数组名 = new int[][] { 一维数组1, 一维数组2, 一维数组3 };
int[][] arr4 = new int[][] { new int[] { 1, 2 },
new int[] { 3, 4},
new int[] { 5 } };
//最常用：
//变量类型[][] 交错数组名 = { 一维数组1, 一维数组2, 一维数组3 };
int[][] arr5 = {new int[] {1, 2, 3},
new int[] {4, 5},
new int[] {6, 7, 8, 9}};
#endregion
#region 交错数组的使用
int[][] array1 = {new int[] {1, 2, 3},
new int[] {4, 5} };
//1.数组的长度
//行
//交错数组名.Length
//交错数组名.GetLength(0)
Console.WriteLine(array1.Length);
Console.WriteLine(array1.GetLength(0));
//列
//交错数组名[行].Length
//其实就是找到交错数组中的某个一维数组的长度
Console.WriteLine(array1.Length);
Console.WriteLine(array1.Length);
//2.获取交错数组的元素
//交错数组名[行][列]
Console.WriteLine(array1);
//3.修改交错数组的元素
//交错数组名[行][列] = 值;
array1 = 10;
Console.WriteLine(array1);
//4.遍历交错数组
//和二维数组一样，只不过是遍历每一个一维数组
for (int i = 0; i < array1.Length; i++)
{
for (int j = 0; j < array1.Length; j++)
{
Console.Write(array1 + " ");
}
Console.WriteLine();
}
//5.增加交错数组的元素
//6.删除交错数组的元素
//7.查找交错数组的元素
//***都和二维数组一样***
#endregion
}
}namespace 值类型和引用类型;
class Program
{
static void Main(string[] args)
{
//值类型
int a = 1;
//引用类型
int[] arr = new int[] {1,2,3,4 };
//赋值给另一个变量
int b = a;
int[] arr2 = arr;
Console.WriteLine("a={0},b={1}\narr={2},arr2={3}",a,b,arr,arr2);
//修改新的变量
b = 2;
arr2 = 99;
Console.WriteLine("a={0},b={1}\narr={2},arr2={3}",a,b,arr,arr2);
}
} #region string——特殊的引用类型
string str1 = "123";
string str2 = str1;//这一步两个变量指向的地址相同
str2 = "456";//str2重新赋值，地址改变
Console.WriteLine("str1={0},str2={1}",str1,str2);
#endregion递归
必须有结束掉用的条件
#region 习题
int[] arr3 = new int[]{1};
int[] arr4 = arr3;
int[] arr5 = arr3;
arr4 = 99;//arr4修改单个元素，地址不变
arr5 = new int;//arr5重新赋值，地址改变，指向新的堆内存
Console.WriteLine("arr3={0},arr4={1},arr5={2}",arr3,arr4,arr5);
#endregion习题
namespace 函数;
class Program
{
#region 函数的语法
// static 返回类型 函数名(参数类型 参数名){
// // 函数体
// return 返回值;
// }
#endregion
static void Main(string[] args)
{
}
}结构体
结构体相当于一个人，他的变量相当于人的各个属性，方法相当于人的各个功能函数
语法
[*]写在namespace语句块中
[*]关键字struct
[*]帕斯卡命名法
namespace 函数;
class Program
{
//有参有返回值的函数
static int[] sum_avg(int a, int b)
{
int sum = a + b;
int avg = sum / 2;
// int[] result = { sum, avg };
return new int[] { sum, avg };
}
static void Main(string[] args)
{
int a = 10;
int b = 20;
int[] result = sum_avg(a, b);
Console.WriteLine("The sum is: " + result);
Console.WriteLine("The average is: " + result);
}
}访问修饰符
修饰结构体中的变量和方法 是否能被外部使用
public 可以被外部访问
private 只能在内部使用
默认不写，就是private
结构体的构造函数
[*]没有返回值
[*]函数名和结构体名相同
[*]必须有参数
[*]如果申明了构造函数，那就必须在其中对所有变量数据初始化
使用
static void Say(string str){
//void也是可以写return的，return后面的语句不会执行
if(str == "Fuck") return;
Console.WriteLine(str);
}习题
#region 1
static int Max(int a, int b){
return (a > b)? a : b;
}
#endregion排序
冒泡排序
#region 2
static float[] Circle(float r){
//1
// float area= 3.14f * r * r;
// float perimeter = 2 * 3.14f * r;
// float[] result = {area, perimeter};
// return result;
//2
return new float[] { 3.14f * r * r, 2 * 3.14f * r };
}
#endregion #region 3
static int[] CalculateArr(int[] arr){
if( arr.Length == 0 )
{
Console.WriteLine("数组不能为空");
return new int;
}
int sum = 0, max = arr, min = arr, average = 0;
for (int i = 0; i < arr.Length; i++)
{
sum += arr;
max = (max >= arr) ? max : arr;
min = (min <= arr) ? min : arr;
}
average = sum / arr.Length;
int[] result = { sum, max, min, average };
return result;
}
#endregion习题
#region 4
static bool IsPrime(int num){
for(int i = 2; i <= num; i++){
if(num%i == 0) return false;
}
return true;
}
#endregion #region 5
static bool IsLeapYear(int year){
if(year%4 == 0 && year%100!= 0 || year%400 == 0) return true;
//默认返回false
return false;
}
#endregion选择排序
步骤：
[*]新建中间商
[*]每轮依次比较，更新中间商
[*]找出极值
[*]中间商与目标位置互换位置
[*]n轮比较
详细步骤：
[*]新建一个中间商，索引为0
[*]中间商与数组的值比较，从索引0开始向后依次比较，每次比较后更新中间商的索引为较大值(或较小值)的索引，找到极值(MAX/min)，把极值与目标位置(arr.Length-n-1)互换位置(如果是升序排列，就把MAX放在末尾)
[*]这样比较n轮，每轮比较完重置中间商的索引为0，再继续比较，后续每轮的比较只需i从1遍历到数组长度-n即可(第0个不需要和自己比较，末尾的已经排序完不需要再比较)
namespace ref和out;
class Program
{
#region 为什么要学习ref和out？
//正常来说，我们在调用函数的时候，传递的是值，函数内部修改这个值，并不会影响到外部的变量。
//只有当传入参数是引用类型且引用类型没有被重新赋值时，才会影响到外部的变量。
static void ChangeValue(int value){
value = 1;
}
static void ChangeArrValue(int[] arr){
arr = 1;
}
static void ChangeArr(int[] arr){
arr = new int[]{1};
}
#endregion
static void Main(string[] args)
{
int value = 0;
//传入函数的只是这个变量，没有返回，所以值不变
ChangeValue(value);
Console.WriteLine(value); // Output: 0
int[] arr1 = new int;
//传入函数的是arr的地址，arr和arr1都指向arr1的地址，所以值会变
ChangeArrValue(arr1);
Console.WriteLine(arr1); // Output: 1
int[] arr2 = new int;
//因为函数ChangeArr中arr新开辟了一个地址，与传入的数组的地址不再有关联，所以值不变
ChangeArr(arr2);
Console.WriteLine(arr2); // Output: 0
}
}习题
namespace ref和out;
class Program
{
#region 为什么要学习ref和out？
//正常来说，我们在调用函数的时候，传递的是值，函数内部修改这个值，并不会影响到外部的变量。
//只有当传入参数是引用类型且引用类型没有被重新赋值时，才会影响到外部的变量。
static void ChangeValue(int value){
value = 1;
}
static void ChangeArrValue(int[] arr){
arr = 1;
}
static void ChangeArr(int[] arr){
arr = new int[]{1};
}
#endregion
#region ref和out的使用
//ref
static void ChangeValueRef(ref int value){
value = 1;
}
static void ChangeArrRef(ref int[] arr){
arr = new int[]{1};
}
//out
static void ChangeValueOut(out int value){
value = 2;
}
static void ChangeArrOut(out int[] arr){
arr = new int[]{2};
}
#endregion
static void Main(string[] args)
{
int value = 0;
//传入函数的只是这个变量，没有返回，所以值不变
ChangeValue(value);
Console.WriteLine("正常传入参数,值不变: "+value); // Output: 0
ChangeValueRef(ref value);
Console.WriteLine("加了ref关键字,值变了: "+value); // Output: 1
ChangeValueOut(out value);
Console.WriteLine("加了out关键字,值变了: "+value); // Output: 2
int[] arr1 = new int;
//传入函数的是arr的地址，arr和arr1都指向arr1的地址，所以值会变
ChangeArrValue(arr1);
Console.WriteLine(arr1); // Output: 1
int[] arr2 = new int;
//因为函数ChangeArr中arr新开辟了一个地址，与传入的数组的地址不再有关联，所以值不变
ChangeArr(arr2);
Console.WriteLine("正常传入参数,值不变: "+arr2); // Output: 0
ChangeArrRef(ref arr2);
Console.WriteLine("加了ref关键字,值变了: "+arr2); // Output: 1
ChangeArrOut(out arr2);
Console.WriteLine("加了out关键字,值变了: "+arr2); // Output: 2
}
}
来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！
页:
[1]