iOS 关于容器类的浅、深拷贝探究

引子

LOLITA0164

19242人浏览 · 2017-10-23 14:19:14

LOLITA0164 · 2017-10-23 14:19:14 发布

引子

浅拷贝：指针拷贝，引用拷贝，指向同一内存地址

深拷贝：内容拷贝，指向不同内存地址，但是内容相同

容器类拷贝的误解

针对NSArray，copy是浅拷贝，mutableCopy是深拷贝

针对NSMutableArray，copy是深拷贝，mutableCopy是深拷贝

举例说明：

NSArray的拷贝

NSArray *itemsOrigin = @[@"apple",@"pear"];
NSArray *items_copy = itemsOrigin.copy;
NSArray *items_mutableCopy = itemsOrigin.mutableCopy;
NSLog(@"原始数组地址：%p",itemsOrigin);
NSLog(@"copy数组地址：%p",items_copy);
NSLog(@"mutableCopy数组地址：%p",items_mutableCopy);

输出的内存地址：

看来似乎没什么问题，copy后的数组指向同一内存地址，mutableCopy产生新的内存地址

NSMutableArray的拷贝

NSMutableArray *mutableItemsOrigin = [NSMutableArray arrayWithArray:@[@"apple",@"pear"]];
NSArray *mutableItems_copy = mutableItemsOrigin.copy;
NSMutableArray *mutableItems_mutableCopy = mutableItemsOrigin.mutableCopy;
NSLog(@"原始数组地址：%p",mutableItemsOrigin);
NSLog(@"copy数组地址：%p",mutableItems_copy);
NSLog(@"mutableCopy数组地址：%p",mutableItems_mutableCopy);

输出的内存地址：

这和误解中说的一致，针对NSMutableArray，copy是深拷贝，mutableCopy是深拷贝

但是我们不要忘了，深拷贝的意义在于，内容完全的复制，解决引用的问题，当我们改变其中一个元素时，相互不会影响

这里有人会反驳了，我改变了元素，的确不会影响到复制的数组，就像下面这样：

// 改变原始数组
[mutableItemsOrigin addObject:@"banana"];
// 改变mutableCopy数组
[mutableItems_mutableCopy addObject:@"grape"];
NSLog(@"原始数组元素：%@",mutableItemsOrigin);
NSLog(@"mutableCopy数组元素：%@",mutableItems_mutableCopy);

输出：

似乎没啥问题，确实相互不会影响，说到这里，有人可能会大骂LZSB！

那是不是笔者哗众取宠了呢？回答是NO，让笔者一步步揭开容器类真正的深拷贝

首先，我们回到最初的数组，输出它们的内存地址

NSMutableArray *mutableItemsOrigin = [NSMutableArray arrayWithArray:@[@"apple",@"pear"]];
NSArray *mutableItems_copy = mutableItemsOrigin.copy;
NSMutableArray *mutableItems_mutableCopy = mutableItemsOrigin.mutableCopy;
NSLog(@"原始数组地址：%p",mutableItemsOrigin);
NSLog(@"copy数组地址：%p",mutableItems_copy);
NSLog(@"mutableCopy数组地址：%p",mutableItems_mutableCopy);

NSLog(@"\n");
for (NSString *itemString in mutableItemsOrigin) {
    NSLog(@"原始数组元素地址：%p",itemString);
}
for (NSString *itemString in mutableItems_copy) {
    NSLog(@"copy数组元素地址：%p",itemString);
}
for (NSString *itemString in mutableItems_mutableCopy) {
    NSLog(@"mutableCopy数组元素地址：%p",itemString);
}

输出元素内存地址：

由上图可知，容器数组无论是copy还是mutableCopy，元素指向了相同的内存地址；由此可知，两种拷贝方式仅仅产生了两个内存地址不同的容器，它们的使用的是同一份元素

那为什么内容不相互影响呢？接着往下看
我们为原始数组新增一个元素，mutableCopy的数组作删除一个元素操作

// 改变原始数组 -- 新增
[mutableItemsOrigin addObject:@"banana"];
// 改变mutableCopy数组 -- 删除
[mutableItems_mutableCopy removeLastObject];
NSLog(@"原始数组元素：%@",mutableItemsOrigin);
NSLog(@"mutableCopy数组元素：%@",mutableItems_mutableCopy);
NSLog(@"\n");
for (NSString *itemString in mutableItemsOrigin) {
    NSLog(@"原始数组元素地址：%p",itemString);
}
for (NSString *itemString in mutableItems_mutableCopy) {
    NSLog(@"mutableCopy数组元素地址：%p",itemString);
}

