在Xcode4中编辑代码,Xcode4编写代码

2019-08-16 04:15栏目:电脑操作

在Xcode4中编辑代码,Xcode4编写代码

 

Xcode4中达成了机动参照总计,不用再领悟对变量调用release或许autorelease方法开始展览参谋总括管理了,那样一来会缓慢解决技术员非常多承受。

Xcode4中贯彻了自动参照总结,不用再显著对变量调用release只怕autorelease方法进行仿照效法总结管理了,那样一...

objective-c 语法神速过(6)内部存款和储蓄器管理原理,objectivec语法

内存管理基本原理(最重要)

  • 一举手一投足设备的内部存款和储蓄器非常轻松(iphone 4内部存款和储蓄器512M),每一种app所能占用的内部存款和储蓄器是有限制的(几十兆而已)。
  • 当app所攻陷的内部存款和储蓄器比较多时,系统会产生内部存储器警告,那时得回收部分无需再使用的内部存储器空间。比如回收部分不要求利用的目标、变量等
  • 管制范围:任何承接了NSObject的对象,对任何核心数据类型(int、char、float、double、struct、enum等)无效,和 java 不等同,oc 开头的时候从不污源自动回收机制。

OC对象的中央结构

图片 1

每一种OC对象皆有和谐的援用计数器,是二个四字节的整数,表示“对象被引述的次数”,即有多少人正在使用那几个OC对象

每一种OC对象内部特地有4个字节的累积空间来囤积援用计数器(面试题)

援用计数器的功效

当使用alloc、new恐怕copy创造多个新指标时,新对象的引用计数器私下认可便是1,当多少个对象的援用计数器值为0时,对象占用的内部存款和储蓄器就能够被系统回收。换句话说,如若目的的计数器不为0,那么在全部程序运营进度,它占用的内部存款和储蓄器就不容许被回收,除非整套程序已经脱离。

引用计数器的操作

给目的发送一条retain新闻(代表调用这几个指标方法),能够使援引计数器值 1(retain方法重临对象自己)

给指标发送一条release新闻,可以使引用计数器值-1,没有再次回到值

能够给目的发送retainCount音讯获得当前的引用计数器值

对象的销毁(IOS6事先)

当二个对象的引用计数器值为0时,那么它将被销毁,其占用的内部存款和储蓄器被系统回收,

  • 当多个对象被灭绝时,系统会活动向指标发送一条dealloc音信,
  • 一般会重写dealloc方法,在此间释放相关财富,dealloc如同对象的濒临灭绝的危险遗言,

假定重写了dealloc方法,就非得调用[super dealloc],而且位居最终边调用(类似 c 的析构函数,析构函数的调用顺序和构造函数的调用顺序完全相反),

  • 永不直接调用dealloc方法,
  • 假设目的被回收了,它占用的内部存款和储蓄器就不再可用,坚持不渝采纳会促成程序崩溃(野指针错误)

Xcode的设置,取消 ARC

 

要想手动调用retain、release等措施,在成立项目标时候绝不勾选ARC(自动引用计数)

/* 文件名:Person.h */
#import <Foundation/Foundation.h>
@interface Person : NSObject
@property int age;
@end

/* 文件名:Person.m */
#import "Person.h"
@implementation Person
// 当一个Person对象被回收的时候,就会自动调用这个方法
- (void)dealloc
{
    NSLog(@"Person对象被回收");
    // super的dealloc一定要调用,而且放在最后面
    [super dealloc];
}
@end

//  main.m
 1> retain :计数器 1,会返回对象本身
 2> release :计数器-1,没有返回值
 3> retainCount :获取当前的计数器
 4> dealloc,当一个对象要被回收的时候,就会调用这个函数,一定要调用[super dealloc],且这句调用要放在最后面。

 概念
 1> 僵尸对象 :所占用内存已经被回收的对象,僵尸对象不能再使用
 2> 野指针 :指向僵尸对象(不可用内存)的指针,给野指针发送消息会报错(EXC_BAD_ACCESS)
 3> 空指针 :没有指向任何东西的指针(存储的东西是nil、NULL、0),给空指针发送消息不会报错 ,这是 oc 的语法,但是其他语言不一定。比如 java 就不行。

