引言
烦躁死了,我最近一直在疯狂踩坑c#的引用类型值类型,虽然在c++中也学过那个String类的深度拷贝和浅拷贝,涉及过这部分的知识点。但是这里我还是想针对c#的语言特性做个总结。
为什么,因为老子肉眼定位不到自己的bug,但是知道肯定是因为这个特性没用好导致的。
概念介绍
引用类型:基类为
Objcet
值类型:均隐式派生自
System.ValueTyp
值类型:
byte,short,int,long,float,double,decimal,char,bool 和 struct 统称为值类型。
引用类型:
string 和 class统称为引用类型。
-
值类型变量声明后,不管是否已经赋值,编译器为其分配内存。
-
引用类型当声明一个类时,只在栈中分配一小片内存用于容纳一个地址,而此时并没有为其分配堆上的内存空间。当使用 new 创建一个类的实例时,分配堆上的空间,并把堆上空间的地址保存到栈上分配的小片空间中。
-
值类型的实例通常是在线程栈上分配的(静态分配),但是在某些情形下可以存储在堆中。 引用类型的对象总是在进程堆中分配(动态分配)。
值类型在栈内分配空间大小因变量类型而异;
引用类型在栈内的空间大小相同;
概念深化
C#有以下一些引用类型:
- 数组(派生于System.Array)
用户用定义的以下类型:
- 类:class(派生于System.Object);
- 接口:interface(接口不是一个“东西”,所以不存在派生于何处的问题。Anders在《C# Programming
Language》中说,接口只是表示一种约定[contract]); - 委托:delegate(派生于System.Delegate)
- object(System.Object的别名);
- 字符串:string(System.String的别名)
可以看出:
- 引用类型与值类型相同的是,结构体也可以实现接口;
- 引用类型可以派生出新的类型,而值类型不能;
- 引用类型可以包含null值,值类型不能(可空类型功能允许将 null 赋给值类型);
- 引用类型变量的赋值只复制对对象的引用,而不复制对象本身。而将一个值类型变量赋给另一个值类型变量时,将复制包含的值。
对于最后一条,经常混淆的是string。我曾经在一本书的一个早期版本上看到String变量比string变量效率高;我还经常听说String是引用类型,string是值类型,等等。例如:
string s1 = "Hello, ";
string s2 = “world!”;
string s3 = s1 + s2;//s3 is “Hello, world!”
这确实看起来像一个值类型的赋值。再如:
string s1 = “a”;
string s2 = s1;
s1 = “b”;//s2 is still “a”
改变s1的值对s2没有影响。这更使string看起来像值类型。实际上,这是运算符重载的结果,当s1被改变时,.NET在托管堆上为s1重新分配了内存。这样的目的,是为了将做为引用类型的string实现为通常语义下的字符串。
使用情况分析
经常听说,并且经常在书上看到:值类型部署在栈上,引用类型部署在托管堆上。实际上并没有这么简单。
MSDN上说:托管堆上部署了所有引用类型。这很容易理解。当创建一个应用类型变量时:
object reference = new object();
关键字new将在托管堆上分配内存空间,并返回一个该内存空间的地址。左边的reference位于栈上,是一个引用,存储着一个内存地址;而这个地址指向的内存(位于托管堆)里存储着其内容(一个System.Object的实例)。下面为了方便,简称引用类型部署在托管推上。
数组
考虑数组:
int[] reference = new int[100];
根据定义,数组都是引用类型,所以int数组当然是引用类型(即reference.GetType().IsValueType为false)。
而int数组的元素都是int,根据定义,int是值类型(即reference[i].GetType().IsValueType为true)。那么引用类型数组中的值类型元素究竟位于栈还是堆?
如果用WinDbg去看reference[i]在内存中的具体位置,就会发现它们并不在栈上,而是在托管堆上。
实际上,对于数组:
TestType[] testTypes = new TestType[100];
如果TestType是值类型,则会一次在托管堆上为100个值类型的元素分配存储空间,并自动初始化这100个元素,将这100个元素存储到这块内存里。
如果TestType是引用类型,则会先在托管堆为testTypes分配一次空间,并且这时不会自动初始化任何元素(即testTypes[i]均为null)。等到以后有代码初始化某个元素的时候,这个引用类型元素的存储空间才会被分配在托管堆上。
类型嵌套
结合unity的理解
Vector3本质是结构体(struct),所以是值类型。
组件(component)本质是类(class),所以是引用类型。
UnityEngine.Object类
使用情况分析深化
重点来了同志们,啊,我的眼睛,我的脑袋…我被恶心死了
无论是浅拷贝与深拷贝,C#都将源对象中的所有字段复制到新的对象中。不过,对于值类型字段,引用类型字段以及字符串类型字段的处理,两种拷贝方式存在一定的区别(见下表)。
一般对C#中传值调用和传引用调用的理解:
- 如果传递的参数是基元类型(int,float等)或结构体(struct),那么就是传值调用。
- 如果传递的参数是类(class)那么就是传引用调用。
- 如果传递的参数前有ref或者out关键字,那么就是传引用调用。
验证示例的代码如下:
using System;
public class ArgsByRefOrValue
{
public static void Main(string[] args)
{
// 实验1. 传值调用--基元类型
int i = 10;
Console.WriteLine("before call ChangeByInt: i = " + i.ToString());
ChangeByInt(i);
Console.WriteLine("after call ChangeByInt: i = " + i.ToString());
Console.WriteLine("==============================================");
// 实验2. 传值调用--结构体
Person_val p_val = new Person_val();
p_val.name = "old val name";
Console.WriteLine("before call ChangeByStruct: p_val.name = " + p_val.name);
ChangeByStruct(p_val);
Console.WriteLine("after call ChangeByStruct: p_val.name = " + p_val.name);
Console.WriteLine("==============================================");
// 实验3. 传引用调用--类
Person_ref p_ref = new Person_ref();
p_ref.name = "old ref name";
Console.WriteLine("before call ChangeByClass: p_ref.name = " + p_ref.name);
ChangeByClass(p_ref);
Console.WriteLine("after call ChangeByClass: p_ref.name = " + p_ref.name);
Console.WriteLine("==============================================");
// 实验4. 传引用调用--利用ref
Person_ref p = new Person_ref();
p.name = "old ref name";
Console.WriteLine("before call ChangeByClassRef: p.name = " + p.name);
ChangeByClassRef(ref p);
Console.WriteLine("after call ChangeByClassRef: p.name = " + p.name);
Console.ReadKey(true);
}
static void ChangeByInt(int i)
{
i = i + 10;
Console.WriteLine("when calling ChangeByInt: i = " + i.ToString());
}
static void ChangeByStruct(Person_val p_val)
{
p_val.name = "new val name";
Console.WriteLine("when calling ChangeByStruct: p_val.name = " + p_val.name);
}
static void ChangeByClass(Person_ref p_ref)
{
p_ref.name = "new ref name";
Console.WriteLine("when calling ChangeByClass: p_ref.name = " + p_ref.name);
}
static void ChangeByClassRef(ref Person_ref p)
{
p.name = "new ref name";
Console.WriteLine("when calling ChangeByClassRef: p.name = " + p.name);
}
}
public struct Person_val
{
public string name;
}
public class Person_ref
{
public string name;
}
看起来似乎上面代码中实验3和实验4是一样的,即对于类(class)来说,不管加不加ref或out,都是传引用调用。
其实,这只是表面的现象,只要稍微改一下代码,结果就不一样了。
修改上面代码,再增加两个实验。
using System;
public class ArgsByRefOrValue
{
public static void Main(string[] args)
{
// 实验1. 传值调用--基元类型
int i = 10;
Console.WriteLine("before call ChangeByInt: i = " + i.ToString());
ChangeByInt(i);
Console.WriteLine("after call ChangeByInt: i = " + i.ToString());
Console.WriteLine("==============================================");
// 实验2. 传值调用--结构体
Person_val p_val = new Person_val();
p_val.name = "old val name";
Console.WriteLine("before call ChangeByStruct: p_val.name = " + p_val.name);
ChangeByStruct(p_val);
Console.WriteLine("after call ChangeByStruct: p_val.name = " + p_val.name);
Console.WriteLine("==============================================");
// 实验3. 传引用调用--类
Person_ref p_ref = new Person_ref();
p_ref.name = "old ref name";
Console.WriteLine("before call ChangeByClass: p_ref.name = " + p_ref.name);
ChangeByClass(p_ref);
Console.WriteLine("after call ChangeByClass: p_ref.name = " + p_ref.name);
Console.WriteLine("==============================================");
// 实验4. 传引用调用--利用ref
Person_ref p = new Person_ref();
p.name = "old ref name";
Console.WriteLine("before call ChangeByClassRef: p.name = " + p.name);
ChangeByClassRef(ref p);
Console.WriteLine("after call ChangeByClassRef: p.name = " + p.name);
Console.WriteLine("==============================================");
// 实验5. 传引用调用--类 在调用的函数重新new一个对象
Person_ref p_ref_new = new Person_ref();
p_ref_new.name = "old new ref name";
Console.WriteLine("before call ChangeByClassNew: p_ref_new.name = " + p_ref_new.name);
ChangeByClassNew(p_ref_new); //注意区别这里
Console.WriteLine("after call ChangeByClassNew: p_ref_new.name = " + p_ref_new.name);
Console.WriteLine("==============================================");
// 实验6. 传引用调用--利用ref 在调用的函数重新new一个对象
Person_ref p_new = new Person_ref();
p_new.name = "old new ref name";
Console.WriteLine("before call ChangeByClassRefNew: p_new.name = " + p_new.name);
ChangeByClassRefNew(ref p_new);
Console.WriteLine("after call ChangeByClassRefNew: p_new.name = " + p_new.name);
Console.ReadKey(true);
}
static void ChangeByInt(int i)
{
i = i + 10;
Console.WriteLine("when calling ChangeByInt: i = " + i.ToString());
}
static void ChangeByStruct(Person_val p_val)
{
p_val.name = "new val name";
Console.WriteLine("when calling ChangeByStruct: p_val.name = " + p_val.name);
}
static void ChangeByClass(Person_ref p_ref)
{
p_ref.name = "new ref name";
Console.WriteLine("when calling ChangeByClass: p_ref.name = " + p_ref.name);
}
static void ChangeByClassRef(ref Person_ref p)
{
p.name = "new ref name";
Console.WriteLine("when calling ChangeByClassRef: p.name = " + p.name);
}
static void ChangeByClassNew(Person_ref p_ref_new)
{
p_ref_new = new Person_ref(); //这样不改变 p_ref_newp_ref_new
p_ref_new.name = "new ref name";
Console.WriteLine("when calling ChangeByClassNew: p_ref_new.name = " + p_ref_new.name);
}
static void ChangeByClassRefNew(ref Person_ref p_new)
{
p_new = new Person_ref();
p_new.name = "new ref name";
Console.WriteLine("when calling ChangeByClassRefNew: p_new.name = " + p_new.name);
}
}
public struct Person_val
{
public string name;
}
public class Person_ref
{
public string name;
}
停一下,看吐了没。我看吐了。我要截个图来分析。。(这就舒服多了…)
内存分析:
实验3:
从图中我们可以看出实参new出来之后就在托管堆上分配了内存,并且在栈上保存了对象的指针。
调用函数ChangeByClass后,由于没有ref参数,所以将栈上的实参p_val拷贝了一份作为形参,注意这里p_val(实参)和p_val(形参)是指向托管堆上的同一地址。
所以说没有ref时,即使参数为引用类型(class)时,也可算是一种传值调用,这里的值就是托管堆中对象的地址(0x1000)。
调用函数ChangeByClass后,通过p_val(形参)修改了name属性的值,由于p_val(实参)和p_val(形参)是指向托管堆上的同一地址,所以函数外的p_val(实参)的name属性也被修改了。
实验5:
函数ChangeByClassNew中,对p_val(形参)重新分配了内存(new操作),使其指向了新的地址(0x1100),如下图:
所以p_val(形参)的name属性改了时候,p_val(实参)的name属性还是没变。
实验6:
参数中加了ref关键字之后,其实传递的不是托管堆中对象的地址(0x1000),而是栈上p_val(实参)的地址(0x0001)。
所以这里实参和形参都是栈上的同一个东西,没有什么区别了。我觉得这才是真正的传引用调用。
然后调用了函数ChangeByClassRefNew,函数中对p_val(形参)重新分配了内存(new操作),使其指向了新的地址(0x1100)。
由于p_val(形参)就是p_val(实参),所以p_val(形参)的name属性改变后,函数ChangeByClassRefNew外的p_val(实参)的name属性也被改变了。
而原先分配的对象(地址0x1000)其实已经没有被引用了,随时会被GC回收。
其实就是和c++那套指针,堆栈一样一样。。。就是c#把* & 这些操作符都隐藏起来了,他奶奶的。一点都不直观。
总结
啊!恶心死了!我还是想写c++…
unity为啥不用c++做开发语言!!!!!!!!!!!!!!!