iPhoneGeek 爱疯极客 » 基础

iPhone用Expat XML解析器

bagusflyer — Fri, 23 Jul 2010 10:29:09 +0000

xml的解析运用的十分广泛，我以前也介绍过使用ticpp（tinyxml的c++版本）进行简单的xml解析，见跨平台代码分享之三–xml解析器，它是采用DOM进行解析。iPhone SDK中自带的NSXMLParsers也可进行xml解析，但是对于解析web server下载的大型文件时效率不够高，有一个第三方的objective c expat wrapper 采用expat（SAX方式）进行解析，效率非常高。据有人测试，其效率相对于NSXMLParsers约提高了70-80%。

下面是其下载地址。

调试教程 – 使用UIRecorder Instrument将测试自动化

bagusflyer — Mon, 19 Jul 2010 01:52:31 +0000

（注：这是我以前收集的一篇文章，找不到出处了，稍作修改在此发布）

如果你发现程序的bug，但每次进行测试都需要许多步骤才能重现问题，那么本教程适合你。通常，测试和调试是非常繁琐的事情，iPhone程序的开发尤其如此。

比如说，你有个程序需要经过5个步骤才能到达另一个view。如果你有一个bug发生在这个需要5步之多的view上，通常情况下调试的步骤如下：

运行程序
触击 view 1
触击view 2
触击 view 3
触击 view 4
触击 view 5
(程序崩溃)
修改代码
重复以上步骤

如你所见，这是多么痛苦的事情啊。 Kendall Gelner 在 360iDev 上有关使用Instruments 和 XCode进行调试的若干提示的演讲中，对我而言最为有用的就是将测试自动化。我演示一下应该怎么做:

1. 打开希望测试/调试的程序

2. 在模拟器中运行

3. 打开Instrument – 位于 /Developer/Applications/Instruments

4. 选择 UIRecorder 并按Choose - 你将看到下面窗口

5. 然后需要将此工具与iPhone模拟器进程链接。按下下拉菜单选择 Default Target -> Attach to Process -> iPhone Simulator.

6. 再按下 Drive & Record 并在模拟器中完成测试所需的所有步骤。至此，UI Recorder记录下了你的一举一动。完成时，按下Stop按钮。 注意： 在完成记录后请不要移动模拟器，因为这有可能会使弄乱整个处理过程。

7. 修改你的代码…

8. 按下 Drive & Record 按钮亲眼目睹一下有什么神奇的事情发生吧。测试自动进行了！你应该看到它自动模拟了你刚才进行的所有动作。

真机安装测试iPhone应用程序

bagusflyer — Sat, 10 Apr 2010 03:04:33 +0000

前两天有朋友问我有关怎样在真机上加载和调试iPhone程序的问题，实际上有两个方法：

1. 申请ADC帐号，购买iDP（iPhone Develop Program）

2. 在“越狱”的iPhone上安装程序

本准备写一篇教程，但在网上搜了一下，找到一些链接，为尊重原作者的劳动，这里我仅给出链接（但是否是原始链接，我就不得而知了，因为有许多网站并未表明原始地址。对此，小小地鄙视一下！）

从零开始开发iPhone，教你如何在真机调试iPhone应用程序

简单明了SDK2.2.1无99刀证书真机运行方法图文教程

iPhone不是Mac Pro

bagusflyer — Tue, 09 Feb 2010 05:21:03 +0000

本文是关于通过Objective C++的强大功能提高iPhone程序的性能。通过讨论现实世界中Savoy的Spots应用程序遇到的问题，本文展示了通过3个步骤对程序进行优化使其顺利运行的过程。

使用Objective C++提高iPhone应用程序的性能

我十分喜爱软件开发的一个原因是总是会遇到这样那样的问题，而总能找到相应的解决方法。在开发Spots时，我多次遇到了UI设计的问题。为 iPhone设计一个精简的用户界面是不容易的。比如，我应该提供一个提供者过滤器（指Hotspot）按钮或将其放在Settings.app中？关于这个问题，我至少改变了二十次主意？

本文不是关于用户界面设计而是有关编程与性能。本文并不是针对用户界面而是有关编程和性能。一个最大的难题是地图的绘制（屏幕下方的长方形）。经过几种方法的试用，我发现在绘制230，000个点时，只有使用OpenGL以及大量的旁门左道才能使绘图的性能勉强被接受。根据放大的级别以及可见点点数量，我最后使用了三种不同的技术。由于我需要地图交互动作（拖动和缩放）尽可能地平滑，理想情况下为60HZ，性能是最为重要的问题。

本文中我将分享一些能提高性能的技术。虽然它们都很简单和直接，但因为在Cocoa中很少见，所以我还是花了不少时间。例如，尽管C++和Objective C可以非常高效地混合使用，但我在Cocoa中并没有见到许多C++。当你的目标是高性能时，Objective C++是纯Cocoa的很好的扩展。而在iPhone上，性能是应该首先需要考虑到因素。

难题

对于分布在一个矩形区域包括230，000个热点位置的地图（麦卡托投影的世界地图 the world map in mercator projection），首先必须清楚当前地图矩形区域中有多少个可见点，因为此数值可以决定使用何种绘图技术。指标值必须归一，因此整个地图覆盖了一个{{0.0, 1.0}, {0.0, 1.0}}的矩形区域。通常情况下，程序使用的地图矩形是很小的：通常小于整个地图宽度和高度的百分之二。