#import <Foundation/Foundation.h>
#import "Person.h"

int main()
{
    // 计数器=1
    Person *p = [[Person alloc] init];

    //NSUInteger c = [p retainCount];
  //NSLog(@"计数器:%ld", c);
  //这样写不太好,注意是长整型

    // 计数器=2 retain方法返回的是对象本身
    [p retain];

    // 计数器=1,没有返回值
    [p release];

    // 计数器=0,对象的内存被释放,p 成了野指针:指向僵尸对象(不可用内存)的指针
    [p release];


   //给野指针发送消息,错误!也就是不能使用僵尸对象,人死不能复生!
    // [p retain];

    // 给已经释放的对象发送了一条-setAge:消息:
    // p.age = 10;使用野指针,报错
   //[p setAge:10];
    // -[Person setAge:]: message sent to deallocated instance 0x100109a10

    //如果继续 release,也会报错。重复析构
    // EXC_BAD_ACCESS : 访问了一块坏的内存(已经被回收、已经不可用的内存


  // 野指针错误
  // 但是记住:OC不存在空指针错误,给空指针发送消息,oc里不报错,故解决办法:
    // 把指针p变成空指针
    //p = nil;这样下面的语就对了,否则就是野指针错误
    [p release];
    [p release];
    [p release];
    [p release];

    [nil release];//ok

    return 0;
}

1.当须要采用int类型的变量的时候,能够像写C的次序同样,用int,也能够用NSInteger,但更推荐应用NSInteger,因为这么就不用思索配备是三12位的要么陆14位的。

2.NSUInteger是无符号的,即未有负数,NSInteger是有记号的。

敞开活死人对象监察和控制

暗中认可情形下,Xcode是不会管丧尸对象的,使用一块被释放的内部存款和储蓄器也不会报错。为了方便调节和测验,应该张开丧尸对象监察和控制

图片 2

 

 

图片 3

内存管理原则

QQ堂开房间原理:只要房间还应该有人在用,就不会解散

  • 要是还会有人在用有个别对象,那么那些目的就不会被回收
  • 设若您想用这些指标,就让对象的计数器 1
  • 当你不再采用那几个目的时,就让对象的计数器-1

图片 4

谁创建,谁release

如若您通过alloc、new或[mutable]copy来创立一个目的,那么您不可能不调用release或autorelease,换句话说,不是你成立的,就不要你去[auto]release

谁retain,谁release

假若您调用了retain,无论这么些指标是哪些变化的,你都要调用release

总结

坚持不渝,有加就有减

已经让对象的计数器 1,就亟须在最后让对象计数器-1

你想行使(占用)有个别对象,就活该让对象的计数器 1(让对象做三遍retain操作),不想再选拔(占用)有个别对象,就应当让对象的计数器-1(让对象做一回release)

set方法的内部存款和储蓄器管理

设若有个OC对象类型的成员变量,就不可以小视理这一个成员变量的内部存款和储蓄器。比如有个Book *_book,而大家事先的做法并不不追求虚名。

/*
文件名:Car.h
 */
#import <Foundation/Foundation.h>

@interface Car : NSObject
{
    int _speed;
}
- (void)setSpeed:(int)speed;
- (int)speed;
@end

/*文件名:Car.m */
#import "Car.h"
@implementation Car
- (void)setSpeed:(int)speed
{
    _speed = speed;
}
- (int)speed
{
    return _speed;
}
- (void)dealloc
{
    /*只有对象计数器=0,这个方法是自动调用的!
     _speed :最直接的访问成员变量
     self->_speed :直接访问成员变量
     self.speed : 兼容的get方法
     [self speed] : 原装的get方法
     */
    NSLog(@"速度为%d的Car对象被回收了", _speed);
    [super dealloc];
}
@end

/*
文件名:Person.h
 */
#import <Foundation/Foundation.h>
#import "Car.h"
@interface Person : NSObject
{
    Car *_car;
    int _age;
}

- (void)setAge:(int)age;
- (int)age;

- (void)setCar:(Car *)car;
- (Car *)car;
@end

/*
文件名:Person.m
 */
