【oj每周推荐】谈谈.Net里的引用
上星期有个贴子string 赋值问题，从里面的回复来看，很多人都没有明白.Net里的“引用”，在此，对于那些还没搞清楚什么是值类型，什么是引用类型的人我不想再说些什么，只能建议他们多看看书。
首先问大家一个选择题，在写程序的时候，经常会碰到的一个异常就是：System.NullReferenceException ，也就是常见的“未将对象引用设置到对象的实例”，见可能见得多了，但可能还有很多人不明白这句话什么意思，那么，大家先来断断句，看看以下几个，你觉得哪个是正确的？
A、未将 对象 引用设置到 对象的 实例
B、未将 对象引用 设置到 对象的 实例
C、未将 对象 引用 设置到 对象的 实例
给出你的选择后，再看看下面这个例子：
MyClass mc1 = new MyClass();//MyClass为一个自定义的类
MyClass mc2 = mc1;
int i = 1;
int j = i;
以上四句代码在运行的时候，你觉得总共会创建几个对象？
大家都知道关键字ref和out 用在方法的参数前面，会导致参数通过引用来传递，那这里的“通过引用来传递”你是怎么理解的？
欢迎大家踊跃发言
[解决办法]
B 喽
MyClass mc1 = new MyClass(); // 在托管堆上创建对象，并使mc1引用到该对象MyClass mc2 = mc1; // 将mc2引用到mc1引用的对象，此时MyClass.Equals(mc2, mc1)为trueint i = 1; // int 是值类型，在栈上存储。 i 为一个变量int j = i; // 值类型 j 获取 值类型 i 的值的副本
[解决办法]
object o = new object();
[解决办法]
MyClass mc1 = new MyClass();//MyClass为一个自定义的类MyClass mc2 = mc1;int i = 1;int j = i;
[解决办法]
MyClass mc1 = new MyClass(); // 在托管堆上创建对象，并使mc1引用到该对象MyClass mc2 = mc1; // 将mc2引用到mc1引用的对象，此时MyClass.Equals(mc2, mc1)为trueint i = 1; // int 是值类型，在栈上存储。 i 为一个变量int j = i; // 值类型 j 获取 值类型 i 的值的副本
[解决办法]
个人感觉是 选择B
第二问是 3个对象， 一个类，两个变量
[解决办法]
B
3个对象，1个mtclass,2个int
通过引用来传递时传递的参数本身，如果不加这几个关键字是传的一份拷贝，效率变低。
看来我和大家理解的都是一样的，
[解决办法]
三个。
但是，C#无处不对像，无处不引用，int 只不过是System.Int32结构体的一种alias（在.net平台下是，int 只不过是C#的关键字，但是.net只认System.Int32），那么无论 i 还是 j 都是这一类型的结构体的实例罢了，.net为了让他们表现得像一个“值”，所以会分别创建他们的复本。但我的理解，它们与栈变量无关，它们还是对像，只不过装B装得像一个值。在.net中，只有struct和class两种，没有什么byte什么int之类的东西。而它们两个，只不过看起来有那么点儿差别，实际上都是一个东西，只不过struct需要满足“值语义”。
C#.net对于每个对像，都有两套备案，一个是对像实例，一个是引用表映射，使用的时候只不过在不断地调用这个引用表中的映射，而不去动实例本身，一个类对像的成员可以在内存中满地都是，由引用表来将之总结起来使之看起来像一个整体。
像ref、out这种……这种……
[解决办法]
我认为：
B
3个对象！
[解决办法]
选择B了，
我不知道，我说的对不对。严格的说，建创了5个对象。
MyClass mc1 = new MyClass(); // 在托管堆上创建了一个MyClass对象，在堆栈中创建了mc1变量，mc1的值是MyClass对象在堆中的地址（引用）
MyClass mc2 = mc1; // 在堆栈中创建了mc2,将mc1的值赋给了mc2（是MyClass对象在堆中的地址）。
int i = 1; // int 是值类型，在堆栈上存储。 i 为一个变量
int j = i; // 值类型 j 获取 值类型 i 的值的副本
[解决办法]
选择B了，
我不知道，我说的对不对。严格的说，建创了5个对象。
MyClass mc1 = new MyClass(); // 在托管堆上创建了一个MyClass对象，在堆栈中创建了mc1变量，mc1的值是MyClass对象在堆中的地址（引用）
MyClass mc2 = mc1; // 在堆栈中创建了mc2,将mc1的值赋给了mc2（是MyClass对象在堆中的地址）。
int i = 1; // int 是值类型，在堆栈上存储。 i 为一个变量
int j = i; // 值类型 j 获取 值类型 i 的值的副本
[解决办法]
B
3个对象
引用本质上应该就是指针的传递
“未将对象引用设置到对象的实例”也就是说使用了未赋值的空指针变量
[解决办法]
B
3个对象。
如果对，楼主还请给分啊。哈哈
[解决办法]
严格来讲，应该是创建了5个对象。。
//会在托管堆上创一个对象MyCalss。。 比如它在托管堆上的地址是0x000011//同时也会在栈上创建一个变量mc1，它的值就是MyCalss的地址0x000011MyClass mc1 = New MyCalss() MyClass mc1 //在栈上栈上创建一个变量mc2，它的值就是MyCalss的地址0x000011MyClass mc2 //在栈上创建一个变量i，其值就是1int i = 1//在栈上创建一个变量i，其值复制i的值1int j=i
[解决办法]
在c#里，用ref就表示传递变量的地址,对于值类型比较好理解。。但是对于引用类型通过下面这个例子就容易理解了
using System;using System.Collections.Generic;using System.Text;namespace ConsoleApplication1{ class Person { private int num; public int Num { get { return num; } set { num = value; } } } class Program { static void Main(string[] args) { Person person = new Person(); person.Num = 1; SetPersonNum(person); //引用类型直接传递 Console.WriteLine(person.Num); //person.Num是1 SetPersonNum(ref person); //引用类型地址传递 Console.WriteLine(person.Num); //person.Num是5 Console.ReadKey(); } private static void SetPersonNum(Person person) { Person newPerson = person; person = new Person(); person.Num = 5; } private static void SetPersonNum(ref Person person) { Person newPerson = person; person = new Person(); person.Num = 5; } }}
[解决办法]
A、未将 对象 引用设置到 对象的 实例
B、未将 对象引用 设置到 对象的 实例
C、未将 对象 引用 设置到 对象的 实例
给出你的选择后，再看看下面这个例子：
MyClass mc1 = new MyClass();//MyClass为一个自定义的类
MyClass mc2 = mc1;
int i = 1;
int j = i;
以上四句代码在运行的时候，你觉得总共会创建几个对象？
大家都知道关键字ref和out 用在方法的参数前面，会导致参数通过引用来传递，那这里的“通过引用来传递”你是怎么理解的？
======================================================================
题目我选B
创建了三个实例吧 创建一个实例 使新创建的mc1实例指向这个实例 再使新创建的mc2实例指向mc1实例
通过引用来传递 个人是像指针那样来理解的 传的是地址
[解决办法]
我也选择B,三个对象
[解决办法]
以下是java中的几个经典初学问题。考虑java和.net的很多相似，初学者很有必要看看:
问题一：我声明了什么！
String s = "Hello world!";
许多人都做过这样的事情，但是，我们到底声明了什么？回答通常是：一个String，内容是“Hello world!”。这样模糊的回答通常是概念不清的根源。如果要准确的回答，一半的人大概会回答错误。
这个语句声明的是一个指向对象的引用，名为“s”，可以指向类型为String的任何对象，目前指向"Hello world!"这个String类型的对象。这就是真正发生的事情。我们并没有声明一个String对象，我们只是声明了一个只能指向String对象的引用变量。所以，如果在刚才那句语句后面，如果再运行一句：
String string = s;
我们是声明了另外一个只能指向String对象的引用，名为string，并没有第二个对象产生，string还是指向原来那个对象，也就是，和s指向同一个对象。
问题二："=="和equals方法究竟有什么区别？
==操作符专门用来比较变量的值是否相等。比较好理解的一点是：
int a=10;
int b=10;
则a==b将是true。
但不好理解的地方是：
String a=new String("foo");
String b=new String("foo");
则a==b将返回false。
根据前一帖说过，对象变量其实是一个引用，它们的值是指向对象所在的内存地址，而不是对象本身。a和b都使用了new操作符，意味着将在内存中产生两个内容为"foo"的字符串，既然是“两个”，它们自然位于不同的内存地址。a和b的值其实是两个不同的内存地址的值，所以使用"=="操作符，结果会是 false。诚然，a和b所指的对象，它们的内容都是"foo"，应该是“相等”，但是==操作符并不涉及到对象内容的比较。
对象内容的比较，正是equals方法做的事。
看一下Object对象的equals方法是如何实现的：
boolean equals(Object o){
return this==o;
}
Object 对象默认使用了==操作符。所以如果你自创的类没有覆盖equals方法，那你的类使用equals和使用==会得到同样的结果。同样也可以看出， Object的equals方法没有达到equals方法应该达到的目标：比较两个对象内容是否相等。因为答案应该由类的创建者决定，所以Object把这个任务留给了类的创建者。
看一下一个极端的类：
Class Monster{
private String content;
...
boolean equals(Object another){ return true;}
}
我覆盖了equals方法。这个实现会导致无论Monster实例内容如何，它们之间的比较永远返回true。
所以当你是用equals方法判断对象的内容是否相等，请不要想当然。因为可能你认为相等，而这个类的作者不这样认为，而类的equals方法的实现是由他掌握的。如果你需要使用equals方法，或者使用任何基于散列码的集合（HashSet,HashMap,HashTable），请察看一下java doc以确认这个类的equals逻辑是如何实现的。
问题三：String到底变了没有？
没有。因为String被设计成不可变(immutable)类，所以它的所有对象都是不可变对象。请看下列代码：
String s = "Hello";
s = s + " world!";
s 所指向的对象是否改变了呢？从本系列第一篇的结论很容易导出这个结论。我们来看看发生了什么事情。在这段代码中，s原先指向一个String对象，内容是 "Hello"，然后我们对s进行了+操作，那么s所指向的那个对象是否发生了改变呢？答案是没有。这时，s不指向原来那个对象了，而指向了另一个 String对象，内容为"Hello world!"，原来那个对象还存在于内存之中，只是s这个引用变量不再指向它了。
通过上面的说明，我们很容易导出另一个结论，如果经常对字符串进行各种各样的修改，或者说，不可预见的修改，那么使用String来代表字符串的话会引起很大的内存开销。因为 String对象建立之后不能再改变，所以对于每一个不同的字符串，都需要一个String对象来表示。这时，应该考虑使用StringBuffer类，它允许修改，而不是每个不同的字符串都要生成一个新的对象。并且，这两种类的对象转换十分容易。
同时，我们还可以知道，如果要使用内容相同的字符串，不必每次都new一个String。例如我们要在构造器中对一个名叫s的String引用变量进行初始化，把它设置为初始值，应当这样做：
public class Demo {
private String s;
...
public Demo {
s = "Initial Value";
}
...
}
而非
s = new String("Initial Value");
后者每次都会调用构造器，生成新对象，性能低下且内存开销大，并且没有意义，因为String对象不可改变，所以对于内容相同的字符串，只要一个String对象来表示就可以了。也就说，多次调用上面的构造器创建多个对象，他们的String类型属性s都指向同一个对象。
上面的结论还基于这样一个事实：对于字符串常量，如果内容相同，Java认为它们代表同一个String对象。而用关键字new调用构造器，总是会创建一个新的对象，无论内容是否相同。
至于为什么要把String类设计成不可变类，是它的用途决定的。其实不只String，很多Java标准类库中的类都是不可变的。在开发一个系统的时候，我们有时候也需要设计不可变类，来传递一组相关的值，这也是面向对象思想的体现。不可变类有一些优点，比如因为它的对象是只读的，所以多线程并发访问也不会有任何问题。当然也有一些缺点，比如每个不同的状态都要一个对象来代表，可能会造成性能上的问题。所以Java标准类库还提供了一个可变版本，即 StringBuffer。
[解决办法]
C# 下的变量:
可以区分为 值类型变量, 和引用类型变量, 注意这里的 '量'.
object o = null;
int i = 0;
o 和 i 都是 C# 下的变量.
我们知道, 是变量就有值. 那么上面 o i 的值分别是什么?
.......
C# 中的变量赋值, 参数传递, 以及函数返回值:
...
其实也瞒无聊的, 这些问题.
[解决办法]
B
2个对象：MyClass和i
4个引用： mc1,mc2,i,j
[解决办法]
很多细小的地方，不仔细琢磨，经常让人搞不清。
这个地方，我认为是在栈上创建了4个变量，两个引用类型MYCLASS变量，和两个值类型变量。值变量就不说了，托管堆并不会花大力气去处理它的善后事。对于两个MYCLASS变量，它们只是地址，在缺省域的GC堆上分配一块内存，创建一个MYCLASS的实例，两个MYCLASS变量都指向GC堆中该实例的TYPEHANDLER。
之所以会经常遇到“未将对象的引用设置到对象的实例”这个异常，就是因为创建了引用类型的变量，但该变量只是保持了创建时的初始化值，并未指向任何在GC堆或LOH堆上分配的实例，所以在调用该变量时，会引发这个异常。
仅供参考。
[解决办法]
B、未将 对象引用 设置到 对象的 实例
----
1个对象，另外在栈上占用了4个字用来存储两个MyClass的指针和两个int数
----
通过引用来传递，其实是直接通过栈进行值传递，对引用类型来说就是它的指针，对值类型来说就是它本身
[解决办法]