但是我怎样有效地在数据库成千上万的点中找到可见点的数量？

我准备了一个XCode项目，它包括了这里讨论的所有代码。此示例项目并未包括了所有点的原始数据库。它仅包含了一些世界地图上的随机数据。虽然与真实情况有所区别，但它们的处理方法与我收集的原始数据的大同小异。

第一种方法: 普通Cocoa方法

第一种方法十分简单而且并没有采用十分高效的方法。使用Object C对象（@class Spot）来表示位置，它们以NSArrary的形式被保存在一个数据库对象中（@class SpotsDB1）。

@interface Spot : NSObject {
    CGPoint _position;
}
@property (nonatomic) CGPoint position;
@end

@interface SpotsDB1 : NSObject {
    NSArray* _spots;
}
- (NSUInteger)countSpotsInRect:(CGRect)rect;
@end

为进行一个指定CGRect内地位置计数，数据库对象简单地循环整个数组并检查各位置。

NSUInteger count = 0;
for (Spot* spot in _spots) {
if (CGRectContainsPoint(aRect, spot.position))
++count;
}

使用上述代码，在总数为230，000个点的区域上的任意一个{0.02, 0.02}矩形内进行计数大概需要250毫秒。太糟糕了，如果你的目标是刷新率60Hz，那么你只有16 ms绘制一帧。使得此方案过慢的原因不仅在于其缺乏聪明的算法，而且在循环中浪费了许多时间在调用了几个函数上。另一个对性能产生负面影响的因素是位置被保存在NSArray中的对象，这是由于对象占用了大量的内存以及数组指针的非直接性导致了处理器时间的增加。

第二种方法: 简单优化

为使同样的方案运行得更快，我们只需简单地将位置存储与一个更为紧凑的数据结构中：一个CGPoint结构的标准C数组。为使用方便，我们将C数组保存在一个NSMutableData 对象中。

_spotCount = [spots count];
_spotsData = [[NSMutableData alloc] init];
for (Spot* spot in spots) {
CGPoint p = spot.position;
[data appendBytes:&p length:sizeof(CGPoint)];
}

消除了循环内函数调用的负面影响，我们使得性能有四倍的提升：

CGFloat xMin = CGRectGetMinX(aRect);
CGFloat yMin = CGRectGetMinY(aRect);
CGFloat xMax = CGRectGetMaxX(aRect);
CGFloat yMax = CGRectGetMaxY(aRect);

CGPoint* begin = (CGPoint*)[_spotsData bytes];
CGPoint* end = begin + _spotCount;

NSUInteger count = 0;
for (CGPoint* i = begin; i != end; ++i) {
if (i->x > xMin && i->y > yMin && i->x < xMax && i->y < yMax)
++count;
}

在没有改变基本算法的基础上，点计数的计算现在只需55毫秒，这大概比原来方法快了四倍。另一个好处是现在使用的内存是原来版本的一半。

第三种方法：算法优化

当然，还有许多聪明的方法来优化平面地图点的查询。例如，你可以使用四边形树来保存这些点。在本例中我使用了一种比较简单的解决方案，所以没有涉及数据存储的方式。我使用了C++的内置功能所以甚至不需要写任何代码来处理数据的存储。

我的设想是将数组中的位置从左至右分类。这样做的好处是确定指定正方形的左右边界十分快速（见下图）。当数组中边界已知时，仅需要检查边界间的点。

所以此算法是有关快速寻找边界的。我们使用的是二进制搜索，它适用于已排序的数组。它并不检查每个值以找到匹配的位置，而是直接跳到数组的中点，检查其值是小于还是大于给点值，然后跳到剩余部分的中心点，重复以上步骤。使用这种方法，二进制搜索需要 log2(n)的时间来查找最佳元素。对于一个拥有230，000个位置的数组，只需22次搜索！回到代码，我们发现上述算法的实现是很简单的。当然，我们必须为数据库排序：

// comparison function for array sorting
NSInteger leftToRight(Spot* a, Spot* b, void* context) {
    CGFloat xa = a.position.x;
    CGFloat xb = b.position.x;
    if (xa < xb)
        return NSOrderedAscending;
    return xa > xb ? NSOrderedDescending : NSOrderedSame;
}

...

spots = [spots sortedArrayUsingFunction:leftToRight context:NULL];

现在是有趣的部分：使用C++进行二进制搜索。我们使用了#include 中的库函数 std::lower_bound。它需要一个起点，终点，要查找的值以及比较函数。它返回比较为false的第一个值。起点和终点可以是简单的指向数组的C指针。

#include
…

bool cmpX(const CGPoint& a, const CGPoint& b) {
return a.x < b.x;
}
…

CGFloat yMin = CGRectGetMinY(aRect);
CGFloat yMax = CGRectGetMaxY(aRect);

CGPoint* begin = (CGPoint*)[_spotsData bytes];
CGPoint* end = begin + _spotCount;

CGPoint leftMargin = aRect.origin;
CGPoint rightMargin;
rightMargin.x = CGRectGetMaxX(aRect);

CGPoint* left = std::lower_bound(begin, end, leftMargin, cmpX);
CGPoint* right = std::lower_bound(left, end, rightMargin, cmpX);

NSUInteger count = 0;
for (CGPoint* i = left; i != right; ++i) {
if (i->y > yMin && i->y < yMax)
++count;
}

