属性关键字尤为重要, 总结复习。
属性关键字就是用来修饰属性的关键字,保证了程序的正常运行。
weak
, assgin
, strong
, retain
, copy
;monatomic
, atomic
readonly
, readwrite
。const
, static
, extern
。weak经常用来OC对象类型的数据,修饰的对象在释放之后,指针地址会自动被置nil,这是弱引用的表现
⚠️:assgin修饰的基本类型都是基本数据类型,基本数据类型分配在栈上的,栈上的变量是系统自动进行管理,不会造成野指针以及:MRC下的delegate往往assgin,此操作是为了deletage和self等自身产生循环引用。
eg:当对象A通过retain持有了B,B的delegate对象是A,如果都是强引用则导致互相持有无法正确的释放,造成循环引用。
strong是最常用的修饰符,主要用来修饰OC对象类型的数据:(NSNumber,NSString,NSArray、NSDate、NSDictionary、模型类等)。 strong是强引用,在ARC下等于retain,这一点区别于weak。
strong是我们通常所说的指针拷贝(浅拷贝),内存地址保持不变,只是产生了一个新的指针,新指针和引用对象的指针指向同一个内存地址,没有生成新的对象,多了一个指向该对象的指针。
⚠️:由于使用的是一个内存地址,当该内存地址存储的内容发生变更的时候导致属性也跟着变更。
同样用于修饰OC对象类型的数据,同时在MRC时期用来修饰block,因为MRC时期block要从栈区copy到堆区。现在的ARC系统自动给我们做了这个操作。也就是现在使用strong或者copy修饰block都可以。
copy和strong相同点在于都是属于强引用,引用计数 + 1,但是copy修饰的对象是内存拷贝,在引用的时候会生成一个新的内存地址和指针,和引用对象完全同,也不会因为引用属性的变更而改变。
copy:内存拷贝-深拷贝,内存地址不同,指针地址也不同。
storng: 指针拷贝-浅拷贝,内存地址不变,指针地址不同。
声明两个copy属性,两个strong属性,分别为可变和不可变类型:
@property(nonatomic,strong)NSString * Strstrong;
@property(nonatomic,copy)NSString * Strcopy;
@property(nonatomic,copy)NSMutableString * MutableStrcopy;
@property(nonatomic,strong)NSMutableString * MutableStrstrong;
1. 不可变对象对属性进行赋值,查看strong修饰和copy修饰的区别
// 不可变对象对属性进行赋值,查看strong修饰和copy修饰的区别
- (void)testNormal {
NSString * OriginalStr = @"我已经开始测试了";
//对 不可变对象赋值 无论是 strong 还是 copy 都是原地址不变,内存地址都为(0x10c6d75c0),生成一个新指针指向对象(浅拷贝)
self.Strcopy = OriginalStr;
self.Strstrong = OriginalStr;
self.MutableStrcopy = OriginalStr;
self.MutableStrstrong = OriginalStr;
// 内容
NSLog(@"原字符串=>%@\n normal:copy=>%@=====strong=>%@\nMutable:copy=>%@=====strong=>%@",OriginalStr,_Strcopy,_Strstrong,_MutableStrcopy,_MutableStrstrong);
// 内存地址
NSLog(@"原字符串=>%p\n normal:copy=>%p=====strong=>%p\nMutable:copy=>%p=====strong=>%p",OriginalStr,_Strcopy,_Strstrong,_MutableStrcopy,_MutableStrstrong);
// 指针地址
NSLog(@"原字符串=>%p\n normal:copy=>%p=====strong=>%p\nMutable:copy=>%p=====strong=>%p",&OriginalStr,&_Strcopy,&_Strstrong,&_MutableStrcopy,&_MutableStrstrong);
}
}
由上面可以看出,strong修饰的对象,在引用一个对象的时候,内存地址都是一样的,只有指针地址不同,copy修饰的对象也是如此。
为什么呢?不是说copy修饰的对象是生成一个新的内存地址嘛?这里为什么内存地址还是原来的呢?
因为,用不可变对象对属性进行赋值,无论是strong还是copy,都是一样的,原内存地址不变,生成了新的指针地址。
2. 可变对象对属性进行赋值,查看strong和copy的区别
// 可变对象对属性进行赋值,查看strong和copy的区别
- (void)testMutable {
NSMutableString * OriginalMutableStr = [NSMutableString stringWithFormat:@"我已经开始测试了"];
//对 不可变对象赋值 无论是 strong 还是 copy 都是原地址不变,内存地址都为(0x10c6d75c0),生成一个新指针指向对象(浅拷贝)
self.Strcopy = OriginalMutableStr;
self.Strstrong = OriginalMutableStr;
self.MutableStrcopy = OriginalMutableStr;
self.MutableStrstrong = OriginalMutableStr;
[OriginalMutableStr appendFormat:@"改变了"];
// 内容
NSLog(@"原字符串=>%@\n normal:copy=>%@=====strong=>%@\nMutable:copy=>%@=====strong=>%@",OriginalMutableStr,_Strcopy,_Strstrong,_MutableStrcopy,_MutableStrstrong);
// 内存地址
NSLog(@"原字符串=>%p\n normal:copy=>%p=====strong=>%p\nMutable:copy=>%p=====strong=>%p",OriginalMutableStr,_Strcopy,_Strstrong,_MutableStrcopy,_MutableStrstrong);
// 指针地址
NSLog(@"原字符串=>%p\n normal:copy=>%p=====strong=>%p\nMutable:copy=>%p=====strong=>%p",&OriginalMutableStr,&_Strcopy,&_Strstrong,&_MutableStrcopy,&_MutableStrstrong);
在上面的结果可以看出,strong修饰的属性内存地址依然没有改变,但是copy修饰的属性内存值产生了变化。
由此得出结论:
对可变对象赋值 strong 是原地址不变,引用计数+1(浅拷贝)。 copy是生成一个新的地址和对象生成一个新指针指向新的内存地址(深拷贝)
3. 此时改变OriginalMutableStr的值
结果:
结果:
在对容器对象(NSArray)进行copy操作时,分为多种:
出现调用可变方法不可控问题,会导致程序崩溃。给Mutable 被声明为copy修饰的属性赋值, 过程描述如下:
nonatomic:非原子操作,不加锁,线程执行快,但是多个线程访问同一个属性可能产生crash
atomic原子操作:加锁,保证setter和getter存取方法的线程安全(仅仅对setter和getter方法加锁)。因为线程加锁,别的线程访问当前属性的时候会先执行完属性当前的操作。
⚠️注意:atomic只针对属性的 getter/setter 方法进行加锁,所以安全只是针对getter/setter方法来说,并不是整个线程安全,因为一个属性并不只有 setter/getter 方法,例:(如果一个线程正在getter 或者 setter时,有另外一个线程同时对该属性进行release操作,如果release先完成,会造成crash)
常量修饰符,表示不可变,可以用来修饰右边的基本变量和指针变量(放在谁的前面修饰谁(基本数据变量p,指针变量*p))。
int x = 12;
int new_x = 21;
const int *px = &x;
px = &new_x; // 改变指针px的指向,使其指向变量y
复制代码int y = 12;
int new_y = 21;
int * const py = &y;
(*py) = new_y; // 改变px指向的变量x的值
使用宏和常量所占用的内存差别不大,宏定义的是常量,常量都放在常量区,只会生成一份内存。
缺点:
优点:
定义所修饰的对象只能在当前文件访问,不能通过extern来引用
默认情况下的全局变量 作用域是整个程序(可以通过extern来引用) 被static修饰后仅限于当前文件来引用 其他文件不能通过extern来引用
⚠️注意:当在对象A里这么写static int i = 10;
当A销毁掉之后 这个i还存在
当再次alloc init一个A的对象之后 在新对象里 依然可以拿到i = 90
除非杀死程序 再次进入才能得到i = 0。
局部变量只会生成一份内存,只会初始化一次。把它分配在静态存储区,该变量在整个程序执行期间不释放,其所分配的空间始终存在
static修饰局部变量还可以延长变脸的生命周期。
- (void)test{
// static修饰局部变量1
static int age = 0;
age++;
NSLog(@"%d",age);
}
-(void)test2{
// static修饰局部变量2
static int age = 0;
age++;
NSLog(@"%d",age);
}
[self test];
[self test2];
[self test];
[self test2];
[self test];
[self test2];
打印 1 1 2 2 3 3
由此可见 变量生命周期延长了,作用域没有变
只是用来获取全局变量(包括全局静态变量)的值,不能用于定义变量。
查找优先级: 先在当前文件查找有没有全局变量,没有找到,才会去其他文件查找。
#import "JMProxy.h"
@implementation JMProxy
int ageJMProxy = 20;
@end
@implementation TableViewController
- (void)viewDidLoad {
[super viewDidLoad];
extern int ageJMProxy;
NSLog(@"%d",ageJMProxy);
}
@end
⚠️ extern不能用于定义变量。
声明一个静态的全局只读常量。开发中声明的全局变量,有些不希望外界改动,只允许读取。
iOS中staic和const常用使用场景,是用来代替宏,把一个经常使用的字符串常量,定义成静态全局只读变量.
// 开发中经常拿到key修改值,因此用const修饰key,表示key只读,不允许修改。
static NSString * const key = @"name";
// 如果 const修饰 *key1,表示*key1只读,key1还是能改变。
static NSString const *key1 = @"name";
在多个文件中经常使用的同一个字符串常量,可以使用extern与const组合
extern与const组合:只需要定义一份全局变量,多个文件共享
@interface Person : NSObject
extern NSString * const nameKey = @"name";
@end
#import "ViewController.h"
@interface ViewController ()
@end
NSString * const nameKey; // 必须用xonst才能访问到 extern与const组合组合修饰的全局变量