36

我对这两种将一个对象复制到另一个对象的方法有点陌生。我很困惑,无法找出深拷贝和浅拷贝之间的主要区别。我已经经历了很多关于这一点的理论,但我需要用适当的例子来解释。我有程序可以将一个对象复制到另一个对象中. -->

   class A
    {
        public int a = 0;
        public void display()
        {
            Console.WriteLine("The value of a is " + a);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            A ob1 = new A();
            ob1.a = 10;
            ob1.display();
            A ob2 = new A();
            ob2 = ob1;
            ob2.display();
            Console.Read();
        }
    }

这是浅拷贝还是深拷贝?任何人都可以提供理由的答案。如果是深拷贝,请提供该程序的浅拷贝代码,该程序执行相同的对象复制工作,反之亦然。

如果上面是浅拷贝,那么即使这个也应该是浅拷贝-->

            A ob1 = new A();
            ob1.a = 10;
            ob1.display();
            A ob2 = ob1;
            ob2.a = 444;
            ob1.display();
4

6 回答 6

59

这里的链接

浅拷贝尽可能少地重复。集合的浅拷贝是集合结构的副本,而不是元素的副本。使用浅拷贝,两个集合现在共享单个元素。

深拷贝复制一切。集合的深层副本是两个集合,其中原始集合中的所有元素都重复。

您的示例是创建一个浅拷贝。

A ob1 = new A();
ob1.a = 10;
A ob2 = new A();
ob2 = ob1;

ob1.a = 5; // <-- If you see value of ob2.a after this line, it will be 5.

深拷贝将是 -

 A ob1 = new A();
 ob1.a = 10;
 A ob2 = new A();
 ob2.a = ob1.a;

 ob1.a = 5; // <-- If you see value of ob2.a after this line, it will be 10.
于 2013-08-05T19:48:14.007 回答
18

在我看来,它不是严格的浅拷贝或深拷贝。如果我必须定义它,我会说浅拷贝。

ob2 = ob1; 此代码创建两个对象引用,它们都引用同一个对象。因此,通过 ob1 对对象所做的任何更改都会反映在 ob2 的后续使用中。

来自 MSDN 的示例将更好地解释浅拷贝、深拷贝和简单的类拷贝的区别。

 using System;

    public class IdInfo
    {
        public int IdNumber;

        public IdInfo(int IdNumber)
        {
            this.IdNumber = IdNumber;
        }
    }

    public class Person
    {
        public int Age;
        public string Name;
        public IdInfo IdInfo;

        public Person ShallowCopy()
        {
            return (Person)this.MemberwiseClone();
        }

        public Person DeepCopy()
        {
            Person other = (Person)this.MemberwiseClone();
            other.IdInfo = new IdInfo(this.IdInfo.IdNumber);
            other.Name = String.Copy(this.Name);
            return other;
        }
    }

    public class Example
    {
        public static void Main()
        {
            // Create an instance of Person and assign values to its fields.
            Person p1 = new Person();
            p1.Age = 42;
            p1.Name = "Sam";
            p1.IdInfo = new IdInfo(6565);

            // Perform a shallow copy of p1 and assign it to p2.
            Person p2 = (Person)p1.ShallowCopy();

            // Display values of p1, p2
            Console.WriteLine("Original values of p1 and p2:");
            Console.WriteLine("   p1 instance values: ");
            DisplayValues(p1);
            Console.WriteLine("   p2 instance values:");
            DisplayValues(p2);

            // Change the value of p1 properties and display the values of p1 and p2.
            p1.Age = 32;
            p1.Name = "Frank";
            p1.IdInfo.IdNumber = 7878;
            Console.WriteLine("\nValues of p1 and p2 after changes to p1:");
            Console.WriteLine("   p1 instance values: ");
            DisplayValues(p1);
            Console.WriteLine("   p2 instance values:");
            DisplayValues(p2);

            // Make a deep copy of p1 and assign it to p3.
            Person p3 = p1.DeepCopy();
            // Change the members of the p1 class to new values to show the deep copy.
            p1.Name = "George";
            p1.Age = 39;
            p1.IdInfo.IdNumber = 8641;
            Console.WriteLine("\nValues of p1 and p3 after changes to p1:");
            Console.WriteLine("   p1 instance values: ");
            DisplayValues(p1);
            Console.WriteLine("   p3 instance values:");
            DisplayValues(p3);

            // Make an equal of p1 and assign it to p4.
            Person p4 = new Person();
            p4 = p1;
            // Change the members of the p1 class to new values to show the equal copy.
            p1.Name = "Will";
            p1.Age = 30;
            p1.IdInfo.IdNumber = 8484;
            Console.WriteLine("\nValues of p1 and p4 after changes to p1:");
            Console.WriteLine("   p1 instance values: ");
            DisplayValues(p1);
            Console.WriteLine("   p4 instance values:");
            DisplayValues(p4);
        }

        public static void DisplayValues(Person p)
        {
            Console.WriteLine("      Name: {0:s}, Age: {1:d}", p.Name, p.Age);
            Console.WriteLine("      Value: {0:d}", p.IdInfo.IdNumber);
        }
    }