输出：

由上图可知：

1、原始数组新增了一个内存地址为：0x100002130，内容为banana的元素，mutableCopy数组只剩内存地址为0x100002090，内容为apple的元素

2、原始数组和mutableCopy数组确实没有相互影响

原因解析

最初的时候

当我们操作数组中的元素时（原始数组新增一个元素，mutableCopy的数组作删除一个元素操作），会发生如下变化

上图可以看出，原始数组多出了一个“banana”的元素，而可变数组被删除了“pear”元素，指向“pear”元素的指针被移除了

过程虽然如此，但是并没有影响到我们使用，那我们是不是忽略其非深拷贝到事实了呢？错，我们要知道，上述的例子中，元素都是不可变的，当我们操作时，都是操作了整个元素地址，要么被删除（指针），要么新增元素（新地址），假如元素是可变的，我们只操作元素的子元素会发生什么呢？

重点：操作可变数组可变元素

我们将元素定义为可变的

// 定义一个可变元素数组
NSMutableArray *items = [NSMutableArray arrayWithArray:@[@"apple",@"pear"]];
// 新建原始数组
NSMutableArray *mutableItemsOrigin = [NSMutableArray arrayWithObject:items];
// copy该数组
NSArray *mutableItems_copy = mutableItemsOrigin.copy;
// mutableCopy该数组
NSMutableArray *mutableItems_mutableCopy = mutableItemsOrigin.mutableCopy;
NSLog(@"原始数组地址：%p",mutableItemsOrigin);
NSLog(@"copy数组地址：%p",mutableItems_copy);
NSLog(@"mutableCopy数组地址：%p",mutableItems_mutableCopy);
// 输出元素的内存地址
NSLog(@"\n");
for (NSMutableArray *items in mutableItemsOrigin) {
    for (NSString *itemString in items) {
        NSLog(@"原始数组元素地址：%p",itemString);
    }
}
for (NSMutableArray *items in mutableItems_copy) {
    for (NSString *itemString in items) {
        NSLog(@"copy数组元素地址：%p",itemString);
    }
}
for (NSMutableArray *items in mutableItems_mutableCopy) {
    for (NSString *itemString in items) {
        NSLog(@"mutableCopy数组元素地址：%p",itemString);
    }
}

输出内存地址：

由上图可知：同样的，NSMutableArray数组的copy和mutableCopy都会产生内存地址不同容器，但是元素依旧引用了同一份，属于浅拷贝

接下来，我们来改变其中可变元素

// 改变原始数组 -- 新增
NSMutableArray *tmpItemsOrigin = mutableItemsOrigin.firstObject;
[tmpItemsOrigin addObject:@"banana"];
// 改变mutableCopy数组 -- 新增
NSMutableArray *tmpItems_mutableCopy = mutableItems_mutableCopy.firstObject;
[tmpItems_mutableCopy addObject:@"watermelon"];
NSLog(@"原始数组元素：%@",mutableItemsOrigin.firstObject);
NSLog(@"copy数组元素：%@",mutableItems_copy.firstObject);
NSLog(@"mutableCopy数组元素：%@",mutableItems_mutableCopy.firstObject);

for (NSMutableArray *items in mutableItemsOrigin) {
    for (NSString *itemString in items) {
        NSLog(@"原始数组元素地址：%p",itemString);
    }
}
for (NSMutableArray *items in mutableItems_copy) {
    for (NSString *itemString in items) {
        NSLog(@"copy数组元素地址：%p",itemString);
    }
}
for (NSMutableArray *items in mutableItems_mutableCopy) {
    for (NSString *itemString in items) {
        NSLog(@"mutableCopy数组元素地址：%p",itemString);
    }
}

输出结果：

我们看到，上述操作，无论是原始数组的新增，还是mutableCopy数组的新增都会相互影响，不仅如此，copy出来的不可变数组也被改变了！！

这种结果再次说明，容器类的复制，无论是copy还是mutableCopy，如果仅仅做一次拷贝就是浅拷贝！！！

接下来，我们来看下系统的一个方法，拷贝元素

- (instancetype)initWithArray:(NSArray<ObjectType> *)array copyItems:(BOOL)flag

这个方法是将items拷贝（copy）一份，不可变元素为浅拷贝，可变元素则为深拷贝容器

1、items为NSArray