注意第二个二进制搜索，它仅从左边界而不是整个数组查找右边界。另一个优化是从循环中移除X-轴的检查，这是因为已经通过指定边界完成了这部分工作。

通过这些优化，只需要1毫秒来对长方形进行计数。这是第一个版本的200倍。

结果

下面是运行在三种不同设备上的示例项目的输出。如果你需要运行在你自己的设备上，你只需将目标设定中将代码签名标识符改为自己的。如果你不希望用在通用标识符的程序上，你还需要更改Info.plist中的包标识符（Bundle Identifier）。

iPhone 3G：

SpotsDB1 needed 3.2 seconds to count spots in 13 rects
that's 244.423 ms per rect
SpotsDB2 needed 3.0 seconds to count spots in 55 rects
that's 55.230 ms per rect
SpotsDB3 needed 3.0 seconds to count spots in 2988 rects
that's 1.004 ms per rect

第二代iPod Touch：

SpotsDB1 needed 3.1 seconds to count spots in 16 rects
that's 194.756 ms per rect
SpotsDB2 needed 3.0 seconds to count spots in 65 rects
that's 46.450 ms per rect
SpotsDB3 needed 3.0 seconds to count spots in 3399 rects
that's 0.883 ms per rect

运行在Mac Pro之上的模拟器：

SpotsDB1 needed 3.0 seconds to count spots in 687 rects
that's 4.372 ms per rect
SpotsDB2 needed 3.0 seconds to count spots in 2687 rects
that's 1.117 ms per rect
SpotsDB3 needed 3.0 seconds to count spots in 187276 rects
that's 0.016 ms per rect

结论

观察结果我们可以看出在桌面电脑和iPhone上性能有显著的区别。有一个金科玉律是：在Mac上只需一秒的操作在iPhone上要一分钟。或者有一个更悲观的说法：Mac上60Hz的刷新率在iPhone上每秒钟只能更新一次。

所以显而易见在iPhone上进行优化是完全必须的。本文中我展示了几种方法来减小Object C的开销以及怎样使用C++来获得最大的性能。当然找到性能的瓶颈并转而使用数据结构使代码性能提升并不总是很容易的事情。但是在设计一个使用大量数据的程序时，绝对有必要考虑使用非Cocoa的方法。

原文见：My iPhone is not a Mac Pro

iPhone程序的文档目录

bagusflyer — Thu, 04 Feb 2010 06:09:12 +0000

最近实在太忙，手头上的事情还没有完成，因此正在进行的几篇有关OpenGL ES的文章只能推后了。

今天介绍一下怎样获得iPhone程序的文档目录（通常用来存储用户数据），方法一：

1 2	NSString* documentsDirectory = [NSHomeDirectory() stringByAppendingPathComponent:@"Documents"];

方法二：

1 2	NSArray paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES); NSString documentsDirectory = [paths objectAtIndex:0];

跨平台代码分享之七 – 一个简单的音效引擎

bagusflyer — Wed, 06 Jan 2010 06:18:19 +0000

游戏都需要一个声音引擎，一般来说，有三种类型：

播放音效。音效一般是比较简短的声音文件。
播放背景音乐。
乐器，音效模拟。

本文介绍一个简单跨平台的音效引擎，主要针对第一种类型。实际上，也可以适用于第二种类型，但由于背景音乐文件较大，占用内存较大，所以本文介绍的方法并不是最为有效率的（特别是对于像iPhone之类内存较为紧张的平台，但仍然可用）。可以在本引擎的基础上加以改进，比如采用“流”（streaming）技术。而第三种类型，可能涉及到DSP（数字处理技术），比较复杂，另外在不同平台有一些不同的技术，如Windows下的VST/VSTi，Mac OSX下的AU等，不在本文的讨论范围。

本文介绍的音效引擎是基于OpenAL的，并且是我在许多项目中使用的引擎的简化部分（去除错误处理及乐器模拟部分）。

有关OpenAL的使用，网上有许多教程，比如：OpenAL编程教程等。iPhone上的OpenAL使用，本网站也有几篇文章。所以这里不再赘述。

本引擎的目的，是简化声音播放接口。最简单的情况下可以仅仅使用两条语句，就播放一段音效。而繁复的OpenAL初始化功能等都由引擎自动完成。下例展示了怎样播放一段音效的最为典型的调用：

1
2
3

audio::CSound sound("sound.wav");

sound.play();

本引擎由三个类和一个公共函数构成。audio::CEngine是引擎的核心部分，它是一个单例类（Singleton)，负责直接与OpenAL接口，用户无需与其打交道。audio::CBuffer类对应于OpenAL中的缓存，通过audio::openAudioData函数打开音效文件，创建内部缓存，用户也无需直接使用。audio::CSound是用户直接使用的类，它提供了诸如play（），stop（），setVolume（）和setPosition（）几个接口函数。如需扩展功能，添加一些其他功能，可以直接加在此类中，并在audio::CEngine中实现。