#import "Person.h"
// _car -> c1  0
@implementation Person
- (void)setCar:(Car *)car
{
    if (car != _car)
    {
        // 对当前正在使用的车(旧车)做一次release,因为假如换车了,说明旧车不用了!那么没有这个操作,就会出问题
        [_car release];
        // 对新车做一次retain操作
        _car = [car retain];
    }
}

- (Car *)car
{
    return _car;
}

- (void)setAge:(int)age
{ // 基本数据类型不需要管理内存
    _age = age;
}

- (int)age
{
    return _age;
}

- (void)dealloc
{
    // 当人不在了,代表不用车了
    // 对车做一次release操作
    [_car release];
    NSLog(@"%d岁的Person对象被回收了", _age);
    [super dealloc];
}
@end

/*文件名:Student.h */
#import <Foundation/Foundation.h>
#import "Car.h"
#import "Dog.h"
@interface Student : NSObject
{
    int _no;
    NSString *_name;
    Car *_car;
    Dog *_dog;
}

- (void)setNo:(int)no;
- (int)no;

- (void)setName:(NSString *)name;
- (NSString *)name;

- (void)setCar:(Car *)car;
- (Car *)car;

- (void)setDog:(Dog *)dog;
- (Dog *)dog;
@end

/*文件名:Student.m */
#import "Student.h"
@implementation Student
- (void)setNo:(int)no
{
    _no = no;
}
- (int)no
{
    return _no;
}

- (void)setName:(NSString *)name
{
    //如果换名字了,说明旧名字不用了,那么必须 release,否则出错!同时别       忘记给新名字 retain(记住原则,我想用或者占用了,就必须 retain 一次,不想要或者丢掉就必须 release 一次)
    if ( name != _name )
    {
        [_name release];
        _name = [name retain];
    }
}
    //get 方法不用内存管理,基本数据类型的成员也不要内存管理
- (NSString *)name
{
    return _name;
}

- (void)setCar:(Car *)car
{
    if ( car != _car )
    {
        [_car release];
        _car = [car retain];
    }
}

- (Car *)car
{
    return _car;
}

- (void)setDog:(Dog *)dog
{
    if ( dog != _dog )
    {
        [_dog release];
        _dog = [dog retain];
    }
}

- (Dog *)dog
{
    return _dog;
}

- (void)dealloc
{
    [_name release];
    [_car release];
    [_dog release];

    [super dealloc];
}
@end

/*文件名:Dog.h */
#import <Foundation/Foundation.h>

@interface Dog : NSObject
@end

/*文件名:Dog.m */
#import "Dog.h"
@implementation Dog
@end

//  main.m
#import <Foundation/Foundation.h>
#import "Car.h"
#import "Person.h"
#import "Student.h"
#import "Dog.h"

int main()
{
    // stu = 1
    Student *stu = [[Student alloc] init];

    // Car = 2
    // 这行内存有内存泄露
    //stu.car = [[Car alloc] init];

    // stu = 0
    // Car = 1
    [stu release];


    // 这行内存有内存泄露
    // [[Car alloc] init].speed = 100;

    return 0;
}

void test3()
{
    Student *stu = [[Student alloc] init];

    Car *c = [[Car alloc] init];
    stu.car = c;

    Dog *d = [[Dog alloc] init];
    stu.dog = d;

    NSString *s = @"Jack";

    stu.name = s;

    [d release];
    [c release];
    [stu release];
}

void test2()
{
    Person *p1 = [[Person alloc] init];
    p1.age = 20;

    // c1 - 1
    Car *c1 = [[Car alloc] init];
    c1.speed = 100;
    // c1 - 2
    p1.car = c1;
    // c1 - 1
    [c1 release];

    Car *c2 = [[Car alloc] init];
    c2.speed = 200;
    // c1 - 0
    p1.car = c2;

    [c2 release];

    [p1 release];
}

void test1()
{
    // p-1
    Person *p = [[Person alloc] init];
    p.age = 20;

    // c1-1
    Car *c1 = [[Car alloc] init];
    c1.speed = 250;

    // c1-2
    p.car = c1;

    // c1-1
    [c1 release];

    p.car = c1;
    p.car = c1;
    p.car = c1;
    p.car = c1;
    p.car = c1;
    p.car = c1;
    p.car = c1;

    [p release];
}

