C#基础增强(6)之引用相等与运算符重载

引用相等

介绍

在 C# 中能够经过 object.ReferenceEquals(obj1, obj2) 方法来判断两个变量引用的是否是同一个地址，若是是，那么就是引用相等。

引用相等是针对引用类型变量来讲的，由于值类型变量存储在栈内存，不存在引用状况。

普通引用类型

一、有以下实体类：

class Person
{
    private int id;
    private string name;

    public int Id
    {
        get { return id; }
        set { id = value; }
    }

    public string Name
    {
        get { return name; }
        set { name = value; }
    }
}

二、编写以下代码运行：

var p1 = new Person();
p1.Id = 1;
p1.Name = "张三";

var p2 = p1;

var p3 = new Person();
p3.Id = 1;
p3.Name = "张三";

Console.WriteLine(object.ReferenceEquals(p1,p2)); // true
Console.WriteLine(object.ReferenceEquals(p1,p3)); // false
Console.WriteLine(p1 == p2); // true
Console.WriteLine(p1 == p3); // false

能够看到，类的实例用 obj1 == obj2 比较与 object.ReferenceEquals(obj1, obj2) 的结果是同样的。

结论：对于普通引用类型来使用 == 来比较两个引用类型变量也是比较它们是否是引用同一个地址。

不同的引用类型-string

为何说 string 不同呢？看以下示例：

1 string s1 = "hello";
2 string s2 = "hello";
3 string s3 = new string(new char[] {'h', 'e', 'l', 'l', 'o'});
4 Console.WriteLine(object.ReferenceEquals(s1,s2)); // true
5 Console.WriteLine(object.ReferenceEquals(s1,s3)); // false
6 Console.WriteLine(s1 == s2); // true
7 Console.WriteLine(s1 == s3); //true

因为字符串拘留池的缘由， s1 和 s2 确定是引用同一个地址的，因此第 4 行和第 6 行结果都为 true 。

再看第 5 行和第 7 行，由于 s3 是手动 new 的一个对象，因此 s1 与 s3 确定不是同一个引用，因此第 5 行结果为 false 。可是再看第 7 行， s1 == s3 的结果为 true 。

结论：对于 string 类型，使用 == 比较的是字符串的实际内容，而不是它们的引用地址。能够理解为， string 类对 == 运算符方法进行了重载。

字符串拘留池：也叫字符串暂存池、缓冲池。字符串是引用类型，程序中常会存在大量的字符串对象，若是每次都建立一个字符串对象，会比较浪费内存、性能低下，所以 CLR 作了字符串拘留池，在一些状况下对于字符串对象进行了重用。

相关面试题

下面的代码一共建立了几个字符串对象？

string s1 = "hello";
string s2 = "hello";
string s3 = new string(new char[] {'h', 'e', 'l', 'l', 'o'});

答案：建立了两个对象， s1 和 s2 引用的是同一个对象 "hello" ，另外一个是 s3 指向的对象。

运算符重载

介绍

C# 容许用户定义的类型经过使用 operator 关键字定义静态成员函数来重载运算符。注意必须用 public 修饰且必须是类的静态的方法。但并不是全部内置运算符均可以被重载，详见下表：

运算符	可重载性
+、-、!、~、++、--、true、false	能够重载这些一元运算符， true和false运算符必须成对重载
+、-、*、/、%、&、|、^、<<、>>	能够重载这些二元运算符
==、!=、<、>、<=、>=	能够重载比较运算符，必须成对重载
&&、||	不能重载条件逻辑运算符，但可使用可以重载的&和|进行计算
[]	不能重载数组索引运算符，但能够定义索引器
()	不能重载转换运算符，但能够定义新的转换运算符（请参见 explicit 和 implicit）
+=、-=、*=、/=、%=、&=、|=、^=、<<=、>>=	不能显式重载赋值运算符，在重写单个运算符如+、-、%时，它们会被  隐式重写
=、.、?:、->、new、is、sizeof、typeof	不能重载这些运算符

示例

 1 internal class Program
 2 {
 3     public static void Main(string[] args)
 4     {
 5         var p1 = new Person();
 6         p1.Id = 1;
 7         p1.Name = "张三";
 8 
 9         var p2 = p1;
10 
11         var p3 = new Person();
12         p3.Id = 1;
13         p3.Name = "张三";
14 
15         Console.WriteLine(object.ReferenceEquals(p1,p2)); // true
16         Console.WriteLine(object.ReferenceEquals(p1,p3)); // false
17         Console.WriteLine(p1 == p2); // true
18         Console.WriteLine(p1 == p3); // true
19     }
20 
21     class Person
22     {
23         // == 与 != 必须成对重载
24         public static bool operator ==(Person left, Person right)
25         {
26             return left.Id == right.Id && left.Name == right.Name;
27         }
28 
29         public static bool operator !=(Person left, Person right)
30         {
31             return left.Id != right.Id || left.Name != right.Name;
32         }
33 
34         private int id;
35         private string name;
36 
37         public int Id
38         {
39             get { return id; }
40             set { id = value; }
41         }
42 
43         public string Name
44         {
45             get { return name; }
46             set { name = value; }
47         }
48     }
49 }

能够看到第 16 行的结果为 false ，说明 p1 和 p3 引用的不是同一个对象。而第 18 行的执行结果为 true ，说明此时经过 == 比较是执行了咱们重载的运算符方法。

更多可参考微软官方文档

相关面试题

在 C# 中， obj1 == obj2 的比较结果是否与 obj1.Equals(obj2) 相同？

答案：不必定，由于 == 比较其实是执行默认的运算符方法，除非 obj1 和 obj2 所属类型的 == 运算符方法和 Equals 方法的比较规则相同它们的结果才相同。