以上三个类可以直接使用在不同平台中。与平台相关的代码，都在audio::openAudioData()中。它的作用是打开不同的声音文件。对于Windows，我使用了一个开源项目库libsndfile，用来打开诸如wav，caf，aiff，flac，ogg等常用音效文件（注意：mp3并未包括其中。由于使用mp3的软件需要支付一定许可证费用，本人也不喜欢使用）。而对于Mac OSX（iPhone），则使用了core audio。这里大家可能会有一个疑问，既然libsndfile也是跨平台的，为什么在iPhone上不使用它呢？确实，libsndfile支持Windows，Linux，Mac OSX，Sun Solaris等平台，而iPhone并不支持ogg等格式，使用libsndfile不正好填补这个空白？是的，我也是这样想的，但是，有两点原因初始我暂时没有使用它：

没有现成的iPhone库。由于libsndfile需要使用makefile由GCC编译（我曾试过使用Xcode编译，没有成功），我也不是这方面的专家。但是，libsndfile在Mac OSX下编译没有问题，所以只需稍作修改，在为iPhone进行编译也不是没有可能的事情。
由于其许可证的限制。libsndfile是基于LGPL的，它要求使用者采用动态连接库，而众所周知，iPhone（官方）是不支持动态链接的。如果使用静态链接，则需要随软件发布源代码或目标代码。其实，这也不是无法克服的，LGPL只要求发布与libsnd相关的目标代码，所以对你的软件并无影响。对吗？

本文给出了Windows下和iPhone下的应用。在Windows下使用需要下载OpenAL SDK和libsndfile。为方便编译好的libsndfile随示例程序给出给出。（你需要修改一下VS 项目文件中的有关OpenAL的头文件和库文件路径，另外，在OpenAL include目录中创建一个OpenAL目录，并将.h复制到其下，这样我就不需要修改#include语句了。）

示例程序audiolib下载。（项目在test目录下）

Poco C++ for iPhone之一 – 编译

bagusflyer — Tue, 29 Dec 2009 02:39:58 +0000

Poco C++是一个强大的跨平台C++库，你可以在iPhone程序中使用它，如果：

你打算使你的程序跨平台。
你喜欢使用C++或希望使用Poco C++中的功能如：XML，Zip等。

目前，最新Poco C++版本为1.3.6P1，根据文档，它可以编译为iPhone静态库。但是我试用了一下，无法使用在iPhone Xcode项目中链接，不知何故。所以我自己创建了下列Xcode项目：

Poco Foundation
Poco Util
Poco Net
Poco XML
Poco Zip

另外，由于Crypto，Data，NetSSL_OpenSSL库需要外部库而且目前我不需要使用，所以没有包括。另外我增加了一个目录iPhoneSamples，它目前包括了一个示例程序HelloPoco，演示了怎样在iPhone项目中使用Poco C++库（此演示程序十分简单，它调用Poco中的UUID功能，产生一个UUID，显示与屏幕上）。下面是包括了此展示程序以及各Xcode文件的Poco包的下载：

poco-1.3.6p1

跨平台代码分享之六 – 使用minizip进行解压

bagusflyer — Wed, 23 Dec 2009 10:56:03 +0000

压缩和解压技术应用很广泛，比如游戏程序中的资源管理器可以使用压缩技术将许多文件打包，便于管理，也节约了空间。本文介绍使用minizip进行解压。由于可以使用zip工具比如winzip，betterzip等进行压缩，所以本文并未涉及压缩。

minizip++

我编写了一个简单的类，与minizip和zlib一起（实际上，Mac OSX中包括了zlib库，但其他平台不一定有zlib库，所以我将其包括在源码中），构成了minizip++。此类仅包含一个类zip::CReader，此类只包括一个函数openFile用于从zip文件中读取一个文件。

范例概述

本示例程序很简单，它从data.zip文件中提取data/hello.txt显示于屏幕上，有兴趣的话，你可以扩展此程序，从zip中提取图像然后显示出来。

废话少说，下面介绍程序：

1. 先建立一个View based Xcode项目ziptest，再创建一个目录data，在此目录下建立一个文本文件hello.txt，编辑此文本文件，加入你想在屏幕上显示的内容，比如，我在hello.txt中加入“Hello World！”。压缩data目录，然后将压缩文件data.zip加入Xcode的resource。（注意：此时加入的zip文件将出现在Targets下的“Link Binary With Libraries”下，编译时会出现一个警告，zip文件将不会被加入到.app中。所以你应该将data.zip移动到”Copy Bundle Resources”下）
2. ziptestViewController.h部分如下：
1
2
3
4
5
@interface ziptestViewController : UIViewController {
UILabel* _mytext;
}

@property (nonatomic,retain) IBOutlet UILabel* _mytext;
3. 将ziptestViewController.m重命名为ziptestViewController.mm，部分代码如下：
4. 双击ziptestViewController.xib打开Interface Builder。添加一个Label。Control+点击File Owner拖动到新建的Label，选取_mytext。
5.然后加入header和library搜索路径。比如，我的Header Search Paths为：../../external/minizip++。然后按iphone项目使用静态库的最佳方法一文中介绍的方法加入ziptest项目。
6.在viewDidLoad下进入下列代码：

1
2
3
4
5

std::stringstream in;
zip::CReader reader;
NSString* zippath=[[[NSBundle mainBundle]resourcePath]stringByAppendingPathComponent:@"data.zip"];
reader.openFile([ziptestViewController getString:zippath],"data/hello.txt",in);
_mytext.text = [NSString stringWithCString:in.str().c_str()];

6. 按Build and Go运行程序。

minizip++中CReader类中用于解压的代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