void test()
{
    // p-1
    Person *p = [[Person alloc] init];
    p.age = 20;

    // c1-1
    Car *c1 = [[Car alloc] init];
    c1.speed = 250;

    // p想拥有c1
    // c1-2
    p.car = c1;  // [p setCar:c1];

    // c2-1
    Car *c2 = [[Car alloc] init];
    c2.speed = 300;

    // p将车换成了c2
    // c1-1
    // c2-2
    p.car = c2;

    // c2-1
    [c2 release];
    // c1-0
    [c1 release];
    // p-0 c2-0
    [p release];
}

内部存款和储蓄器管理代码标准:

 1.假设调用了alloc,必须有release(autorelease),   对象不是因此alloc发生的,就没有必要release

 2.set办法的代码标准

 1> 基本数据类型:直接复制

 - (void)setAge:(int)age
 {

    _age = age;

 }

 2> OC对象类型

- (void)setCar:(Car *)car
 {

    // 1.先判断是不是新传进来对象

    if ( car != _car )
    {

        // 2.对旧对象做一次release

        [_car release];

        // 3.对新对象做一次retain

        _car = [car retain];
    }

 }

 3.dealloc方法的代码标准

 1> 一定要[super dealloc],何况放到最终边

 2> 对self(当前)所享有的别的对象做叁次release

- (void)dealloc
 {
    [_car release];
    [super dealloc];
 }

怎么样是码农,那样的重新代码的编排正是码农的职业,so苹果出了计策,IDE 自动落成都部队分重复性代码的编纂工作。

XCODE 能够帮大家省掉编写那多少个恶心代码的专业。使用@property自动生成内部存储器管理的代码,可是dealloc 方法依然要团结写,那时候就有了 ARC,IOS5自此出的新特色。

@property参数

决定set方法的内部存款和储蓄器处理

  • retain : release旧值,retain新值(用于OC对象)
  • assign : 间接赋值,不做别的内存管理(暗中同意,用于非OC对象类型)
  • copy   : release旧值,copy新值(一般用于NSString *)
/*文件名:Book.h */
#import <Foundation/Foundation.h>
@interface Book : NSObject
@end

/*文件名:Book.m */
#import "Book.h"
@implementation Book
@end

/*文件名:Person.h */
#import <Foundation/Foundation.h>
#import "Book.h"
@interface Person : NSObject
@property int age;

// retain : 生成的set方法里面,release旧值,retain新值
@property (retain) Book *book;
@property (retain) NSString *name;
@end

/*文件名:Person.m */
#import "Person.h"
@implementation Person

- (void)dealloc
{
    [_book release];
    [_name release];
    [super dealloc];
}
@end

/*文件名:Student.h */
#import <Foundation/Foundation.h>
#import "Book.h"

@interface Student : NSObject

@property (retain) Book *book;

@property (retain) NSString *name;

@end

/*文件名:Student.m */
#import "Student.h"
@implementation Student

- (void)dealloc
{
    [_book release];
    [_name release];
    [super dealloc];
}
@end

//  main.m
#import <Foundation/Foundation.h>
#import "Person.h"
#import "Book.h"

int main()
{
    Book *b = [[Book alloc] init];
    Person *p = [[Person alloc] init];

    p.book = b;

    NSLog(@"%ld", [b retainCount]);

    [p release];
    [b release];
    return 0;
}

调整需不需生成set方法

  • readwrite 同有的时候间生成set方法和get方法(暗中认可),这里把 set 看成写,get 看成读取,就很好驾驭了。
  • readonly  只会生成get方法(只读,便是只是收获,那么正是 get)

八线程管理

  • atomic    性能低(默认)
  • nonatomic 质量高(写程序要运用那一个)

决定set方法和get方法的名称

  • setter : 设置set方法的称号,一定有个冒号:
  • getter : 设置get方法的称谓
