美文网首页iOS学习iOS登顶之路
iOS 关于容器类的浅、深拷贝探究

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

作者: 小白进城 | 来源:发表于2017-10-23 20:35 被阅读175次

    引子

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

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

    容器类拷贝的误解

    针对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函数，并且元素为可变类型时，可以连元素一起拷贝，属于深拷贝（元素非容器）

    相关文章

      网友评论

        本文标题：iOS 关于容器类的浅、深拷贝探究

        本文链接：https://www.haomeiwen.com/subject/vyqzuxtx.html

        延伸阅读

        深度阅读

        • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

        栏目导航

        热点阅读

        iOS学习

        iOS登顶之路

        关于我们|服务条款|联系我们|iOS 关于容器类的浅、深拷贝探究|投稿指南|网站地图|RSS订阅|排版工具|手机版

        提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

        Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

        备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

        本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

        所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！