MutableArray *mutableItemsOrigin = [NSMutableArray arrayWithObject:@[@"apple",@"pear"]];
NSArray *mutableItems_copy = [[NSArray alloc] initWithArray:mutableItemsOrigin copyItems:YES];
NSMutableArray *mutableItems_mutableCopy = [[NSMutableArray alloc] initWithArray:mutableItemsOrigin copyItems:YES];
NSLog(@"原始数组地址：%p",mutableItemsOrigin);
NSLog(@"copy数组地址：%p",mutableItems_copy);
NSLog(@"mutableCopy数组地址：%p",mutableItems_mutableCopy);

NSLog(@"\n");
NSLog(@"原始数组元素地址：%p",mutableItemsOrigin.firstObject);
NSLog(@"copy数组元素地址：%p",mutableItems_copy.firstObject);
NSLog(@"mutableCopy数组元素地址：%p",mutableItems_mutableCopy.firstObject);

结果：元素的内存地址不变

2、items为NSMutableArray

MutableArray *items = [NSMutableArray arrayWithArray:@[@"apple",@"pear"]];

NSMutableArray *mutableItemsOrigin = [NSMutableArray arrayWithObject:items];
NSArray *mutableItems_copy = [[NSArray alloc] initWithArray:mutableItemsOrigin copyItems:YES];
NSMutableArray *mutableItems_mutableCopy = [[NSMutableArray alloc] initWithArray:mutableItemsOrigin copyItems:YES];
NSLog(@"原始数组地址：%p",mutableItemsOrigin);
NSLog(@"copy数组地址：%p",mutableItems_copy);
NSLog(@"mutableCopy数组地址：%p",mutableItems_mutableCopy);

NSLog(@"\n");
NSLog(@"原始数组元素地址：%p",mutableItemsOrigin.firstObject);
NSLog(@"copy数组元素地址：%p",mutableItems_copy.firstObject);
NSLog(@"mutableCopy数组元素地址：%p",mutableItems_mutableCopy.firstObject);

结果：元素变为不可变数组，内存地址改变

这样，我们来重复之前的例子

MutableArray *items = [NSMutableArray arrayWithArray:@[@"apple",@"pear"]];

NSMutableArray *mutableItemsOrigin = [NSMutableArray arrayWithObject:items];
NSArray *mutableItems_copy = [[NSArray alloc] initWithArray:mutableItemsOrigin copyItems:YES];
NSMutableArray *mutableItems_mutableCopy = [[NSMutableArray alloc] initWithArray:mutableItemsOrigin copyItems:YES];
NSLog(@"原始数组地址：%p",mutableItemsOrigin);
NSLog(@"copy数组地址：%p",mutableItems_copy);
NSLog(@"mutableCopy数组地址：%p",mutableItems_mutableCopy);

NSLog(@"\n");
// 输出元素地址
NSLog(@"原始数组元素地址：%p",mutableItemsOrigin.firstObject);
NSLog(@"copy数组元素地址：%p",mutableItems_copy.firstObject);
NSLog(@"mutableCopy数组元素地址：%p",mutableItems_mutableCopy.firstObject);
// 输出最小元素地址
for (NSMutableArray *items in mutableItemsOrigin) {
    for (NSString *itemString in items) {
        NSLog(@"原始数组元素地址：%p",itemString);
    }
}
for (NSMutableArray *items in mutableItems_copy) {
    for (NSString *itemString in items) {
        NSLog(@"copy数组元素地址：%p",itemString);
    }
}
for (NSMutableArray *items in mutableItems_mutableCopy) {
    for (NSString *itemString in items) {
        NSLog(@"mutableCopy数组元素地址：%p",itemString);
    }
}

结果：

我们发现：

1、使用了copyItems函数后，产生了新的元素容器，但是最小元素的内存地址依旧是一份

2、可变元素数组由于该函数，变为了不可变数组

3、最小单位的元素依旧指向同一份地址

这时，由于元素数组内存地址已经不同，我们操作原始数组时，不会在影响到拷贝到数组

// 改变原始数组 -- 新增
NSMutableArray *tmpItemsOrigin = mutableItemsOrigin.firstObject;
[tmpItemsOrigin addObject:@"banana"];
// 改变mutableCopy数组 -- 新增 -- 由于元素变为不可变数组，所以不可像下面那样操作
//NSMutableArray *tmpItems_mutableCopy = mutableItems_mutableCopy.firstObject;
//[tmpItems_mutableCopy addObject:@"watermelon"];
NSLog(@"原始数组元素：%@",mutableItemsOrigin.firstObject);
NSLog(@"copy数组元素：%@",mutableItems_copy.firstObject);
NSLog(@"mutableCopy数组元素：%@",mutableItems_mutableCopy.firstObject);