/*文件名:Person.h */
#import <Foundation/Foundation.h>
/*
 1.set方法内存管理相关的参数
 * retain : release旧值,retain新值(适用于OC对象类型)
 * assign : 直接赋值(默认,适用于非OC对象类型,写不写都行)
 * copy   : release旧值,copy新值

 2.是否要生成set方法
 * readwrite : 同时生成setter和getter的声明、实现(默认)
 * readonly  : 只会生成getter的声明、实现

 3.多线程管理
 * nonatomic : 性能高 (一般就用这个)
 * atomic    : 性能低(默认)

 4.setter和getter方法的名称
 * setter : 决定了set方法的名称,一定要有个冒号 :
 * getter : 决定了get方法的名称(一般用在BOOL类型)
 */

@interface Person : NSObject
// 返回BOOL类型的方法名一般以is开头
@property (getter = isRich) BOOL rich;
//   
@property (nonatomic, assign, readwrite) int weight;
// setWeight:
// weight
// 
@property (readwrite, assign) int height;

@property (nonatomic, assign) int age;

@property (retain) NSString *name;
@end

/*文件名:Person.m */
#import "Person.h"
@implementation Person
@end

//  main.m
#import <Foundation/Foundation.h>
#import "Person.h"
int main()
{
    Person *p = [[Person alloc] init];

    p.rich = YES;

    BOOL b = p.isRich;

    return 0;
}

巡回引用(盛名的难点)

@class的使用

运用处境;对于循环正视关系以来,比如A类援引B类,同一时候B类也引用A类

图片 5

这种代码直接编写翻译会报错。当使用@class在两个类相互注解,就不会油但是生编写翻译报错

用法总结

动用 @class 类名; 就足以援用多个类,说Bellamy(Bellamy)(Karicare)下它是四个类

和#import的区别

#import格局会包涵被援引类的持有消息,包含被援用类的变量和办法;

@class情势只是告诉编写翻译器在A.h文件中 B *b 只是类的评释,具体这一个类里有什么新闻,这里无需领会,等完成文件中真的要用到时,才会真的去查看B类中音讯,假如有很五个头文件都#import了同三个文件,大概这几个文件相继被#improt,那么只要最开首的头文件稍有转移,后边援用到那么些文件的全体类都亟待再一次编译一次,那样的频率也是总来讲之的,而相对来说,使用@class方式就不会冒出这种主题材料了。

在.m达成公文中,就算急需援用到被援引类的实体变量大概措施时,还亟需接纳#import情势引进被引用类

循环retain

比方A对象retain了B对象,B对象retain了A对象,那样会导致A对象和B对象恒久不可能自由

消除方案

当互相相互引用时,应该一端用retain、一端用assign

/*描述:
每个身份证都对应一个人,同时,每个人都对于一个身份证,这就是相互依赖的关系
文件名:Card.h
 */
#import <Foundation/Foundation.h>
@class Person;

@interface Card : NSObject
//@property (nonatomic, retain) Person *person;
@property (nonatomic, assign) Person *person;
@end

/*文件名:Card.m */
#import "Card.h"
#import "Person.h"
@implementation Card

- (void)dealloc
{
    NSLog(@"Car被销毁了");
    // [_person release];有 retain 才有 release,否则不能写
    [super dealloc];
}
@end

/* 文件名:Person.h */
#import <Foundation/Foundation.h>
#import "Card.h"
// @class仅仅是告诉编译器,Card是一个类
//@class Card;
@interface Person : NSObject
@property (nonatomic, retain) Card *card;
@end

/* 文件名:Person.m */
#import "Person.h"
#import "Card.h"

@implementation Person

- (void)dealloc
{
    NSLog(@"Person被销毁了");
    [_card release];
    [super dealloc];
}
@end

//  main.m
#import <Foundation/Foundation.h>
#import "Card.h"
#import "Person.h"

