今天上课学到了C++的浅层拷贝与深层拷贝, 于是在这里将C++和Java关于浅层拷贝与深层拷贝做一个对比.
一.C++的浅层拷贝与深层拷贝
- 先来了解一下C++中的复制构造函数:
//假设有这样一个TEST类:
class TEST
{
private:
int *num;
public:
TEST(int n)
{
num = new int;
*num = n;
}
void change(int anothernum)
{
*num = anothernum;
}
void print()
{
cout << *num << endl;
}
};在上述TEST类中并没有显式定义TEST类的复制构造函数, 那么其默认的复制构造函数应为:
TEST(const TEST & t)
{
num = t.num;
}1.C++的浅层拷贝
以上述TEST类为例, 假设有如下代码:
#include<iostream>
using namespace std;
class TEST
{
private:
int *num;
public:
TEST(int n)
{
num = new int;
*num = n;
}
void change(int anothernum)
{
*num = anothernum;
}
void print()
{
cout << *num << endl;
}
};
int main(void)
{
TEST a(10);
TEST b(a);
a.print();
b.print();
b.change(100);
a.print();
b.print();
}
上述代码中并没有显式定义复制构造函数, 运行结果如下:
10
10
100
100
//即更改了b对象的值, a对象的值也随之改变上述结果可以证明, C++的默认构造函数为浅层复制, 也就是说a对象和b对象指向同一段内存空间.
在小伙伴的提示下, 上述代码存在一些问题:在TEST类中并没有定义析构函数.析构函数的定义应该如下:
~TEST() { delete[] num; }那么定义析构函数和不定义析构函数都会引发什么样的问题呢?
- 定义析构函数:
首先a对象执行析构函数, 释放掉a对象所指向的空间之后, b对象再执行析构函数, 会释放掉b对象所指向的空间. 前面提过了, 使用默认的拷贝构造函数拷贝的b对象和a对象应该是指向同样一段内存空间的. 这样等于对一段空间delete了两次, 会造成内存非法访问, 是极为不妥当的!!!- 不定义析构函数:
如果没有构造析构函数, 那么a和b所指向的空间无法得到释放, 这会造成内存泄露, 这样也是极为不妥当的!!!综上所述, 在TEST类中, 不管是否定义析构函数都是不妥当的, 那这该怎么办呢?
- 拷贝构造函数中涉及到需要动态分配内存的情况下, 应该自定义拷贝构造函数.
- 换句话来说, 如果需要自定义析构函数, 那么也应该自定义拷贝构造函数.
2.C++的深层拷贝
依旧来看一段代码:
#include<iostream>
using namespace std;
class TEST
{
private:
int *num;
public:
TEST(int n)
{
num = new int;
*num = n;
}
//此处显示定义了TEST类的复制构造函数
TEST(const TEST & t)
{
num = new int;
*num = *t.num;
}
void change(int anothernum)
{
*num = anothernum;
}
void print()
{
cout << *num << endl;
}
};
int main(void)
{
TEST a(10);
TEST b(a);
a.print();
b.print();
b.change(100);
a.print();
b.print();
}
上述代码中显式定义了复制构造函数, 自定义的复制构造函数中, 对a对象在堆上动态申请了空间, 然后再将b对象的值赋值给a对象新申请的这段内存空间.
运行结果如下:
10
10
10
100
//更改b对象的值并没有改变a对象的值, 充分说明a对象和b对象所占的是不同的两段内存空间二.Java的浅层拷贝和深层拷贝
1.以数组为例, 关于Java浅层拷贝和深层拷贝的几个小知识点
- 数组复制的两个方法:
System.arraycopy(array1, 0, array2, array1.length);五个参数分别为:源数组, 源数组起始索引, 目的数组, 源数组长度.
Arrays.copyOf(array1, array1.length);参数分别为:源数组, 源数组的长度. - 在Java中, 只要看到new, 就是建立对象, 即申请一段新的空间. 也就是说, 只要new了, 二者就不是同一个对象,这一点千万要注意!!!
- 关于Integer类的一点知识:若使用Integer a = xxx;这样的形式打包一个值, 要打包的值在Integercache.low~Integercache.high(-128~127)之间, 若在缓存中没有打包过, 则返回一个new的新对象; 若打包过, 则直接返回打包过的对象; 若不在此范围内, 则直接返回一个new的新对象. 而使用Integer a = new Integer(xxx);这样打包出来的值, 一定是一个新的对象.
- 关于字符串池:Java为了效率考虑, 凡是以”“写下的字符串都为字符串常量, 以”“包括的字符串, 只要内容相同, 无论在代码中出现多少次, JVM都只会建立一个String对象. 也就是说, “”写下的字符串都会被放入字符串池中, 往后再出现与”“写下字符串相同的字符串, 都将直接参考(意大致等同于C中的指向)至字符串池中已有对象, 不再建立新的对象.
2.Java的深层拷贝
为什么要先谈Java的深层拷贝呢?
因为在Java中, 只要是基本数据类型的数组, 使用上面介绍到的两个数组拷贝函数进行数组拷贝, 都是深层拷贝!
来看如下代码:
public class ArrayCopy {
public static void main(String args[]){
int[] array1 = {0, 1, 2, 3, 4, 5};
int[] array2 = Arrays.copyOf(array1, array1.length);
for(int num : array1){
System.out.printf("%3d", num);
}
System.out.println();
for(int num : array2) {
System.out.printf("%3d", num);
}
System.out.println();
array2[0] = 10;
for(int num : array1){
System.out.printf("%3d", num);
}
System.out.println();
for(int num : array2){
System.out.printf("%3d", num);
}
}
}
因为基本类型的数组的拷贝皆为深层拷贝额, 所以更改array2数组第一个元素的值, 并不会影响array1数组第一个元素的值. 运行结果如下:
0 1 2 3 4 5
0 1 2 3 4 5
0 1 2 3 4 5
10 1 2 3 4 53.Java的浅层拷贝
无论是使用System.arraycopy()还是Arrays.copyOf(), 只要用作类类型声明的数组时, 都执行浅层拷贝, 即源数组与拷贝数组指向同一段内存空间.
需要特别说明的是, 数组在Java中也是类的对象, 所以二维数组和三维数组在使用System.arraycopy()和Arrays.copyOf()的时候, 执行的也是浅层拷贝.
关于浅层拷贝就不在这里举例子了, 下面来看一看, 如何让类类型的数组执行深层拷贝.
4.使类类型的数组执行深层拷贝
看如下代码:
public class DeepCopy {
public static class cloths{
String color;
char size;
cloths(String col, char si){
color = col;
size = si;
}
}
public static void main(String[] args){
cloths[] c1 = {new cloths("red", 'l'), new cloths("blue", 'm')};
cloths[] c2 = new cloths[c1.length];
for(int i = 0; i < c1.length; i++){
cloths c = new cloths(c1[i].color, c1[i].size);
c2[i] = c;
}
c1[0].color = "yellow";
System.out.println(c2[0].color);
}
}上述代码, 在复制每一个类类型的数组元素时, 都给其new一段新的空间, 使之与源数组元素完全隔离开. 所以运行结果如下:
red
//源数组的第一个元素的color并没有被改变