for (NSMutableArray *items in mutableItemsOrigin) {
    for (NSString *itemString in items) {
        NSLog(@"原始数组元素地址：%p",itemString);
    }
}
for (NSMutableArray *items in mutableItems_copy) {
    for (NSString *itemString in items) {
        NSLog(@"copy数组元素地址：%p",itemString);
    }
}
for (NSMutableArray *items in mutableItems_mutableCopy) {
    for (NSString *itemString in items) {
        NSLog(@"mutableCopy数组元素地址：%p",itemString);
    }
}

结果：

copy的数组和mutableCopy数组并未被影响

系统提供的这种方法只不过就是元素数组copy一下，并将数组转换为不可变数组NSArray，这时操作了整个不可变元素数组，这样就避免了相互影响（和操作NSArray一样）

综上所述

1、copy和mutableCopy只能作单层拷贝，针对容器类仅仅使用一次拷贝操作时，只能产生新的容器，但是元素共用一份

2、如果想要拷贝元素，则需要调用系统方法copyItems，将元素copy一份（这个元素copy也仅仅是单层拷贝）

3、如果是容器嵌套容器时，单单使用一次copy或者mutableCopy，严格意义上来说，是无法做到深拷贝的，因为元素可能没有被拷贝，并且如果元素是不可变类型时，无论怎么样做都只能是引用拷贝，因为最小元素是不可变的，仅仅有一份内存地址

4、因此非容器类，如NSString，NSMutableString等，copy和mutableCopy作单层拷贝就达到了最终效果

验证

情况1：非容器类，不可变类型

NSString *string = @"LOLITA64";
NSString *string_copy = string.copy;
NSMutableString *string_mutableCopy = string.mutableCopy;
NSLog(@"string地址：%p",string);
NSLog(@"string_copy地址：%p",string_copy);
NSLog(@"string_mutableCopy地址：%p",string_mutableCopy);
[string_mutableCopy appendString:@"-test"];
NSLog(@"原始字符串：%@",string);
NSLog(@"string_copy字符串：%@",string_copy);
NSLog(@"string_mutableCopy字符串：%@",string_mutableCopy);

输出：

结论：copy为浅拷贝，mutableCopy为深拷贝

情况2：非容器类，可变类型

NSString *string = [NSMutableString stringWithString:@"LOLITA64"];
NSString *string_copy = string.copy;
NSMutableString *string_mutableCopy = string.mutableCopy;
NSLog(@"string地址：%p",string);
NSLog(@"string_copy地址：%p",string_copy);
NSLog(@"string_mutableCopy地址：%p",string_mutableCopy);
[string_mutableCopy appendString:@"-test"];
NSLog(@"原始字符串：%@",string);
NSLog(@"string_copy字符串：%@",string_copy);
NSLog(@"string_mutableCopy字符串：%@",string_mutableCopy);

输出：

结论：copy为深拷贝，mutableCopy为深拷贝

情况3：容器类（单层），不可变类型，元素不可变非容器，单次拷贝

NSArray *items = @[@"apple",@"pear"];
NSArray *items_copy = items.copy;
NSMutableArray *items_mutableCopy = items.mutableCopy;
NSLog(@"items地址：%p",items);
NSLog(@"items_copy地址：%p",items_copy);
NSLog(@"items_mutableCopy地址：%p",items_mutableCopy);
for (NSString *itemString in items) {
    NSLog(@"items不可变元素地址：%p",itemString);
}
for (NSString *itemString in items_copy) {
    NSLog(@"items_copy不可变元素地址：%p",itemString);
}
for (NSString *itemString in items_mutableCopy) {
    NSLog(@"items_mutableCopy不可变元素地址：%p",itemString);
}

输出：

结论：copy不产生新容器，mutableCopy产生新容器，但是最小元素内存地址都一样，浅拷贝

情况4：容器类（单层），不可变类型，元素不可变非容器，元素拷贝

// 更改
NSArray *items_copy = [[NSArray alloc] initWithArray:items copyItems:YES];
NSMutableArray *items_mutableCopy = [[NSMutableArray alloc] initWithArray:items copyItems:YES];

输出：