int main()
{
    // p - 1
    Person *p = [[Person alloc] init];
    // c - 1
    Card *c = [[Card alloc] init];

    // c - 2
    p.card = c;

    // p - 1
    c.person = p;

    // c - 1
    [c release];

    // p - 0  c - 0,如果不这样使用( 1> 一端用retain    2> 一端用assign)
    [p release];
    return 0;
}
////如果不这样使用( 1> 一端用retain    2> 一端用assign),会出错
//// p - 1
//Person *p = [[Person alloc] init];
//// c - 1
//Card *c = [[Card alloc] init];
//
//// c - 2
//p.card = c;
//
//// p - 2,因为两个类的 set 方法生成 都是 retain 属性,那么就是这样的代码
//c.person = p;
////    if (_card != card)
////    {//这个步骤要有,旧的(当前的)对象不再被使用,就把它的计数器-1操作,之后再对新的对象使用 1,防止出错。
////        [_card release];
////        _card = [book retain];
////    }
//
//// c - 1
//[c release];
//
//// p - 1  此时不会调用 dealloc 方法,会出现内存泄露问题,而使用了双端循环引用解决方案,那么p=0,则自动调用 person 类的 dealloc方法,c=0,完美结束。
////- (void)dealloc
////{
////    NSLog(@"Person被销毁了");
////    [_card release];
////    
////    [super dealloc];
////}
//[p release];

@class的意义:仅仅告诉编写翻译器,有些名称是贰个类
@class Person; 仅仅告诉编写翻译器,Person是叁个类,不会把类的主意等引进

实际上开辟中援用八个类的科班是:
1> 在.h文件中用@class来评释类,举例,有九十六个类同有的时候间援用了 Card 类,如果card 修改了,那么余下的98个类也要再度引进编写翻译,功能不高,且还是能一挥而就双端引用(循环援引)的面世错误难题。
2> 在.m文件中用#import来含有类的兼具东西

为了抓实编写翻译的频率!头文件不利用#import,独有贰个特例,那正是在再三再四里,父类须要使用#import 引进到子类

两个循环援用消除方案,那是特例,差异对待,在此在此之前说了,对象用 retain,非对象不须求内部存款和储蓄器管理,使用 assign 就行了,但是此间非常
1> 一端用retain
2> 一端用assign 

autorelease方法(半自动释放)

autorelease

  • 给有些对象发送一条autorelease新闻时,就能够将那几个指标加到二个电动释放池中
  • 当自动释放池销毁时,会给池子里面包车型地铁具备目的发送一条release音讯
  • 调用autorelease方法时并不会改造目的的计数器
  • autorelease 方法重回对象自己
  • autorelease实际上只是把对release的调用延迟了,对于每一遍autorelease,系统只是把该目的放入了现阶段的@autoreleasepool中,当该pool被放飞时,该pool中的全体指标会被调用Release

 使用 autorelease 方法幸免了历次使用对象,都要在指标 release 此前使用的坏处,因为这样总是小心翼翼的,怕出现野指针。可是现身了 ARC 之后这个都不需求了。

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        NSLog(@"Hello, World!");
    }
    return 0;
}

ios 5.0后,今后一贯使用这么些了.

ios 5.0前

NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

// .....

[pool release]; // 或[pool drain];

在程序运行进程中,能够创制多个电动释放池,它们是以栈的花样存在内存中,OC对象只须求发送一条autorelease新闻,就能够把那些目标增多到方今的机关释放池中(栈顶的释放池)

/*文件名:Person.h */
#import <Foundation/Foundation.h>

@interface Person : NSObject
@property (nonatomic, assign) int age;
@end

/*文件名:Person.m */
#import "Person.h"

@implementation Person
- (void)dealloc
{
    NSLog(@"Person---dealloc");
    [super dealloc];
}
@end

//  main.m
/*
 1.autorelease的基本用法
 1> 会将对象放到一个自动释放池中
 2> 当自动释放池被销毁时,会对池子里面的所有对象做一次release操作
 3> 会返回对象本身
 4> 调用完autorelease方法后,对象的计数器不变

 2.autorelease的好处
 1> 不用再关心对象释放的时间
 2> 不用再关心什么时候调用release

 3.autorelease的使用注意
 1> 占用内存较大的对象不要随便使用autorelease
 2> 占用内存较小的对象使用autorelease,没有太大影响

 4.错误写法
 1> alloc之后调用了autorelease,又调用release
 @autoreleasepool
 {
    // 1
    Person *p = [[[Person alloc] init] autorelease];

    // 0
    [p release];
 }

 2> 连续调用多次autorelease
 @autoreleasepool
 {
    Person *p = [[[[Person alloc] init] autorelease] autorelease];
 }

 5.自动释放池
 1> 在iOS程序运行过程中,会创建无数个池子。这些池子都是以栈结构存在(先进后出)
 2> 当一个对象调用autorelease方法时,会将这个对象放到栈顶的释放池

 6.自动释放池的创建方式
 1> iOS 5.0前
 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

 [pool release]; // MAC 上是 [pool drain];

 2> iOS 5.0 开始
 @autoreleasepool
 {

 }
 */