结果如下:

Original values of p1 and p2:    p1 instance values:
      Name: Sam, Age: 42
      Value: 6565    p2 instance values:
      Name: Sam, Age: 42
      Value: 6565

Values of p1 and p2 after changes to p1:    p1 instance values:
      Name: Frank, Age: 32
      Value: 7878    p2 instance values:
      Name: Sam, Age: 42
      Value: 7878

Values of p1 and p3 after changes to p1:    p1 instance values:
      Name: George, Age: 39
      Value: 8641    p3 instance values:
      Name: Frank, Age: 32
      Value: 7878

Values of p1 and p4 after changes to p1:    p1 instance values:
      Name: Will, Age: 30
      Value: 8484    p4 instance values:
      Name: Will, Age: 30
      Value: 8484
于 2014-12-04T16:03:01.237 回答
5

这既不是浅拷贝也不是深拷贝,这是参考拷贝。让我解释一下:变量有两种类型:值类型和参考类型。

值类型是计算机内存中的(命名)位置,用于保存变量的实际值。例如: int 是一个值类型,所以当你写这行代码时:

int MyInt = 5;

当这行代码被执行时,运行时将在 RAM 中找到一个位置并将值 5 写入其中。因此,如果您搜索该位置,您会发现实际值为 5。

引用类型 - 相比之下 - 是内存中的(命名)位置,它实际上并不保存变量的值,而是保存该值所在的内存位置。例如,假设您编写了以下代码:

MyClass myObject = new MyClass();

发生的事情是虚拟机(运行时): 1-查看并找到内存中的可用位置,创建 MyClass 类的实例。假设该对象的位置恰好位于 RAM 中的字节#AA3D2。

2- 在内存中找到一个位置并创建 MyClass 类型的引用(引用是指向内存中某个位置的“箭头”),将其命名为“myObject”并将值 AA3D2 存储在其中。

现在,如果您查看“myObject”变量,您会发现不是类实例,但您会发现 AA3D2 表示保存该类实例的内存位置。

现在让我们检查给定我的 OP 的代码:

A ob1 = new A();

这将创建一个名为 ob1 的变量,创建 A 类的实例并将该类的位置存储在 ob1

ob1.a = 10;
ob1.display();

这将改变 A 类内部的变量 a。然后它调用 display() 方法

A ob2 = new A();

在这里它创建一个名为 ob2 的变量,创建一个类 A 的实例并将其位置分配给 ob2。

到目前为止,您在内存中有 A 的 2 个类实例和 2 个变量,每个变量都指向其中一个。现在这里是有趣的部分:ob2 = ob1;

变量 ob2 被赋予变量 ob1 的值。因为 ob1 包含 A 的第一个实例的内存位置,现在 ob1 和 ob2 都指向内存中的相同位置。使用其中一个做任何事情与另一个做同样的事情。

ob2 = ob1 表示您正在复制引用。

于 2016-10-07T12:40:05.063 回答
2

这是一个浅拷贝,因为如果您修改 ob2 的变量 - 然后尝试打印 ob1 - 它们将是相同的。这是因为 C# 中作为类的东西在它们之间创建了链接。如果你想做一个深拷贝,你应该实现一个拷贝方法并手动拷贝字段。就像是:

  class A
    {
        public int a = 0;
        public void display()
        {
            Console.WriteLine("The value of a is " + a);
        }

       public A Copy()
    {
        A a = new A();
        a.a = = this.a;
        return a;
    }



    }
于 2013-08-05T19:48:54.667 回答
2

我赞同@docesam 的回答和@Will Yu 的部分回答。

这既不是浅拷贝也不是深拷贝,这是参考拷贝。-- 文档


ob2 = ob1; 此代码创建两个对象引用,它们都引用同一个对象。因此,通过 ob1 对对象所做的任何更改都会反映在 ob2 的后续使用中。——余伟


根据MSDN(见备注)

Array 的浅拷贝只复制 Array 的元素,无论它们是引用类型还是值类型,但它不会复制引用所引用的对象。新 Array 中的引用指向的对象与原始 Array 中的引用指向的对象相同。

这里我们有两点需要注意:

  1. 浅拷贝复制元素。
  2. 浅拷贝保留元素的原始引用。

接下来,让我分别解释这两个。


首先,我们创建一个Person具有Name属性的类:

class Person
{
    public string Name {get; set;}
}

然后在Main()方法中,我们创建一个Person数组。

// Create 2 Persons.
var person1 = new Person(){ Name = "Jack" };
var person2 = new Person(){ Name = "Amy" };

// Create a Person array.
var arrPerson = new Person[] { person1, person2 };

1. 浅拷贝复制元素。

如果我们替换浅拷贝中的第一个元素,则不应影响原始数组:

