浅拷贝,深拷贝

一、浅拷贝

含义:多个指针指向同一个内存(如生活中的共享)

特点:不能修改

1.如字符串常量就是浅拷贝,不允许修改

char *str1 = "hello world";
char str1[0] = 'a';//error
2.指针数组
int main()
{
 char buf[100];
 char *str[3];//指针数组
 int i;
 for(i=0;i<3;i++)
 {
  scanf("%s",buf);//123    1234   12345
  str[i] = buf;
 }

 for(i=0;i<3;i++)
 {
  printf("%s\n",str[i]);//12345   12345   12345
 }

 return 0;
}
3.free
realloc

int *q = (int *)malloc(20*sizeof(int));   //创建新家

   for(i = 0;i<10;i++)                    

{

      *q[i] = *p[i];                       //搬家

}

     free(p);                              //释放旧地址

    p = q;                                //更新新地址

    q = NULL;                             //浅拷贝发生错误,多个指针不能指向同一个内存,所以q = NULL



二、深拷贝

含义:各自内存互不干扰,如自己的私人物品自己随意处理

//深拷贝  将从键盘中读取的字符串复制到另一数组里打印出
#include<stdio.h>
#include<malloc.h>
#include<string.h>
#include<vld.h>
int main()
{
 char buf[100];
 char *str[3];//
 int i;
 for(i=0;i<sizeof(str)/sizeof(str[0]);i++)
 {
  scanf("%s",buf);
  str[i] = (char*)malloc(strlen(buf)+1);
  strcpy(str[i],buf);
 }

 for(i=0;i<3;i++)
 {
  printf("%s\n",str[i]);
 }
 
 for(i = 0;i<sizeof(str)/sizeof(str[0]);i++)
 {
  free(str[i]);
    }
 return 0;
}

### Java 中浅拷贝深拷贝的区别及用法 #### 1. 浅拷贝 (Shallow Copy) 浅拷贝是指创建一个新的对象,这个新对象会复制原对象中的基本数据类型字段值以及引用类型的内存地址。这意味着,在浅拷贝的情况下,如果原始对象包含其他对象的引用,则这些引用会被简单地复制到新的对象中,而不是重新创建被引用的对象。 在 Java 中可以通过 `Object` 类的 `clone()` 方法来实现浅拷贝[^1]。需要注意的是,默认情况下,`clone()` 只能完成浅拷贝操作。下面是一个浅拷贝的例子: ```java class Person implements Cloneable { String name; int age; @Override protected Object clone() throws CloneNotSupportedException { return super.clone(); } } public class Main { public static void main(String[] args) throws CloneNotSupportedException { Person original = new Person(); original.name = "Alice"; original.age = 25; Person copied = (Person) original.clone(); System.out.println(copied.name); // 输出 Alice System.out.println(copied.age); // 输出 25 } } ``` 上述代码展示了如何通过重写 `clone()` 方法来进行浅拷贝[^4]。 #### 2. 深拷贝 (Deep Copy) 深拷贝不仅复制了对象本身,还递归地复制了该对象所引用的所有子对象。因此,即使修改了原始对象的内容,也不会影响到副本对象的状态。这使得深拷贝更加安全但也更耗费资源和时间。 要实现深拷贝,可以采用序列化的方式或者手动逐级克隆每一个成员变量及其内部结构[^3]。以下是利用序列化的例子: ```java import java.io.*; class Address implements Serializable { String city; } class Employee implements Serializable, Cloneable { String name; transient Address address; private Object readResolve() throws ObjectStreamException { this.address = new Address(); this.address.city = "New York"; return this; } @Override protected Object clone() throws CloneNotSupportedException { try { ByteArrayOutputStream bos = new ByteArrayOutputStream(); ObjectOutputStream oos = new ObjectOutputStream(bos); oos.writeObject(this); ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray()); ObjectInputStream ois = new ObjectInputStream(bis); return ois.readObject(); } catch (IOException | ClassNotFoundException e) { throw new RuntimeException(e); } } } public class DeepCopyExample { public static void main(String[] args) throws Exception{ Employee empOriginal = new Employee(); empOriginal.name = "John Doe"; Address addr = new Address(); addr.city = "Los Angeles"; empOriginal.address = addr; Employee deepCopiedEmp = (Employee)empOriginal.clone(); System.out.println(empOriginal.name.equals(deepCopiedEmp.name)); // true System.out.println(empOriginal.address == deepCopiedEmp.address); // false } } ``` 此示例说明了如何借助序列化机制执行真正的深拷贝过程。 #### 3. 主要差异对比 | 特性 | 浅拷贝 | 深拷贝 | |-------------------|----------------------------------|--------------------------------| | **定义** | 复制基础数据类型并共享引用 | 完全独立的新实例 | | **性能开销** | 较低 | 高 | | **适用场景** | 数据量较小或无需完全隔离的情况 | 要求严格分离的数据处理 | #### 4. 总结 当仅需快速复制少量数据而不关心后续更改时可选用浅拷贝;而对于那些需要保持绝对一致性的复杂数据结构则应考虑使用深拷贝
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

@所谓伊人

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值