namespace zip
{

void CReader::openFile(const std::string& zip,const std::string& file,std::iostream& in)
{
unzFile uf=NULL;

// open zip file
#ifdef USEWIN32IOAPI
zlib_filefunc_def ffunc;
fill_win32_filefunc(&ffunc);
uf = unzOpen2(zip.c_str(),&ffunc);
#else
uf = unzOpen(zip.c_str());
#endif
if (uf==NULL)
{
printf("No zip file found!\n");
return;
}

// find the file inside zip
if ( unzLocateFile(uf,file.c_str(),0) != UNZ_OK )
{
printf("%s not found in zip\n",file.c_str());
return;
}

// file founded,extract it into the stream
// open it
if ( unzOpenCurrentFile(uf) != UNZ_OK )
{
// TODO: error handling
printf("unzOpenCurrentFile error\n");
return;
}

// get the file info
char filename_inzip[256];
int err=UNZ_OK;

unz_file_info file_info;
err = unzGetCurrentFileInfo(uf,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0);

if (err!=UNZ_OK)
{
// TODO: error handling
printf("error %d with zipfile in unzGetCurrentFileInfo\n",err);
return;
}

// read the file into stream
char* buf = (char*)malloc(file_info.uncompressed_size);
if ( unzReadCurrentFile(uf,buf,file_info.uncompressed_size) < 0 )
{
// TODO: error handling
printf("error in unzReadCurrentFile!\n");
free(buf);
return;
}

// write to istream
in.rdbuf()->sputn(buf,file_info.uncompressed_size);
free(buf);

unzCloseCurrentFile(uf);

unzClose(uf);
}
}

源码下载

ziptest

注意：编译时，你需要修改头文件路径或者按照我的路径解压源代码。我的路径如下：

root
|—— external
|———– minizip++

|—— test
|———– ziptest

minizip++

开始学习iPhone编程之五 – Objective C / Cocoa / iPhone的内存管理

bagusflyer — Wed, 23 Dec 2009 05:11:27 +0000

随着iPhone SDK的发布，iPhone/iPod Touch被售出数以百万计（作者注：这是一篇以前的文章，现在iPhone/iPod Touch的销售数量远大于此数）而且App Store广受欢迎，越来越多的开发者开始进行iPhone及Cocoa Touch的开发。SDK设计精良而且很容易入门，最大的障碍来自于Apple选择作为OSX和iPhone开发的独特语言（其前身为NextStep）：Object C。初看时，Object C非常丑陋而且与人们常用的基于C的语法（C, C++, ActionScript, JavaScript, Java, C#, GLSL等）并不相似。但一旦对其有所研究后，你会喜欢上它并明白其语法为何如此。

大部分人初次接触Objective C/Cocoa开发时的最大困难是内存管理 – 当你最终理解了它是多么简单（尽管这可能需要通过几个项目）时，你就会明白这一切实际上是多么漂亮。实际上，我发现其非常实用，所以编写了一个C++类来实现类似功能(http://code.google.com/p/ofxmsaof/wiki/ofxObjCPointer).

C/C++的方式

对于传统C/C++开发，确定使用过后的对象清理的职责多多少少有那么些噩梦的意味。C/C++语言本身并未提供怎样进行此项工作方法，一切都取决于程序员本身个人的习惯和约定。

想象一下程序员A编写了一段代码(类A)，此段代码创建叫做Data的对象并为其分配内存然后将此对象传递给程序员B，B将在他的代码（类B)中使用此对象。两个程序员使用同一个对象Data。到底是谁应该在不再使用对象Data后对其进行删除？

如果类A只是创建和初始化Data并不再使用它，那么类B可以在使用完Data后安全地删除它。但是，怎样才能保证类A不再使用Data？如果在类B使用Data时类A仍然需要使用它，我们怎样才能知道何时删除它？如果类A在使用完Data后进行删除，类B有可能还需要使用，这会导致程序崩溃。如果类B在使用完后进行删除，同样如果类A还在使用将会引起崩溃。当然，如果类C也需要更新同一Data，那么情况会更复杂。

有一些约定和模式可以处理这些情况，比如有下列形式的通讯：”等下，不要删除对象，我正在使用” 或者 “好，我使用完毕，你可以任意处置“。这实际上正好是开发引用计数的原因，这种技术是Objective C使用的主要内存管理技术。

Objective C的方式

Objective C 使用’引用计数’作为其主要内存管理技术(wikipedia.org/wiki/Reference_counting)。每个对象都保存一份记录了它被“需要”的次数的内部计数器。系统保证当对象被需要时不会被删除，当不被需要时才被删除。这听上去有点象自动垃圾收集(即Java, AS3 wikipedia.org/wiki/Garbage_collection_(computer_science)的工作方式)，但实际上并不是如此。它与自动GC (Java, AS3 等)的主要区别在于，GC是一段单独的代码在后台定期运行检查是否对象被引用以及哪个对象不再被需要。然后所有未被使用的对象将被自动删除，程序员不需做任何特殊处理。而引用计数方法，程序员有责任通知他需要使用或完成使用某个对象，当对象不再被使用时，即引用计数为0时，它将立即被删除。（有关更多详情请参考以上wikipedia链接）。

注意： Objective C 2.0 同样具有一个选项允许自动垃圾收集。但是，开发iPhone程序不能使用此选项，所以了解引用计数，对象所有权等仍然十分重要。

