24 个解决方案
#1
数组是一种数据结构,它包含若干称为数组元素的变量。数组元素通过计算所得的索引访问。C# 数组从零开始建立索引,即数组索引从零开始。所有数组元素必须为同一类型,该类型称为数组的元素类型。数组元素可以是任何类型,包括数组类型。数组可以是一维数组或多维数组。数组类型是从抽象基类型 System.Array 派生的引用类型。
#2
可以传值,也可以传地址
看数组类型
看数组类型
#3
一般情况下,船引用
#4
没有什么一般情况,引用传递.无论什么类型的数组.
#5
C#的数组是类,类总是传引用
#6
static void changearray(int[] array)
{
array[0] = 1;
array[1] = 2;
}
上面这段代码是不是和
static void changearray(ref int[] array)
{
array[0] = 1;
array[1] = 2;
}
等同????
{
array[0] = 1;
array[1] = 2;
}
上面这段代码是不是和
static void changearray(ref int[] array)
{
array[0] = 1;
array[1] = 2;
}
等同????
#7
是的
不过,调用的时候稍有不同
定义一个
int[] test=new int[2];
第一个函数:
changearray(test);
第二个函数:
changearray(ref test);
结果是一样的
不过,调用的时候稍有不同
定义一个
int[] test=new int[2];
第一个函数:
changearray(test);
第二个函数:
changearray(ref test);
结果是一样的
#8
现在有一个新问题
比方说:
main()
{
int[] a = int[1];
func1(a);
func2(ref a);
}
static void func1(int[] array)
{
array = new int[10];
}
static void func2(ref int[] array)
{
array = new [10];
}
却不一样,在调用func1时,函数func1的操作没有反应到a中,
而在在调用func2时,函数func1的操作反应到a中了,a变成了一个10个长的数组,这又是为什么呢?????
比方说:
main()
{
int[] a = int[1];
func1(a);
func2(ref a);
}
static void func1(int[] array)
{
array = new int[10];
}
static void func2(ref int[] array)
{
array = new [10];
}
却不一样,在调用func1时,函数func1的操作没有反应到a中,
而在在调用func2时,函数func1的操作反应到a中了,a变成了一个10个长的数组,这又是为什么呢?????
#9
传引用和传值有的时候是有区别的
就象你刚才的那个示例
1、如果不用new的话,传值等价于引用
2、用new:如果是传值,只有new以前的代码会改变数组的内容,以后的将会被忽略;引用,只有new以后的代码会改变数组的内容,以前的将被忽略。
就象你刚才的那个示例
1、如果不用new的话,传值等价于引用
2、用new:如果是传值,只有new以前的代码会改变数组的内容,以后的将会被忽略;引用,只有new以后的代码会改变数组的内容,以前的将被忽略。
#10
修改过的代码可以证明:
main()
{
int[] a = int[1];
a[0]=1;//a[0]=1
func1(a);
//func1执行完之后,a[0]=2
func2(ref a);
//func2执行完之后,a[0]=3;a[1 .. 9]=0
}
static void func1(int[] array)
{
array[0]=2;
array = new int[10];
array[0]=3;
}
static void func2(ref int[] array)
{
array[0]=2;
array = new [10];
array[0]=3;
}
main()
{
int[] a = int[1];
a[0]=1;//a[0]=1
func1(a);
//func1执行完之后,a[0]=2
func2(ref a);
//func2执行完之后,a[0]=3;a[1 .. 9]=0
}
static void func1(int[] array)
{
array[0]=2;
array = new int[10];
array[0]=3;
}
static void func2(ref int[] array)
{
array[0]=2;
array = new [10];
array[0]=3;
}
#11
当然是引用,所谓函数,可以理解为主程序的一次中断调用
也就是说,是在堆栈中分配的一块区域来处理中断事件.如果
你指望去传递一个在堆内分配的一整段数据,简直是在发疯
是的,我想没人愿意那样做,所以把引用作为参数传递进去是
正确的选择.
也就是说,是在堆栈中分配的一块区域来处理中断事件.如果
你指望去传递一个在堆内分配的一整段数据,简直是在发疯
是的,我想没人愿意那样做,所以把引用作为参数传递进去是
正确的选择.
#12
用ref时传值并返回值,不用时不返回值
#13
hfayga(飞白)
我想你一定没有仔细阅读MSDN,无论是ref还是out所传递的都是引用
"关键字使方法引用传递到方法的同一个变量。"
以上为原文
我想你一定没有仔细阅读MSDN,无论是ref还是out所传递的都是引用
"关键字使方法引用传递到方法的同一个变量。"
以上为原文
#14
to HellMaster(李晋)
如果如你所说不得 HanYZ(飞虎) ( )说的这句话“ C#的数组是类,类总是传引用”是错的吧!
是吗???
如果如你所说不得 HanYZ(飞虎) ( )说的这句话“ C#的数组是类,类总是传引用”是错的吧!
是吗???
#15
对
#16
个人认为 确实是传递的引用,但当你加了ref以后,就相当于一个指向指针的指针。修改的内容是array这个指针的内容,而不是她所指向的内存区域的内容。
#17
hellmaster 说的是错误的,则跟new 是没有关系的。
#18
to nuobo(西木头)
我只是根据我实际的执行结果得出的结论
你可以自己去试试
我只是根据我实际的执行结果得出的结论
你可以自己去试试
#19
HellMaster(李晋)
你的例子并不能说明数组作为参数是传值的,所谓数组的值并应该包含数组的元素而你调用fun1后数组元素的值已经改变
另请参阅
ms-help://MS.VSCC/MS.MSDNVS.2052/csref/html/vclrfArraysPG.htm
数组类型是从抽象基类型 System.Array 派生的引用类型。
ms-help://MS.VSCC/MS.MSDNVS.2052/csref/html/vcreftypess.htm
值类型的变量存储数据,而引用类型的变量存储对实际数据的引用。
正如to nuobo(西木头)所述,数组变量本身存储的就是实际数据的引用,增加ref 导致传入引用的引用
对你的例子进一步修改可以看到
static void main()
{
int[] a = new int[1];
int[] b = a;
a[0]=1;//a[0]=1
//-------------------------同时b[0]=1
func1(a);
//func1执行完之后,a[0]=2
//-------------------------同时b[0]=2
func2(ref a);
//func2执行完之后,a[0]=3;a[1 .. 9]=0
//-------------------------然而b[0]=2
}
你的例子并不能说明数组作为参数是传值的,所谓数组的值并应该包含数组的元素而你调用fun1后数组元素的值已经改变
另请参阅
ms-help://MS.VSCC/MS.MSDNVS.2052/csref/html/vclrfArraysPG.htm
数组类型是从抽象基类型 System.Array 派生的引用类型。
ms-help://MS.VSCC/MS.MSDNVS.2052/csref/html/vcreftypess.htm
值类型的变量存储数据,而引用类型的变量存储对实际数据的引用。
正如to nuobo(西木头)所述,数组变量本身存储的就是实际数据的引用,增加ref 导致传入引用的引用
对你的例子进一步修改可以看到
static void main()
{
int[] a = new int[1];
int[] b = a;
a[0]=1;//a[0]=1
//-------------------------同时b[0]=1
func1(a);
//func1执行完之后,a[0]=2
//-------------------------同时b[0]=2
func2(ref a);
//func2执行完之后,a[0]=3;a[1 .. 9]=0
//-------------------------然而b[0]=2
}
#20
都可以
#21
还是不明白
static void func1(int[] array)
{
array[0]=2;
array = new int[10];
array[0]=3;
}
如果说是引用,那么array应该是一个指向数组值的指针,array就是一个指针了,对吧。那为什么array = new int[10];不行呢?array = new int[10]相应于我把一个指针的指向改变什么不行呢?
static void func1(int[] array)
{
array[0]=2;
array = new int[10];
array[0]=3;
}
如果说是引用,那么array应该是一个指向数组值的指针,array就是一个指针了,对吧。那为什么array = new int[10];不行呢?array = new int[10]相应于我把一个指针的指向改变什么不行呢?
#22
还是不明白
static void func1(int[] array)
{
array[0]=2;
array = new int[10];
array[0]=3;
}
-----------------------------------------------------
首先你将数组对象看做一个指针变量
如果不用ref
(&array1 != &array) // 两个指针变量的地址并不相等,但指向的内存地址是相同的
而你在函数中将array 指向新的内存地址,但事实上并未影响到array1
// 我用array来表示形参 array1表示实参
static void func1(int[] array)
{
array[0]=2;
array = new int[10];
array[0]=3;
}
-----------------------------------------------------
首先你将数组对象看做一个指针变量
如果不用ref
(&array1 != &array) // 两个指针变量的地址并不相等,但指向的内存地址是相同的
而你在函数中将array 指向新的内存地址,但事实上并未影响到array1
// 我用array来表示形参 array1表示实参
#23
首先数组变量的值就是数组数据的引用
所谓传引用指的是传递数组数据的应用(从数组数据的角度看)
所谓传值指的是传递数组数组变量的值,即数组指针的值(从数组变量的角度看)
大家着眼点不同罢了
所谓传引用指的是传递数组数据的应用(从数组数据的角度看)
所谓传值指的是传递数组数组变量的值,即数组指针的值(从数组变量的角度看)
大家着眼点不同罢了
#24
c#中数组是类,所以是传引用,
只有几个基础的是传值,除非用(ref)
只有几个基础的是传值,除非用(ref)
#1
数组是一种数据结构,它包含若干称为数组元素的变量。数组元素通过计算所得的索引访问。C# 数组从零开始建立索引,即数组索引从零开始。所有数组元素必须为同一类型,该类型称为数组的元素类型。数组元素可以是任何类型,包括数组类型。数组可以是一维数组或多维数组。数组类型是从抽象基类型 System.Array 派生的引用类型。
#2
可以传值,也可以传地址
看数组类型
看数组类型
#3
一般情况下,船引用
#4
没有什么一般情况,引用传递.无论什么类型的数组.
#5
C#的数组是类,类总是传引用
#6
static void changearray(int[] array)
{
array[0] = 1;
array[1] = 2;
}
上面这段代码是不是和
static void changearray(ref int[] array)
{
array[0] = 1;
array[1] = 2;
}
等同????
{
array[0] = 1;
array[1] = 2;
}
上面这段代码是不是和
static void changearray(ref int[] array)
{
array[0] = 1;
array[1] = 2;
}
等同????
#7
是的
不过,调用的时候稍有不同
定义一个
int[] test=new int[2];
第一个函数:
changearray(test);
第二个函数:
changearray(ref test);
结果是一样的
不过,调用的时候稍有不同
定义一个
int[] test=new int[2];
第一个函数:
changearray(test);
第二个函数:
changearray(ref test);
结果是一样的
#8
现在有一个新问题
比方说:
main()
{
int[] a = int[1];
func1(a);
func2(ref a);
}
static void func1(int[] array)
{
array = new int[10];
}
static void func2(ref int[] array)
{
array = new [10];
}
却不一样,在调用func1时,函数func1的操作没有反应到a中,
而在在调用func2时,函数func1的操作反应到a中了,a变成了一个10个长的数组,这又是为什么呢?????
比方说:
main()
{
int[] a = int[1];
func1(a);
func2(ref a);
}
static void func1(int[] array)
{
array = new int[10];
}
static void func2(ref int[] array)
{
array = new [10];
}
却不一样,在调用func1时,函数func1的操作没有反应到a中,
而在在调用func2时,函数func1的操作反应到a中了,a变成了一个10个长的数组,这又是为什么呢?????
#9
传引用和传值有的时候是有区别的
就象你刚才的那个示例
1、如果不用new的话,传值等价于引用
2、用new:如果是传值,只有new以前的代码会改变数组的内容,以后的将会被忽略;引用,只有new以后的代码会改变数组的内容,以前的将被忽略。
就象你刚才的那个示例
1、如果不用new的话,传值等价于引用
2、用new:如果是传值,只有new以前的代码会改变数组的内容,以后的将会被忽略;引用,只有new以后的代码会改变数组的内容,以前的将被忽略。
#10
修改过的代码可以证明:
main()
{
int[] a = int[1];
a[0]=1;//a[0]=1
func1(a);
//func1执行完之后,a[0]=2
func2(ref a);
//func2执行完之后,a[0]=3;a[1 .. 9]=0
}
static void func1(int[] array)
{
array[0]=2;
array = new int[10];
array[0]=3;
}
static void func2(ref int[] array)
{
array[0]=2;
array = new [10];
array[0]=3;
}
main()
{
int[] a = int[1];
a[0]=1;//a[0]=1
func1(a);
//func1执行完之后,a[0]=2
func2(ref a);
//func2执行完之后,a[0]=3;a[1 .. 9]=0
}
static void func1(int[] array)
{
array[0]=2;
array = new int[10];
array[0]=3;
}
static void func2(ref int[] array)
{
array[0]=2;
array = new [10];
array[0]=3;
}
#11
当然是引用,所谓函数,可以理解为主程序的一次中断调用
也就是说,是在堆栈中分配的一块区域来处理中断事件.如果
你指望去传递一个在堆内分配的一整段数据,简直是在发疯
是的,我想没人愿意那样做,所以把引用作为参数传递进去是
正确的选择.
也就是说,是在堆栈中分配的一块区域来处理中断事件.如果
你指望去传递一个在堆内分配的一整段数据,简直是在发疯
是的,我想没人愿意那样做,所以把引用作为参数传递进去是
正确的选择.
#12
用ref时传值并返回值,不用时不返回值
#13
hfayga(飞白)
我想你一定没有仔细阅读MSDN,无论是ref还是out所传递的都是引用
"关键字使方法引用传递到方法的同一个变量。"
以上为原文
我想你一定没有仔细阅读MSDN,无论是ref还是out所传递的都是引用
"关键字使方法引用传递到方法的同一个变量。"
以上为原文
#14
to HellMaster(李晋)
如果如你所说不得 HanYZ(飞虎) ( )说的这句话“ C#的数组是类,类总是传引用”是错的吧!
是吗???
如果如你所说不得 HanYZ(飞虎) ( )说的这句话“ C#的数组是类,类总是传引用”是错的吧!
是吗???
#15
对
#16
个人认为 确实是传递的引用,但当你加了ref以后,就相当于一个指向指针的指针。修改的内容是array这个指针的内容,而不是她所指向的内存区域的内容。
#17
hellmaster 说的是错误的,则跟new 是没有关系的。
#18
to nuobo(西木头)
我只是根据我实际的执行结果得出的结论
你可以自己去试试
我只是根据我实际的执行结果得出的结论
你可以自己去试试
#19
HellMaster(李晋)
你的例子并不能说明数组作为参数是传值的,所谓数组的值并应该包含数组的元素而你调用fun1后数组元素的值已经改变
另请参阅
ms-help://MS.VSCC/MS.MSDNVS.2052/csref/html/vclrfArraysPG.htm
数组类型是从抽象基类型 System.Array 派生的引用类型。
ms-help://MS.VSCC/MS.MSDNVS.2052/csref/html/vcreftypess.htm
值类型的变量存储数据,而引用类型的变量存储对实际数据的引用。
正如to nuobo(西木头)所述,数组变量本身存储的就是实际数据的引用,增加ref 导致传入引用的引用
对你的例子进一步修改可以看到
static void main()
{
int[] a = new int[1];
int[] b = a;
a[0]=1;//a[0]=1
//-------------------------同时b[0]=1
func1(a);
//func1执行完之后,a[0]=2
//-------------------------同时b[0]=2
func2(ref a);
//func2执行完之后,a[0]=3;a[1 .. 9]=0
//-------------------------然而b[0]=2
}
你的例子并不能说明数组作为参数是传值的,所谓数组的值并应该包含数组的元素而你调用fun1后数组元素的值已经改变
另请参阅
ms-help://MS.VSCC/MS.MSDNVS.2052/csref/html/vclrfArraysPG.htm
数组类型是从抽象基类型 System.Array 派生的引用类型。
ms-help://MS.VSCC/MS.MSDNVS.2052/csref/html/vcreftypess.htm
值类型的变量存储数据,而引用类型的变量存储对实际数据的引用。
正如to nuobo(西木头)所述,数组变量本身存储的就是实际数据的引用,增加ref 导致传入引用的引用
对你的例子进一步修改可以看到
static void main()
{
int[] a = new int[1];
int[] b = a;
a[0]=1;//a[0]=1
//-------------------------同时b[0]=1
func1(a);
//func1执行完之后,a[0]=2
//-------------------------同时b[0]=2
func2(ref a);
//func2执行完之后,a[0]=3;a[1 .. 9]=0
//-------------------------然而b[0]=2
}
#20
都可以
#21
还是不明白
static void func1(int[] array)
{
array[0]=2;
array = new int[10];
array[0]=3;
}
如果说是引用,那么array应该是一个指向数组值的指针,array就是一个指针了,对吧。那为什么array = new int[10];不行呢?array = new int[10]相应于我把一个指针的指向改变什么不行呢?
static void func1(int[] array)
{
array[0]=2;
array = new int[10];
array[0]=3;
}
如果说是引用,那么array应该是一个指向数组值的指针,array就是一个指针了,对吧。那为什么array = new int[10];不行呢?array = new int[10]相应于我把一个指针的指向改变什么不行呢?
#22
还是不明白
static void func1(int[] array)
{
array[0]=2;
array = new int[10];
array[0]=3;
}
-----------------------------------------------------
首先你将数组对象看做一个指针变量
如果不用ref
(&array1 != &array) // 两个指针变量的地址并不相等,但指向的内存地址是相同的
而你在函数中将array 指向新的内存地址,但事实上并未影响到array1
// 我用array来表示形参 array1表示实参
static void func1(int[] array)
{
array[0]=2;
array = new int[10];
array[0]=3;
}
-----------------------------------------------------
首先你将数组对象看做一个指针变量
如果不用ref
(&array1 != &array) // 两个指针变量的地址并不相等,但指向的内存地址是相同的
而你在函数中将array 指向新的内存地址,但事实上并未影响到array1
// 我用array来表示形参 array1表示实参
#23
首先数组变量的值就是数组数据的引用
所谓传引用指的是传递数组数据的应用(从数组数据的角度看)
所谓传值指的是传递数组数组变量的值,即数组指针的值(从数组变量的角度看)
大家着眼点不同罢了
所谓传引用指的是传递数组数据的应用(从数组数据的角度看)
所谓传值指的是传递数组数组变量的值,即数组指针的值(从数组变量的角度看)
大家着眼点不同罢了
#24
c#中数组是类,所以是传引用,
只有几个基础的是传值,除非用(ref)
只有几个基础的是传值,除非用(ref)