#import <Foundation/Foundation.h>
#import "Person.h"

int main()
{
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

    Person *pp = [[[Person alloc] init] autorelease];

    [pool release]; // [pool drain];

    @autoreleasepool
    {
        // 1
        Person *p = [[[Person alloc] init] autorelease];
        // 0
        // [p release];
    }

    return 0;
}


void test()
{
    @autoreleasepool
    {// { 开始代表创建了释放池
        // autorelease方法会返回对象本身
        // 调用完autorelease方法后,对象的计数器不变
        // autorelease会将对象放到一个自动释放池中
        // 当自动释放池被销毁时,会对池子里面的所有对象做一次release操作
        Person *p = [[[Person alloc] init] autorelease];

        p.age = 10;

        @autoreleasepool
        {
            // 1
            Person *p2 = [[[Person alloc] init] autorelease];
            p2.age = 10;

        }

        Person *p3 = [[[Person alloc] init] autorelease];

    } // } 结束代表销毁释放池
}

跟release的对比

以前:

Book *book = [[Book alloc] init];

[book release];

现在:

Book *book = [[[Book alloc] init] autorelease];

// 不要再调用[book release];不过这么显得代码相当长,臃肿,能否创制对象的时候,间接正是放入自动释放池里呢?能够的:

一般可以为类增加一个快捷创制对象的类格局

  (id)book {

    return [[[self alloc] init] autorelease];

}

外面调用[Book book]时,根本毫无思量在如曾几何时候释放再次来到的Book对象,实际支出中常用。

支付中时常会提供一些类格局,连忙创造一个已经autorelease过的对象,创制对象时不用一向用类名,用self,因为这么写,此类的子类都能调用那个主意,自动识别,self 指向调用这一个措施的类,不会出错。

 

相似的话,除了alloc、new或copy之外,其余的不二等秘书籍成立的靶子都被声称了autorelease

譬喻说下边包车型大巴对象都早已是autorelease的,无需再release

NSNumber *n = [NSNumber numberWithInt:100];

NSString *s = [NSString stringWithFormat:@"jack"];

NSString *s2 = @"rose";

小结;

一、计数器的基本操作

1> retain : 1

2> release :-1

3> retainCount : 获得计数器

 

二、set方法的内部存款和储蓄器管理

1> set方法的兑现

- (void)setCar:(Car *)car

{

    if ( _car != car )

    {

        [_car release];

        _car = [car retain];

    }

}

2> dealloc方法的落到实处(不要直接调用dealloc)

- (void)dealloc

{

    [_car release];

    [super dealloc];

}

 

三、@property参数

1> OC对象类型

@property (nonatomic, retain) 类名 *属性名;

@property (nonatomic, retain) Car *car;

@property (nonatomic, retain) id car;

// 被retain过的性情,必须在dealloc方法中release属性

- (void)dealloc

{

    [_car release];

    [super dealloc];

}

 

2> 非OC对象类型(intfloatenumstruct)

@property (nonatomic, assign) 类型名称 属性名;

@property (nonatomic, assign) int age;

 

四、autorelease

1.系统自带的措施中,要是不包蕴alloc、new、copy,那么这么些点子重返的指标都以一度autorelease过的

[NSString stringWithFormat:....];

[NSDate date];

 

2.支出中平日写一些类措施赶快成立叁个autorelease的对象

* 创设对象的时候不要一向动用类名,用self

语法急迅过(6)内部存储器管理原理,objectivec语法 内存管理基本原理(最关键) 移动设备的内部存款和储蓄器非常轻便(iphone 4内部存款和储蓄器512M),各个ap...

版权声明:本文由威尼斯人app发布于电脑操作,转载请注明出处:在Xcode4中编辑代码,Xcode4编写代码