对象拥有者

理解对象拥有者的概念十分重要。在Objective C中，一个对象的所有者是宣称“我需要此对象，不要删除它”的某人（或某段代码）。它可能是创建此对象的人（或代码）（比如上例中的类A）。或者它可能是接收并需要此对象的另一个人（或代码）（即上例中的类B）。一个对象可以具有不只一个所有者。 一个对象的所有者的数量就是引用计数。

对象所有者有责任在使用完毕后通知对象。这样做后，他们将不再是对象的所有者，或者说对象的引用计数减一。当一个对象没有所有者时（即没人再需要时或引用计数为0），它将被删除。

不作为对象的拥有者（临时使用）你仍然可以使用对象，但是要记住此对象可能已经（或者将）被删除。所以如果你希望长期使用一个对象，你应该成为对象的拥有者。如果你只打算临时使用对象（例如，在你的函数中，或者事件循环中 – 后面会介绍autorelease pool），那么你不需要成为拥有者。

消息

你可以传递给一个对象的主要消息（有关内存管理）是：

alloc (即 [NSString alloc]): 此消息为对象分配了一个例程（本例中为NSString）。它同时将引用计数设为1。你是此对象的唯一拥有者。当使用完毕时，你必须释放此对象。（题外话：记住对新分配的对象调用init函数： [[NSString alloc] init] 或 [[NSString alloc] initWithFormat:] 。)

new (例如： [NSString new]): 这是[[NSString alloc] init]的简写。

retain (例如：[aString retain]): 当你传递一个存在的对象（内存已经分配）而且你需要保持它时你需要调用此函数。这就好像在说：“我需要此对象，不要在我完成前删除它”。引用计数将加1，你成为了此对象的拥有者（与以前拥有它的拥有者一起）。完成时，你必须释放它。

release （例如 [aString release]）: 在你完成对象的使用后调用。你将不再拥有此对象，因此引用计数将减1。如果此时引用计数为0（即没有拥有者），那么对象将被自动删除，内存被释放，否则因为其他拥有者还在使用，对象将继续保存在内存中。这就好像在说“好了，我已经使用完此对象，如果没有人使用它，你可以删除它了”。如果你不是此对象的拥有者，你不应该调用此函数。如果你是对象的拥有者，在你完成后，你必须调用它。

autorelease (例如： [aString autorelease])。它表示你只是暂时需要对象，并不会使你成为对象的拥有者。这好像在说“Ok，我现在需要对象，在我完成几件事前保留在内存中，然后你可以删除它。”。更多介绍请参见稍后的’autorelease pools’部分。

