iOS中的Copy

最新推荐文章于 2024-08-02 12:05:25 发布
原创 最新推荐文章于 2024-08-02 12:05:25 发布 · 410 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#ios

iOS提供了copy与mutableCopy方法，copy就是复制了一个不可变的对象，而mutableCopy就是复制了一个可变的对象，下面通过几个实例来演示一下。

一、非容器类对象的copy与mutableCopy

    NSString *str = [NSString stringWithFormat:@"%@", @"create by "];
    NSLog(@"str： %p 值：%@ 引用计数：%lu", str, str, [str retainCount]);

    NSString *strCopy = [str copy];
    NSLog(@"strCopy： %p 值：%@ 引用计数：%lu", strCopy, strCopy, [strCopy retainCount]);

    NSMutableString *mStrCopy = [str mutableCopy];
    NSLog(@"mStrCopy： %p 值：%@ 引用计数：%lu", mStrCopy, mStrCopy, [mStrCopy retainCount]);

    NSMutableString *mStrCopy2 = [mStrCopy copy];
    NSLog(@"mStrCopy2：%p 值：%@ 引用计数：%lu", mStrCopy2, mStrCopy2, [mStrCopy2 retainCount]);
    //下面一句代码不注释则引起crash
//    [mStrCopy2 appendString:@"xiangpuhua"];
//    NSLog(@"mStrCopy2：%p 值：%@ 引用计数：%lu", mStrCopy2, mStrCopy2, [mStrCopy2 retainCount]);

    [mStrCopy appendString:@"xiangpuhua"];
    NSLog(@"mStrCopy：%p 值：%@ 引用计数：%lu", mStrCopy, mStrCopy, [mStrCopy retainCount]);

    NSMutableString *mStrCopy3 = [mStrCopy mutableCopy];
    NSLog(@"mStrCopy3：%p 值：%@ 引用计数：%lu", mStrCopy3, mStrCopy3, [mStrCopy3 retainCount]);
    [mStrCopy3 appendString:@"!!!"];
    NSLog(@"mStrCopy3：%p 值：%@ 引用计数：%lu", mStrCopy3, mStrCopy3, [mStrCopy3 retainCount]);

输出结果：

2017-02-27 17:49:42.859 CopyTest[12206:2131173] str： 0x60000002ade0 值：create by  引用计数：1
2017-02-27 17:49:42.859 CopyTest[12206:2131173] strCopy： 0x60000002ade0 值：create by  引用计数：2
2017-02-27 17:49:42.860 CopyTest[12206:2131173] mStrCopy： 0x600000074940 值：create by  引用计数：1
2017-02-27 17:49:42.861 CopyTest[12206:2131173] mStrCopy2：0x60000002ae20 值：create by  引用计数：1
2017-02-27 17:49:42.861 CopyTest[12206:2131173] mStrCopy：0x600000074940 值：create by xiangpuhua 引用计数：1
2017-02-27 17:49:42.861 CopyTest[12206:2131173] mStrCopy3：0x600000074a40 值：create by xiangpuhua 引用计数：1
2017-02-27 17:49:42.861 CopyTest[12206:2131173] mStrCopy3：0x600000074a40 值：create by xiangpuhua!!! 引用计数：1

由输出结果，我们可知，str与strCopy指向同一内存区域，此时str与strCopy的引用计数一样都为2。而mStrCopy则是真正意义上的复制，系统为其分配了新的内存，但指针所指向的字符串还是和str所指的一样。而对mStrCopy进行copy的时候发现mStrCopy2与mStrCopy指向不是同一个指针，说明也是进行了真正意义上的复制，由此我们可以得出以下结论：
1、对不可变对象复制，copy是指针复制（浅拷贝），而mutableCopy是对象复制（深拷贝）
2、对可变对象复制，copy与mutableCopy都是对象复制（深拷贝）。
3、对可变对象复制，copy出来的对象是不可变的。

二、容器类对象的copy与mutableCopy

容器类对象指的是NSArray、NSDictionary等。

    NSArray *arr = @[@"a"];
    NSLog(@"arr： %p 值：%@ 引用计数：%lu", arr, arr, [arr retainCount]);

    NSArray *arrCopy = [arr copy];
    NSLog(@"arrCopy： %p 值：%@ 引用计数：%lu", arrCopy, arrCopy, [arrCopy retainCount]);

    NSMutableArray *mArrCopy = [arr mutableCopy];
    NSLog(@"mArrCopy： %p 值：%@ 引用计数：%lu", mArrCopy, mArrCopy, [mArrCopy retainCount]);

    NSMutableArray *mArrCopy2 = [mArrCopy copy];
    NSLog(@"mArrCopy2：%p 值：%@ 引用计数：%lu", mArrCopy2, mArrCopy2, [mArrCopy2 retainCount]);
    //下面一句代码不注释则引起crash
