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

引用相等

介绍

在 C# 中可以通过 object.ReferenceEquals(obj1, obj2) 方法来判断两个变量引用的是不是同一个地址，如果是，那么就是引用相等。

引用相等是针对引用类型变量来说的，因为值类型变量存储在栈内存，不存在引用情况。

普通引用类型

1、有如下实体类：

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; }
    }
}

2、编写如下代码运行：

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

var p2 = p1;

var p3 = new Person();
p3.Id = ;
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 不一样呢？看如下示例：

 string s1 = "hello";
 string s2 = "hello";
 string s3 = new string(new char[] {'h', 'e', 'l', 'l', 'o'});
 Console.WriteLine(object.ReferenceEquals(s1,s2)); // true
 Console.WriteLine(object.ReferenceEquals(s1,s3)); // false
 Console.WriteLine(s1 == s2); // true
 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 做了字符串拘留池，在一些情况下对于字符串对象进行了重用。

运算符重载

介绍

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

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

示例

 internal class Program
 {
     public static void Main(string[] args)
     {
         var p1 = new Person();
         p1.Id = ;
         p1.Name = "张三";

         var p2 = p1;

         var p3 = new Person();
         p3.Id = ;
         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); // true
     }

     class Person
     {
         // == 与 != 必须成对重载
         public static bool operator ==(Person left, Person right)
         {
             return left.Id == right.Id && left.Name == right.Name;
         }

         public static bool operator !=(Person left, Person right)
         {
             return left.Id != right.Id || left.Name != right.Name;
         }

         private int id;
         private string name;

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

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

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

更多可参考微软官方文档