所以当你在与Objective C指针/对象打交道时，重要的是要记住发送正确的消息。基本规则是：如果你拥有一个对象(分配（alloc）或保持（retain）它)，那么你必须释放（release）它。如果你不拥有它 (通过便捷方式产生或别人分配），那么你就不要释放它。

便捷方法

Cocoa下的许多类都具有所谓便捷方法。它们是用于直接分配和初始化对象的静态方法。你并不会成为返回对象的拥有者，它们将在autorelease pool （自动释放池）弹出时（通常在事件循环的结束处，但与你的程序相关）自动被删除。

例如，显性地分配和初始化一个NSNumber的方法是：

1	NSNumber *aNumber = [[NSNumber alloc] initWithFloat:5;

此方法创建一个NSNumber的新例程并通过’initWithFloat’方法使用参数5.0f进行初始化。

aNumber的引用计数为1。你是aNumber的拥有者，所以你必须在使用完毕后释放它。

使用便捷方法：

1	NSNumber *aNumber = [NSNumber numberWithFloat:5.0f];

此方法同样创建一个NSNumber的新例程，通过’numberWithFloat’方法使用参数5.0f进行初始化。

它同样具有引用计数1。但是你不是aNumber的拥有者所以不应该释放它。拥有者是NSNumber类，对象在当前作用域结束时被删除 – 由autorelease pool定义，详情稍后介绍 – 你不应该release（释放） 对象，但要记住对象将存在一段较长的时间。

便捷方法通常具有与相应init函数一样的名字，但将init 替换为对象类型的名字了，比如对于NSNumber: initWithFloat -> numberWithFloat， initWithInt -> numberWithInt。

一个NSString的例子：

1
2
3

NSString *aString1 = [[NSString alloc] initWithFormat:@"Results are %i and %i", int1, int2]; // explicit allocation, you are the owner, you must release when you are done

NSString *aString2 = [NSString stringWithFormat:@"Results are %i and %i", int1, int2]; // convenience method, you are not the owner, the object will be deleted when the autorelease pool is popped

自动释放池

自动释放池是NSAutoreleasePool的一个例程，它定义了临时对象（将被自动释放的对象）的作用域。任何将被自动释放的对象（例如：你对其发送了autorelease消息的对象或者使用便捷方法创建的对象）都会被加入当前autorelease pool（自动释放池）中。当autorelease pool被弹出（释放）时，所有加入其中的对象也将被自动释放。这是管理临时对象自动释放的一种简单方法。

例如，你希望创建几个对象用于临时计算，所以并不需要保持所有定义的局部变量以致在函数结束时需要为它们调用release，你可以在创建时使用autorelease (或便捷方法)，它们将在下一次自动释放池弹出时自动被释放。注意：这样的做法有一个缺点，我将在便捷和显性方式的比较部分中讨论。

Autorelease pool可以嵌套，这种情况下自动释放对象将被加入最近创建的autorelease pool中（释放池以后进先出堆栈的方式堆放）。

示例在自动释放，便捷与显性方式比较一节中。

数组，字典等

数组，字典等通常保存加入其中的任何对象。（当使用第三方集合型对象时，请检查其文档看是否对象被保存）。这意味着这些集合是对象的拥有者，你在添加对象前不需要保持。

示例

下列代码将产生内存泄漏：

1
2
3
4
5

-(void)addNumberToArray:(float)aFloat
{
NSNumber *aNumber = [[NSNumber alloc] initWithFloat:aFloat]; // reference count is now 1, you are the owner
[anArray addObject: aNumber]; // reference count is now 2, the array is also an owner as well as you.
}

如果你在数组之外的其他地方不需要用到对象，那么你必须在添加对象后进行释放。下面的代码是正确的：

1
2
3
4
5

-(void) addNumberToArray:(float)aFloat {
NSNumber *aNumber = [[NSNumber alloc] initWithFloat:aFloat]; // reference count is now 1, you are the owner
[anArray addObject: aNumber]; // reference count is now 2, the array is also an owner as well as you.
[aNumber release]; // reference count is now 1, you are not the owner anymore
}

现在，当数组被释放时，或者从数组中移除对象时，引用计数将减一，因为数组不再是对象的拥有者，所以对象将被删除。

当然，另一种方法也是安全的：

1
2
3
4

-(void) addNumberToArray:(float)aFloat {
NSNumber *aNumber = [NSNumber numberWithFloat:aFloat]; // reference count is now 1, NSNumber is the owner, you are not
[anArray addObject: aNumber]; // reference count is now 2, the array is also an owner as well as NSNumber.
}

现在当autorelease pool弹出时，NSNumber失去其所有权，引用计数降为一（只有数组是对象的拥有者了）。当数组被释放时，或者当对象被从数组中移除时，引用计数降为0，对象将被删除。

你可能会想哪个才是最好的方法？方法一（显性地使用alloc和release)，或者方法二？(便捷方法)。在OSX中，我通常喜欢方法二，因为它看上去更简单而且需要更少的代码。功能上看上去是一样的，但实际上是不同的。实际上使用方法一是更好的方法（特别是为iPhone开发时），或者当你拥有自己的autorelease pool时，方法二更好。下面有详细说明。

自动释放，便捷方式与显性方式比较

你可能想知道到底下面两种方法有什么不同，或者说各有什么好处：

显性方式：

1
2
3
4
5
6

-(void) doStuff:(float)aFloat {
NSNumber *aNumber = [[NSNumber alloc] initWithFloat:aFloat]; // refcount is 1, you are owner
/// ... do a bunch of stuff with aNumber...
...
[aNumber release]; // release aNumber
}

自动释放方式：

1
2
3
4
5

-(void) doStuff:(float)aFloat {
NSNumber *aNumber = [NSNumber numberWithFloat:aFloat];// refcount is 1, you are not ownder, will be automatically release
/// ... do a bunch of stuff with aNumber...
...
}

使用显性方式，aNumber在doStuf结束处立即被清除，内存被释放。

而自动释放方式时，aNumber将在autorelease pool弹出时被释放，通常发生在事件循环的结束处。所以如果你在事件循环中创建了许多自动释放对象，它们都将被加入池中，可能会用完内存。在上例中可能还不是很清楚，我再给出一个例子：

显性方式：

1
2
3
4
5
6
7
8

-(void) doStuff:(float)aFloat {
for(int i=0; i<100; i++) {
NSNumber *aNumber = [[NSNumber alloc] initWithFloat:aFloat]; // refcount is 1, you are owner
/// ... do a bunch of stuff with aNumber...
...
[aNumber release]; // release aNumber
}
}

自动释放方式：

1
2
3
4
5
6
7

-(void) doStuff:(float)aFloat {
for(int i=0; i<100; i++) {
NSNumber *aNumber = [NSNumber numberWithFloat:aFloat];// refcount is 1, you are not owner, will be automatically released
/// ... do a bunch of stuff with aNumber...
...
}
}

现在你可以看到，在第一个例子中，内存中不会超过一个NSNumber（NSNumber在开始处被分配，并在循环结束时被清除）。而在第二个例子中，每个循环都会创建一个新的NSNumber，而旧NSNumber仍处于内存中等待autorelease pool被释放。在桌面系统中，由于拥有内存大，你可以有更奢侈的选择，但在一个像iPhone这类内存有限的平台，更为重要的是保证对象在不在被需要时尽快删除。

当然，另一个选择是创建你自己的autorelease pool，这在你使用了大量临时对象而你又不想麻烦分别释放它们时特别有用。看下下面代码：

显性方式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

-(void) doStuff {
for(int i=0; i<100; i++) {
NSNumber *aNumber1 = [[NSNumber alloc] initWithFloat:1]; // refcount is 1, you are owner
NSNumber *aNumber2 = [[NSNumber alloc] initWithFloat:2]; // refcount is 1, you are owner
NSNumber *aNumber3 = [[NSNumber alloc] initWithFloat:3]; // refcount is 1, you are owner
NSNumber *aNumber4 = [[NSNumber alloc] initWithFloat:4]; // refcount is 1, you are owner
NSNumber *aNumber5 = [[NSNumber alloc] initWithFloat:5]; // refcount is 1, you are owner
NSNumber *aNumber6 = [[NSNumber alloc] initWithFloat:6]; // refcount is 1, you are owner

// ... do a bunch of stuff with all objects above.
...

// release all objects
[aNumber1 release];
[aNumber2 release];
[aNumber3 release];
[aNumber4 release];
[aNumber5 release];
[aNumber6 release];
}
}

自动释放方式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

-(void) doStuff {
for(int i=0; i<100; i++) {
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; // create your own little autorelease pool

// these objects get added to the autorelease pool you created above
NSNumber *aNumber1 = [NSNumber numberWithFloat:1]; // refcount is 1, you are not owner, will be automatically released
NSNumber *aNumber2 = [NSNumber numberWithFloat:2]; // refcount is 1, you are not owner, will be automatically released
NSNumber *aNumber3 = [NSNumber numberWithFloat:3]; // refcount is 1, you are not owner, will be automatically released
NSNumber *aNumber4 = [NSNumber numberWithFloat:4]; // refcount is 1, you are not owner, will be automatically released
NSNumber *aNumber5 = [NSNumber numberWithFloat:5]; // refcount is 1, you are not owner, will be automatically released
NSNumber *aNumber6 = [NSNumber numberWithFloat:6]; // refcount is 1, you are not owner, will be automatically released

// ... do a bunch of stuff with all objects above.
...

[pool release]; // all objects added to this pool (the ones above) are released
}
}

在这种情况下，两段代码实际上是一样的。在第一个例子中，6个NSNumber在循环开始处被创建，在循环结束时被显性释放（你拥有这些对象）。内存中不会超过6个NSNumber.

在第二个例子中，你不会拥有任何NSNumber，但通过创建你自己的autorelease pool，你可以控制它们的生存期。因为你在循环中创建及释放autorelease pool，NSNumber仅存在于循环内，所以内存中也不会超过6个NSNumber。如果你不创建autorelease pool，那么在循环结束时，你会有6个NSNumber等待删除，在函数结束时将会有6×100=600个NSNumber存在于内存中。与在其他函数中创建的自动释放对象一起，你可能会拥有大量未用的对象等待释放（所以不会引起内存泄漏），但是如果你没有及时释放，可能会到达内存上限。

总结

拥有一个对象表示你显性地宣称你需要它（通过使用alloc，new或者 retain)。

