究竟是那里出现了问题--运算符

Question

using System;public class Student
{
   public string Name { get; set; }
   public int Age { get; set; }   public static Student operator ++(Student s)
    {
       return new Student(){ Name = s.Name , Age = s.Age + 1 };
     }   public override string ToString()
    {
       return "Name = " + Name + " , Age = " + Age;
    }
}public class Test
{
  static void Main()
   {
      Student original = new Student(){ Name = "Name" , Age = 30 };
      Student destination = original++;
   
      Console.WriteLine("Original " + original);
      Console.WriteLine("Destination " + destination);
   }
}打印输出:
         Original Name = Name , Age = 31
         Destination Name = Name , Age = 30
当我使用original++时调用重载的运算符,从而创建新的Student对象;
但是从结果来看,目标对象并未将年龄增加,而原始对象的年龄却受到了影响.
此处究其原因我实在不能理解是由于什么原因造成的。
请您观看后,对此进行多多指点!

Answer 1

Student original = new Student(){ Name = "Name" , Age = 30 };
      Student destination = original++; 
显然，你把original给了destination后才++的呀。
++在后面，就是本次运算完了才加的

Answer 2

return new Student(){ Name = s.Name , Age = s.Age + 1 }; 
这是什么？

Answer 3

Student destination = ++original; 
改成这样就都是31了

Answer 4

@Baesky:
正如您所说的那样,的确都输出了31,31.
但是我有一点还是不太明白?
1.>首先,在进行++original时,为什么在original的内部的Age字段同样受到了影响.在运算符的内部难道不只是引用该对象的字段吗?
2.>对于自定义的运算符来说,前增量和后增量同样遵守像C#提供的预定义的简单类型那样执行吗?
以上两点使我心中的疑惑,还请大家给于帮助!
在此致谢!

Answer 5

1.>首先,在进行++original时,为什么在original的内部的Age字段同样受到了影响.在运算符的内部难道不只是引用该对象的字段吗?
正因为是引用类型，所以改变才会影响到他。因为destination的地址跟original的地址相同呀。2.>对于自定义的运算符来说,前增量和后增量同样遵守像C#提供的预定义的简单类型那样执行吗? 
是的

Answer 6

1.>首先,在进行++original时,为什么在original的内部的Age字段同样受到了影响.在运算符的内部难道不只是引用该对象的字段吗?
你自己将++操作符重载了.而且每次调用该操作符,你都行New一个对象,浪费.
--> return new Student(){ Name = s.Name , Age = s.Age + 1 }; 2.>对于自定义的运算符来说,前增量和后增量同样遵守像C#提供的预定义的简单类型那样执行吗?
int i = 0; int j = 0;
i = j++;
i = 0 , j = 1int i = 0; int j = 0;
i = ++j;
i = 1 , j = 1运算符优先级:
http://msdn.microsoft.com/zh-cn/library/6a71f45d(VS.80).aspx

Answer 7

@Baesky:
向您所说,"因为destination的地址跟original的地址相同"
这里讲的我不是太懂,您所说的是original,destination两个变量引用的是同一个对象吗?
如果说是上面的那样的话,return new Student(){//...};
不是代表的创建了新的对象吗?
在运算符的内部不只是引用了original对象中包含的字段值来创建了新的对象吗?

Answer 8

顺序错了：应该这样：
Student original = new Student() { Name = "Name", Age = 30 };
Console.WriteLine("Original " + original);
Student destination = ++original;
Console.WriteLine("Destination " + destination); 

Answer 9

@Lost_Painting:
我的运算符重载可能让您见笑了,如果是您的话会采取一个什么样的重载方案呢?

Answer 10

@CHENFEIYANG2009:
您在进行打印输出时,进行了分开打印可能已经临时解决了这个问题。
但是,如果不进行分离的话,这两个年龄的输出为什么都是31呀?
original的Age字段是怎样受到的影响,能具体讲讲吗?

Answer 11

要知道对象是否是同一个很简单,对比其HashCode就知道了.
        Student destination = ++original;
==>
original1.HashCode != original2.HashCode 
original2.HashCode == destination
        Student destination = original++;
==>
original1.HashCode == original2.HashCode 
original2.HashCode != destination因此New 对象是不对的,应该来说 original1的HashCode自始至终都不应该改变,改变的只是其属性值.
修改后代码如下:(其中包含输出HashCode的)
using System;public class Student
{
    public string Name { get; set; }
    public int Age { get; set; }    public static Student operator ++(Student s)
    {
        s.Age++;
        return s;
    }    public override string ToString()
    {
        return "Name = " + Name + " , Age = " + Age;
    }
}public class Test
{
    static void Main()
    {
        Student original = new Student() { Name = "Name", Age = 30 };
        Console.WriteLine("original1: " + original.GetHashCode());
        Student destination = ++original;
        Console.WriteLine("original2: " + original.GetHashCode());
        Console.WriteLine("destination: " + destination.GetHashCode());        Console.WriteLine("Original " + original);
        Console.WriteLine("Destination " + destination);
        Console.ReadKey();
    }
}

Answer 12

你不需要destination输出的age是 31? 

Answer 13

那你这就是需求问题了.
1.到底++ 这个操作符在做什么?
2.Student destination = ++original;这句你想实现的逻辑是什么?

Answer 14

@Baesky:
经过对两个对象的比较发现正如您所说,确实是指向了同一个对象。
一元运算符的执行结果的确改变了对象自身。
感谢您真诚的讲解!

Answer 15

@Lost_Painting:
刚才您讲是需求问题,正是击中了我的要害了。
本意讲我想只是通过++original返回一个新创建的对象并没有想到会影响到original自身!
现在看来,在这里使用一元运算符看来是用错地方了。
您有什么好的解决办法吗?

Answer 16

@Lost_Painting:
针对11#中的代码,
public static Student operator(Student s)
{
  s.Age++;
  return s;
}
在这里,重载的运算符改变了对象本身的状态,这样做好吗?
难道只是为了减少了创建对象的内存开销吗?