// Create a shallow copy.
var arrPersonClone = (Person[]) arrPerson.Clone();

// Replace an element in the shallow copy.
arrPersonClone[0] = new Person(){Name = "Peter"};

// Display the contents of all arrays.
Console.WriteLine( "After replacing the first element in the Shallow Copy" );
Console.WriteLine( $"The Original Array: {arrPerson[0].Name}, {arrPerson[1].Name}" );
Console.WriteLine( $"The Shallow Copy: {arrPersonClone[0].Name}, {arrPersonClone[1].Name}" );

结果:

The Original Array: Jack, Amy
The Shallow Copy: Peter, Amy

2. 浅拷贝保留元素的原始引用。

如果我们在浅拷贝中更改元素的属性,原始数组将受到影响,因为该元素引用的对象不会被复制。

// Create a new shallow copy.
arrPersonClone = (Person[]) arrPerson.Clone();

// Change the name of the first person in the shallow copy.
arrPersonClone[0].Name = "Peter";

// Display the contents of all arrays.
Console.WriteLine( "After changing the Name property of the first element in the Shallow Copy" );
Console.WriteLine( $"The Original Array: {arrPerson[0].Name}, {arrPerson[1].Name}" );
Console.WriteLine( $"The Shallow Copy: {arrPersonClone[0].Name}, {arrPersonClone[1].Name}" );

结果:

The Original Array: Peter, Amy
The Shallow Copy: Peter, Amy

那么一个简单的等号 ,是如何=表现的呢?

它制作参考副本。对元素或引用对象的任何更改都将反映在原始数组和“复制”数组中。

// Create a reference copy.
var arrPersonR = arrPerson;

// Change the name of the first person.
arrPersonR[0].Name = "NameChanged";
// Replace the second person.
arrPersonR[1] = new Person(){ Name = "PersonChanged" };

// Display the contents of all arrays.
Console.WriteLine( "After changing the reference copy:" );
Console.WriteLine( $"The Original Array: {arrPerson[0].Name}, {arrPerson[1].Name}" );
Console.WriteLine( $"The Reference Copy: {arrPersonR[0].Name}, {arrPersonR[1].Name}" );

结果:

The Original Array: NameChanged, PersonChanged
The Reference Copy: NameChanged, PersonChanged

总之ob2 = ob1不是浅拷贝,而是参考拷贝。

完整的代码:

void Main()
{
    // Create 2 Persons.
    var person1 = new Person(){ Name = "Jack" };
    var person2 = new Person(){ Name = "Amy" };

    // Create a Person array.
    var arrPerson = new Person[] { person1, person2 };

    // ----------- 1. A shallow copy copies elements. -----------

    // Create a shallow copy.
    var arrPersonClone = (Person[]) arrPerson.Clone();

    // Replace an element in the shallow copy.
    arrPersonClone[0] = new Person(){Name = "Peter"};

    // Display the contents of all arrays.
    Console.WriteLine( "After replacing the first element in the Shallow Copy:" );
    Console.WriteLine( $"The Original Array: {arrPerson[0].Name}, {arrPerson[1].Name}" );
    Console.WriteLine( $"The Shallow Copy: {arrPersonClone[0].Name}, {arrPersonClone[1].Name}" );

    Console.WriteLine( "\n" );

    // ----------- 2. A shallow copy retains the original references of the elements. -----------

    // Create a new shallow copy.
    arrPersonClone = (Person[]) arrPerson.Clone();

    // Change the name of the first person in the shallow copy.
    arrPersonClone[0].Name = "Peter";

    // Display the contents of all arrays.
    Console.WriteLine( "After changing the Name property of the first element in the Shallow Copy:" );
    Console.WriteLine( $"The Original Array: {arrPerson[0].Name}, {arrPerson[1].Name}" );
    Console.WriteLine( $"The Shallow Copy: {arrPersonClone[0].Name}, {arrPersonClone[1].Name}" );

    Console.WriteLine( "\n" );  

    // ----------- 2. The equal sign. -----------

    // Create a reference copy.
    var arrPersonR = arrPerson;

    // Change the name of the first person.
    arrPersonR[0].Name = "NameChanged";
    // Replace the second person.
    arrPersonR[1] = new Person(){ Name = "PersonChanged" };

    // Display the contents of all arrays.
    Console.WriteLine( "After changing the reference copy:" );
    Console.WriteLine( $"The Original Array: {arrPerson[0].Name}, {arrPerson[1].Name}" );
    Console.WriteLine( $"The Reference Copy: {arrPersonR[0].Name}, {arrPersonR[1].Name}" );
}

class Person
{
    public string Name {get; set;}
}
于 2017-05-09T00:29:40.080 回答
0

在将第一个对象分配给第二个对象后,再编写几行代码来更改第一个对象的属性。然后在两个对象上调用 display 方法,看看结果如何。这将向您揭示它实际上是一个浅拷贝。

于 2013-08-05T19:58:13.703 回答