//    [mArrCopy2 addObject:@"b"];
//    NSLog(@"mArrCopy2：%p 值：%@ 引用计数：%lu", mArrCopy2, mArrCopy2, [mArrCopy2 retainCount]);

    [mArrCopy addObject:@"c"];
    NSLog(@"mArrCopy：%p 值：%@ 引用计数：%lu", mArrCopy, mArrCopy, [mArrCopy retainCount]);

    NSMutableArray *mArrCopy3 = [mArrCopy mutableCopy];
    NSLog(@"mArrCopy3：%p 值：%@ 引用计数：%lu", mArrCopy3, mArrCopy3, [mArrCopy3 retainCount]);
    [mArrCopy3 addObject:@"d"];
    NSLog(@"mArrCopy3：%p 值：%@ 引用计数：%lu", mArrCopy3, mArrCopy3, [mArrCopy3 retainCount]);

输出结果：

2017-02-27 18:01:32.190 ffm[12459:2216832] arr： 0x60000001d6d0 值：(
    a
) 引用计数：1
2017-02-27 18:01:32.190 ffm[12459:2216832] arrCopy： 0x60000001d6d0 值：(
    a
) 引用计数：2
2017-02-27 18:01:32.191 ffm[12459:2216832] mArrCopy： 0x600000248940 值：(
    a
) 引用计数：1
2017-02-27 18:01:32.191 ffm[12459:2216832] mArrCopy2：0x60800001d360 值：(
    a
) 引用计数：1
2017-02-27 18:01:32.191 ffm[12459:2216832] mArrCopy：0x600000248940 值：(
    a,
    c
) 引用计数：1
2017-02-27 18:01:32.192 ffm[12459:2216832] mArrCopy3：0x608000242dc0 值：(
    a,
    c
) 引用计数：1
2017-02-27 18:01:32.192 ffm[12459:2216832] mArrCopy3：0x608000242dc0 值：(
    a,
    c,
    d
) 引用计数：1

由输出结果可知：容器类基本规则与非容器类一致，遵循一下规则
1、对不可变对象复制，copy是指针复制（浅拷贝），而mutableCopy是对象复制（深拷贝）
2、对可变对象复制，copy与mutableCopy都是对象复制（深拷贝）。
3、对可变对象复制，copy出来的对象是不可变的。
但是我们需要研究的是复制后容器内对象的变化。

    NSArray *arr = @[[NSMutableString stringWithString:@"create by "], [NSString stringWithFormat:@"%@", @"xph"]];
    NSLog(@"arr： %p 值：%@ 引用计数：%lu", arr, arr, [arr retainCount]);
    for (int i=0; i<arr.count; i++) {
        id object = arr[i];
        NSLog(@"arr中第%d个元素： %p 值：%@ 引用计数：%lu", i, object, object, [object retainCount]);
    }

    NSArray *arrCopy = [arr copy];
    NSLog(@"arrCopy： %p 值：%@ 引用计数：%lu", arrCopy, arrCopy, [arrCopy retainCount]);
    for (int i=0; i<arrCopy.count; i++) {
        id object = arrCopy[i];
        NSLog(@"arrCopy中第%d个元素： %p 值：%@ 引用计数：%lu", i, object, object, [object retainCount]);
    }

    NSMutableArray *mArrCopy = [arr mutableCopy];
    NSLog(@"mArrCopy： %p 值：%@ 引用计数：%lu", mArrCopy, mArrCopy, [mArrCopy retainCount]);
    for (int i=0; i<mArrCopy.count; i++) {
        id object = mArrCopy[i];
        NSLog(@"mArrCopy中第%d个元素： %p 值：%@ 引用计数：%lu", i, object, object, [object retainCount]);
    }

    NSMutableString *first = mArrCopy[0];
    [first appendString:@"xiangpuhua"];

    NSLog(@"arr： %p 值：%@ 引用计数：%lu", arr, arr, [arr retainCount]);
    for (int i=0; i<arr.count; i++) {
        id object = arr[i];
        NSLog(@"arr中第%d个元素： %p 值：%@ 引用计数：%lu", i, object, object, [object retainCount]);
    }