结论：产生新容器，但是最小元素内存地址都一样，浅拷贝

情况5：容器类（单层），不可变类型，元素可变非容器，单次拷贝

NSMutableString *string1 = [NSMutableString stringWithString:@"apple"];
NSMutableString *string2 = [NSMutableString stringWithString:@"pear"];
NSArray *items = @[string1,string2];
NSArray *items_copy = items.copy;
NSMutableArray *items_mutableCopy = items.mutableCopy;

结果：

结论：copy不产生新容器，mutableCopy产生新容器，但是最小元素内存地址都一样，浅拷贝

情况6：容器类（单层），不可变类型，元素可变非容器，元素拷贝

NSArray *items_copy = [[NSArray alloc] initWithArray:items copyItems:YES];
NSMutableArray *items_mutableCopy = [[NSMutableArray alloc] initWithArray:items copyItems:YES];

输出：

结论：产生新容器，最小元素内存地址不一样，深拷贝

情况7：容器类（单层），可变类型，元素不可变非容器，单次拷贝

NSMutableArray *items = [NSMutableArray arrayWithArray:@[@"apple",@"pear"]];
NSArray *items_copy = items.copy;
NSMutableArray *items_mutableCopy = items.mutableCopy;

输出：

结论：copy、mutableCopy都产生新容器，但是最小元素内存地址都一样，浅拷贝

情况8：容器类（单层），可变类型，元素不可变，元素拷贝

NSMutableArray *items = [NSMutableArray arrayWithArray:@[@"apple",@"pear"]];
NSArray *items_copy = [[NSArray alloc] initWithArray:items copyItems:YES];
NSMutableArray *items_mutableCopy = [[NSMutableArray alloc] initWithArray:items copyItems:YES];

输出：

结论：copy、mutableCopy都产生新容器，但是最小元素内存地址都一样，浅拷贝

情况9：容器类（单层），可变类型，元素可变，单次拷贝

NSMutableString *string1 = [NSMutableString stringWithString:@"apple"];
NSMutableString *string2 = [NSMutableString stringWithString:@"pear"];
NSMutableArray *items = [NSMutableArray arrayWithArray:@[string1,string2]];
NSArray *items_copy = items.copy;
NSMutableArray *items_mutableCopy = items.mutableCopy;

输出：

结论：copy、mutableCopy都产生新容器，但是最小元素内存地址都一样，浅拷贝

情况10：容器类（单层），可变类型，元素可变，元素拷贝

NSArray *items_copy = [[NSArray alloc] initWithArray:items copyItems:YES];
NSMutableArray *items_mutableCopy = [[NSMutableArray alloc] initWithArray:items copyItems:YES];

输出：

结论：产生新容器，最小元素内存地址不一样，深拷贝

情况11：容器类（多层，嵌套容器）

参考开始几个例子

结论：

1、容器类是否可以深拷贝，首先要看最小元素，若最小元素为不可变类型，容器类的任何拷贝操作都是浅拷贝

2、如使用copyItems函数，并且元素为可变类型时，可以连元素一起拷贝，属于深拷贝（元素非容器）

向您推荐>>Eolink开发者社区

权威｜前沿｜技术｜干货｜国内首个API全生命周期开发者社区

更多推荐

ELK实现containerd的容器日志采集展示【基于logging的全栈监测】

企业级ELK Stack构建介绍

云原生

深入理解 Mocha 测试框架：从零实现一个 Mocha

前言什么是自动化测试自动化测试在很多团队中都是Devops环节中很难执行起来的一个环节，主要原因在于测试代码的编写工作很难抽象，99%的场景都需要和业务强绑定，而且写测试代码的编写工作量往往比编写实际业务代码的工作量更多。在一些很多业务场景中投入产出比很低，适合写自动化测试的应该是那些中长期业务以及一些诸如组件一样的基础库。自动化测试是个比较大的概念，其中分类也比较多，比如单元测试，端对端测试，集

云原生

(20200916 Solved)docker-compose up创建容器自动退出

问题描述如题，创建容器后自动退出了。并且docker start container无效解决方案原因是缺失了控制终端的配置，需要在docker-compose.yml中增加tty:true ，有时候这样也不行，需要再增加一个command:/bin/bash，命令不一定是这个，需要是一个不会退出的命令，然后用-d后台启动容器。Referencesdocker-compose启动容器后自动退出...

云原生

所有评论(0)

查看更多评论

LOLITA0164

@LOLITA0164

已为社区贡献4条内容