如果你拥有一个对象，你必须显性地宣称你已经使用完毕（通过使用release)。

如果你不是对象的拥有者（即你使用autorelease，或通过便捷方法，或它通过函数参数或返回值传递），那么不要释放对象。

只有在你长期需要一个对象时，才保存（retain）它。如果你只在一个函数中需要它，你可以安全地不用拥有它。

数组，字典等拥有加入其中对象的拥有者（调用retain），所以你在添加时不要显性保存。如果你在添加对象到集合前就拥有对象并且在集合之外不需要它，那么你必须在添加它到集合之后释放它。

如果你需要使用大量临时对象（自动释放/使用便捷方法），为避免临时内存过大，应考虑使用临时autorelease pool。在iPhone中如果到达内存上限，程序将退出 – 尽管占用的内存不再需要时将会在autorelease pool中等待释放，但你仍然要有效地定期分配和释放内存。

更详细的信息，请参考官方内存管理文档。
developer.apple.com/documentation/Cocoa/Conceptual/MemoryMgmt/MemoryMgmt.html

原文见：Memory Management with Objective C / Cocoa / iPhone

iPhone项目使用静态库的最佳方法

bagusflyer — Tue, 22 Dec 2009 05:20:40 +0000

由于Apple禁止在iPhone中使用外部框架或动态链接库，所以要重用代码（第三方库或自己的代码）只能选择如下方法：

直接将代码加入项目。这种方法有点笨。例如，你的一段代码被五个项目共享，如果你发现一个小bug，那么你需要更改五个地方。够麻烦吧？
使用静态库。这是我经常使用的方法。但Xcode并未为iPhone提供静态库的模板。有两种解决方法：

如果你的项目主要是使用Objective-C（C/C++也可使用，只要做些简单修改），那么你可使用现成的Xcode模板。
通过Mac OS X栏下的Static Library中的BSD Static Library建立一个静态库。但要用于iPhone项目，还需做些修改（需要将项目的Base SDK改为iPhone）。

但怎样在项目中链接静态库呢？如果你熟悉Xcode，那么你可跳过此段。很简单：

指定静态库的头文件路径Head Search Paths。

添加静态库到Xcode项目中。

就这么简单。但是且慢，万事大吉了吗？如果你要修改你的静态库呢？你需要从Find中找到你的静态库项目，打开它修改。有点麻烦，不能像Visual Studio一样将相关项目包括在应用项目中吗？答案是：可以，虽然还是没有Visual Studio中的工作空间好用。但你可以从Xcode中直接打开相关的静态库。方法是使用Xcode的Cross-Project Reference(跨项目参考)。

将静态库的Xcode项目加入到当前项目。

右击Targets下本项目，添加到静态库项目的关联。

在项目下，扩展静态库项目，拖动xxxx.a到Targets下的Link Binary With Libraries。

这样你就可以从当前项目下，双击静态库的项目来打开和修改静态库的代码了。