输出结果：

2017-02-27 18:13:49.963 CopyTest[12598:2286314] arr： 0x6080002281a0 值：(
    "create by ",
    xph
) 引用计数：1
2017-02-27 18:13:49.963 CopyTest[12598:2286314] arr中第0个元素： 0x608000273680 值：create by  引用计数：2
2017-02-27 18:13:49.963 CopyTest[12598:2286314] arr中第1个元素： 0xa000000006870783 值：xph 引用计数：18446744073709551615
2017-02-27 18:13:49.964 CopyTest[12598:2286314] arrCopy： 0x6080002281a0 值：(
    "create by ",
    xph
) 引用计数：2
2017-02-27 18:13:49.964 CopyTest[12598:2286314] arrCopy中第0个元素： 0x608000273680 值：create by  引用计数：2
2017-02-27 18:13:49.964 CopyTest[12598:2286314] arrCopy中第1个元素： 0xa000000006870783 值：xph 引用计数：18446744073709551615
2017-02-27 18:13:49.964 CopyTest[12598:2286314] mArrCopy： 0x60800024c4e0 值：(
    "create by ",
    xph
) 引用计数：1
2017-02-27 18:13:49.965 CopyTest[12598:2286314] mArrCopy中第0个元素： 0x608000273680 值：create by  引用计数：3
2017-02-27 18:13:49.965 CopyTest[12598:2286314] mArrCopy中第1个元素： 0xa000000006870783 值：xph 引用计数：18446744073709551615
2017-02-27 18:13:49.965 CopyTest[12598:2286314] arr： 0x6080002281a0 值：(
    "create by xiangpuhua",
    xph
) 引用计数：2
2017-02-27 18:13:49.965 CopyTest[12598:2286314] arr中第0个元素： 0x608000273680 值：create by xiangpuhua 引用计数：3
2017-02-27 18:13:49.967 CopyTest[12598:2286314] arr中第1个元素： 0xa000000006870783 值：xph 引用计数：18446744073709551615

由此可知：不管是copy还是mutableCopy，容器内元素只是实现了指针的复制（浅拷贝）。
如果要实现容器内的元素也是深拷贝，怎么办呢？

NSArray *arr = @[@[[NSMutableString stringWithString:@"create by "]].mutableCopy, [NSMutableString stringWithString:@"iOS "], [NSString stringWithFormat:@"%@", @"xph"]];
    NSArray *deepCopyArray = [[NSArray alloc] initWithArray:arr copyItems:YES];
    NSArray *deepCopyArray2 = [NSKeyedUnarchiver unarchiveObjectWithData:
                                  [NSKeyedArchiver archivedDataWithRootObject:arr]];
    NSLog(@"1： %p 值：%@ 引用计数：%lu", arr, arr, [arr retainCount]);
    NSLog(@"2： %p 值：%@ 引用计数：%lu", deepCopyArray, deepCopyArray, [deepCopyArray retainCount]);
    NSLog(@"3： %p 值：%@ 引用计数：%lu", deepCopyArray2, deepCopyArray2, [deepCopyArray2 retainCount]);
    for (int i=0; i<arr.count; i++) {
        id o1 = arr[i];
        id o2 = deepCopyArray[i];
        id o3 = deepCopyArray2[i];
        NSLog(@"1、中第%d个元素： %p 值：%@ 引用计数：%lu", i, o1, o1, [o1 retainCount]);
        NSLog(@"2、中第%d个元素： %p 值：%@ 引用计数：%lu", i, o2, o2, [o2 retainCount]);
        NSLog(@"3、中第%d个元素： %p 值：%@ 引用计数：%lu", i, o3, o3, [o3 retainCount]);
        if ([o1 isKindOfClass:[NSArray class]]) {
            for (id oo in o1) {
                NSLog(@"1、子元素： %p 值：%@ 引用计数：%lu", oo, oo, [oo retainCount]);
            }
        }
        if ([o2 isKindOfClass:[NSArray class]]) {
            for (id oo in o2) {
                NSLog(@"2、子元素： %p 值：%@ 引用计数：%lu", oo, oo, [oo retainCount]);
            }
        }
        if ([o3 isKindOfClass:[NSArray class]]) {
            for (id oo in o3) {
                NSLog(@"3、子元素： %p 值：%@ 引用计数：%lu", oo, oo, [oo retainCount]);
            }
        }
    }

输出结果：

2017-02-27 22:20:00.628 CopyTest[14436:3967892] 1： 0x60000005d010 值：(
        (
        "create by "
    ),
    "iOS ",
    xph
) 引用计数：1
2017-02-27 22:20:00.628 CopyTest[14436:3967892] 2： 0x60000005d040 值：(
        (
        "create by "
    ),
    "iOS ",
    xph
) 引用计数：1
2017-02-27 22:20:00.628 CopyTest[14436:3967892] 3： 0x60000005d490 值：(
        (
        "create by "
    ),
    "iOS ",
    xph
) 引用计数：1
2017-02-27 22:20:00.628 CopyTest[14436:3967892] 1、中第0个元素： 0x60000005cfe0 值：(
    "create by "
) 引用计数：2
2017-02-27 22:20:00.629 CopyTest[14436:3967892] 2、中第0个元素： 0x60000000afd0 值：(
    "create by "
) 引用计数：1
2017-02-27 22:20:00.629 CopyTest[14436:3967892] 3、中第0个元素： 0x60000005d2e0 值：(
    "create by "
) 引用计数：1
2017-02-27 22:20:00.629 CopyTest[14436:3967892] 1、子元素： 0x600000077700 值：create by  引用计数：4
2017-02-27 22:20:00.629 CopyTest[14436:3967892] 2、子元素： 0x600000077700 值：create by  引用计数：4
2017-02-27 22:20:00.629 CopyTest[14436:3967892] 3、子元素： 0x600000077ac0 值：create by  引用计数：1
2017-02-27 22:20:00.629 CopyTest[14436:3967892] 1、中第1个元素： 0x600000077780 值：iOS  引用计数：2
2017-02-27 22:20:00.630 CopyTest[14436:3967892] 2、中第1个元素： 0xa00000020534f694 值：iOS  引用计数：18446744073709551615
2017-02-27 22:20:00.631 CopyTest[14436:3967892] 3、中第1个元素： 0x600000077b80 值：iOS  引用计数：1
2017-02-27 22:20:00.631 CopyTest[14436:3967892] 1、中第2个元素： 0xa000000006870783 值：xph 引用计数：18446744073709551615
2017-02-27 22:20:00.631 CopyTest[14436:3967892] 2、中第2个元素： 0xa000000006870783 值：xph 引用计数：18446744073709551615
2017-02-27 22:20:00.631 CopyTest[14436:3967892] 3、中第2个元素： 0xa000000006870783 值：xph 引用计数：18446744073709551615

根据输出结果我们可知，deepCopyArray实现了一层的深拷贝，也就是说deepCopyArray实现了其内第一层元素（即数组的直接元素）的深拷贝，当数组中的元素为容器类元素时，无法实现第二层数据的深拷贝，而deepCopyArray2实现了真正的深拷贝。（官网解释）

总结如下：
1、对不可变对象复制，copy是指针复制（浅拷贝），而mutableCopy是对象复制（深拷贝）
2、对可变对象复制，copy与mutableCopy都是对象复制（深拷贝）。
3、对可变对象复制，copy出来的对象是不可变的。
4、容器类对象copy与mutableCopy时，元素均为指针复制（浅拷贝）。
5、使用initWithArray:copyItems:且第二个参数为YES的时候实现了一层的深拷贝
6、容器类对象中的元素不可变时，对象复制（深拷贝）并没有真正拷贝对象，而是指针的拷贝。

三、copy关键字

（1）NSString、NSArray、NSDictionay等经常使用copy关键字。
原因：因为父类指针可以指向子类对象，使用copy的目的是为了让本对象的属性不受外界影响，使用copy无论给我传入是一个可变对象还是不可对象，我本身持有的就是一个不可变的副本，如果我们使用是strong，那么这个属性就有可能指向一个可变对象，如果这个可变对象在外部被修改了，那么会影响该属性。

//User.h文件中

@property (nonatomic, strong) NSString *name;//此时若将一个可变字符串set给name，那么此时的name则指向的是一个可变字符，那么就无法保证name的不可变性   
@property (nonatomic, copy) NSString *name;//此时若将一个可变字符串set给name，此时会执行[MutableString copy]内容复制，即深复制，将返回一个不可变字符串，即name指向的是一个不可变字符串，以后即使MutableString改变也不会影响name的值           
  例如：

NSMutableString *string = [NSMutableString stringWithString:@"origin"];//copy
NSString *stringCopy = [string copy];
[string appendString:@"origion!"]

此时的打印结果：string：originorigion!，而stringCopy仍为:origin
（2）block也经常会使用copy关键字
原因：block使用copy是从MRC遗留下来的“传统”，在MRC中，方法内部的block是在栈区的，使用copy可以把它放到堆区。在ARC中写不写都行。对于block使用copy还是strong效果是一样的，但写上copy也无伤大雅，还能时刻提醒我们：编译器自动对block进行了copy操作。

iOS中的浅拷贝与深拷贝
老猿的自留地
02-17 658
在iOS中分为浅拷贝和深拷贝。浅拷贝是指针复制，与源对象指向同一内存地址，源对象的引用计数器会＋1。深拷贝是内容拷贝，两个对象内容相同，新的对象 retain 为 1 ，与旧有对象的引用计数无关，旧有对象没有变化。copy 会减少对象对上下文的依赖。retain 属性表示两个对象地址相同，内容也相同，这个对象的引用计数器+1。2. 什么时候是深拷贝，什么时候是浅拷贝系统的非容器类对象指的是 NSString，NSNumber 这些不能包含其他对象的对象。在非容器类对象中。
iOS关于Copy和mutableCopy方法的浅析
CoderL
06-10 2234
以数组为例，来记录一下Copy 和 mutableCopy的使用细节。 我们知道可变数组和不可变数组之间的转化可以通过下面的方式： [NSMutableArray copy] --> NSArray [NSArray mutableCopy] --> NSMutableArray 我们也知道: （图片来自网络） 那么当我们调用数组的mutableCopy方法时，是否将数组中所包含的对应也深拷贝了呢? testClass* class0 = [testClass new]; cl.
ios copy关键字的使用
精灵的专栏
05-08 3256
转自：http://jordy.easymorse.com/?cat=26 copy关键字的使用 平时我们使用对象之间的传值都是采用retain count +1的方式，这种方式的适用于当对象的某属性的值改变时，引用该对象的不同指针会同时改变，因为这两个指针指向的是同一个内存地址， 但如果需求是，当一个指针执行的对象属性值发生改变时，不影响另一个对象，那么需要分配两个不同的内存地址，也就
iOS copy
kaka
04-04 798
Copying 在 iOS 中有很多概念，例如浅拷贝与深拷贝、copy 与 mutableCopy、NSCopying 协议，一直想彻底搞明白这些概念，刨根问底不搞懂不罢休嘛。于是搜 Google 看了一些博客，又去翻了 Apple 相关的文档，发现网上许多博客都理解错了，下面说说自己的理解。浅拷贝与深拷贝对于浅拷贝（Swallow Copy）与深拷贝（Deep Copy），经常看到这样的说法：浅...
iOS 之 copy
seven_little的博客
11-08 350
copy 属性，就是将属性copy出一个新的内存来存储副本对象。两个对象是不同的内存区域 首先，须实现协议或者协议 NSSting,NSMutableString; NSArray  NSMutableArray ; NSDictionary   NSMutableDictionary copy:产生的新的对象是不可变的 mutableCopy：产生的新的对象是可变的 浅
iOS中的copy及其用法
骑驴找马追骆驼_so的博客
06-01 938
copy的概念特点 copy产生一个新副本的过程 copy：创建一个不可变的副本(NSString;NSArray;NSDictionary;) mutableCopy :创建一个可变的副本 (NSMutableDictionary; NSMutableArray;NSMutableString) 修改新文件，不会影响原文件 修改原文件，不会影响新文件 copy的实现 必须遵守NSC
浅析iOS中的浅拷贝和深拷贝(copy和mutableCopy)
01-20
本文将深入浅析iOS中的`copy`和`mutableCopy`方法，以及它们与`retain`操作的区别。 首先，`copy`方法用于创建一个新的不可变对象，其内容与原对象相同。这意味着如果原始对象是不可变的（如`NSString`），`copy`会...
ios：文本框默认的copy、past改成中文复制粘贴
分享前端开发工程师的一些日常生活、前端知识点、职业发展、对一些问题的看法、感悟等等
05-30 767
ios 开发，对于输入框的一些默认文案展示，如复制粘贴是英文的，那么如何改为中文的呢。按照路径找到这个文件。
IOS中（assign，retain，copy，weak，strong）的区别以及nonatomic的含义
08-31
iOS 中 assign、retain、copy、weak、strong 的区别以及 nonatomic 的含义 iOS 中，在声明@property 属性时，总是要在括号中写上assign、retain、copy、weak、strong 中的一个，这些修饰符有什么区别？下面我们来...
iOS之拷贝
qianqian的博客
06-21 393
对象拷贝 浅拷贝和深拷贝 深浅拷贝便于理解的定义，如下： 浅拷贝：在拷贝操作时，对于被拷贝的对象的每一层拷贝都是指针拷贝。深拷贝：在拷贝操作时，对于被拷贝的对象至少有一层拷贝是深拷贝。完全拷贝：在拷贝操作时，对于被拷贝的对象的每一层拷贝都是对象拷贝。 注： 所谓的层次划分是指数组对象本身和数组内对
小结 iOS 中的 copy
weixin_33777877的博客
05-23 167
预备知识 :   内存的栈区 : 由编译器自动分配释放, 存放函数的参数值, 局部变量的值等. 其 操作方式类似于数据结构中的栈.   内存的堆区 : 一般由程序员分配释放, 若程序员不释放, 程序结束时可能由OS回 收. 注意它与数据结构中的堆是两回事, 分配方式倒是类似于链表.     copy方法和mutableCopy方法   如果你想要创建一个对象, 该对象与源对象...
IOS 深复制（深拷贝）和浅复制（浅拷贝）
programmer589的博客
04-02 372
// 深浅复制1 - (IBAction)copyAction1:(id)sender { NSString *string0 = [NSString stringWithFormat:@"ABCDEFG"]; NSString *string1 = [string0 copy]; // 浅复制 NSMutableString *string2 = [string0 m...
iOS 中copy的简单理解
kobeWei
04-07 534
一个对象的准确类型是在分配内存空间的时候指定 ，程序员指定的类型只是让该对象有该类型的方法。 能否使用指定类的方法取决于运行时，这个对象的类型是否正确。（理解这两句句话很重要） 有可变不可变之分时： 可变 -》不可变  copy  可变 -》可变 mutableCopy 不可变 -》可变 mutableCopy 不可变 -》不可变 copy  不可变做一次copy 得到
iOS Copy的理解
QQQ274628593的博客
10-31 946
个人关于Copy的理解
iOS的copy概念详解
lushuner的专栏
09-16 726
1. copy概念浅复制与深复制 copy即复制，有浅复制和深复制两种。浅复制即引用复制，只拷贝对象的引用，不分配新的内存空间，深复制即对象拷贝，会创建一个对象的副本，分配新的内存空间，与原对象独立。 深复制（深拷贝，内容拷贝，deep copy） 源对象和副本对象是不同的两个对象 源对象引用计数器不变, 副本对象计数器为1（因为是新产生的） 本质是：产生了新的对象浅复制（浅拷贝，指针拷贝
iOS copy和mutablecopy
u012490014的专栏
05-11 593
    就单纯的自己定义的类来说，copy和mutablecopy，与浅拷贝和深拷贝没有什么关系，关键是自己怎么实现NSCopying和NSMutableCopying这两个协议，如果协议实现的的时候只是拷贝指针，那就是浅拷贝，如果又申请一块内存并且把内容复制，那就是深拷贝，但是对于系统自带的容器类和NSString就要另外分了，因为协议的实现我们是看不到的，所以只能测试NSString首先测试N...
iOS中copy和mutableCopy的详细分析
nineteen_的博客
09-17 3656
copy和mutableCopy在实际开发中常用到，同时，copy属性修饰符也是我们在定义NSString、NSArray和block等需要用到的，要较好地掌握它们，需要从原理上去分析于理解，本文侧重于分析copy和mutableCopy是如何实现的，进一步讲解使用copy和mutableCopy时应该注意的细节问题 本文分成两个部分来讲解说明，第一个是copy和mutableCopy方法的使用
iOS copy和mutableCopy 整理
weixin_30446197的博客
09-03 172
copy 和 mutableCopy 你真的理解吗？最近发现很多面试者基本都不能很好地回答这个问题。所以整理一下。 copy和mutableCopy的概念： copy浅拷贝，不拷贝对象本身，仅仅是拷贝指向对象的指针。 NSString *str1 = @"str1"; NSString *str2 = [str1 copy]; NSLog(@"\nst...
【iOS】copy&strong原理+深浅拷贝+完全拷贝
cheng_lin0201的博客
08-02 1268
copy&strong原理+深浅拷贝+完全拷贝
iOS 打包报错copy fail
最新发布
03-18
好的，我现在需要解决用户提到的iOS打包时出现的'copy fail'错误。首先，我得回忆一下常见的iOS打包错误以及相关的解决方法。根据用户提供的引用内容，特别是引用[2]中提到的自动管理签名和配置文件生成，可能和代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值