精通Objective-C：Mac与iOS平台编程指南(第2版)

5星 · 超过95%的资源需积分: 9 12 浏览量更新于2024-07-26 9 收藏 16.45MB PDF 举报

“Learn.Objective-C.on.the.Mac.2nd.Edition”是一本关于Objective-C编程的书籍，针对OS X和iOS平台。本书是第二版，适用于那些希望通过学习Objective-C来开发iPhone、iPad（使用iOS）和Mac（使用OS X）应用的读者，无论他们是否具有C语言基础。书中涵盖了Objective-C的基础知识，使用了Apple最新的Xcode工具，并介绍了对象导向编程、新特性如Blocks、Grand Central Dispatch（GCD）、自动引用计数（ARC）以及类扩展等。此外，还包括构建用户界面、内存管理、类别、协议等内容。在本书中，读者将学到： 1. 掌握Objective-C编程，这是开发iOS和Mac应用的基础。 2. 学习如何为iOS和/或OS X界面编写应用程序，这两个平台以简洁的用户界面著称。 3. 理解变量和设计自定义数据结构的方法。 4. 使用新特性，如Blocks、ARC和类扩展。 5. 了解Clang静态分析器和GCD等新工具。 6. 学习构建简单的用户界面，使用UIKit。 7. 探索最新的Xcode功能。本书适合对iOS和/或OS X原生应用开发感兴趣，尤其是新接触Objective-C但有一定编程经验的开发者。书中的章节包括： 1. 介绍 2. C语言的扩展 3. 对象导向编程入门 4. 继承 5. 组合 6. 源文件组织和使用Xcode 4 7. 更多关于Xcode的内容 8. 基础工具包快速入门 9. 内存管理和ARC 10. 对象初始化 11. 属性 12. 类别 13. 协议 14. 块和并发 15. UIKit简介 16. 应用程序工具包简介 17. 文件加载和保存 18. 键值编码 19. 使用静态分析器 20. NSPredicate 附录：来自其他语言的转换本书作者包括有经验的Mac黑客和畅销书作家Scott Knaster，资深Mac开发者Mark Dalrymple，以及UNIX爱好者和Mac专家Waqar Malik。他们共同提供了丰富的Objective-C和Cocoa编程知识。通过本书，开发者可以深入理解Objective-C语言，掌握开发iOS和OS X应用所需的关键技术。

Chapter 2: Extensions to C12

Deconstructing Hello Objective-C

Here, again, are the contents of main.m:

#import <Foundation/Foundation.h>

int main (int argc, const char *argv[])

{

NSLog (@"Hello, Objective-C!");

return (0);

} // main

Xcode uses the .m extension to indicate a ﬁle that holds Objective-C code and will be processed

by the Objective-C compiler. File names ending in .c are handled by the C compiler, and .cpp

ﬁles are the province of the C++ compiler. (In Xcode, all this compiling is handled by the LLVM

compiler by default), a single compiler that understands all three variations of the language.)

The main ﬁle contains two lines of code that should be familiar to you already if you know

plain C: the declaration of main() and the return (0) statement at the end. Remember that

Objective-C really is C at heart, and the syntax for declaring main() and returning a value is the

same as in C. The rest of the code looks slightly different from regular C. For example, what is

that wacky #import thing? To ﬁnd out, read on!

Note The .m extension originally stood for “messages” when Objective-C was ﬁrst introduced,

referring to a central feature of Objective-C that we’ll talk about in future chapters. Nowadays, we just

call them “dot-m ﬁles.”

That Wacky #import Thing

Just like C, Objective-C uses header ﬁles to hold the declarations of elements such as structs,

symbolic constants, and function prototypes. In C, you use the #include statement to inform

the compiler that it should consult a header ﬁle for some deﬁnitions. You can use #include in

Objective-C programs for the same purpose, but you probably never will. Instead, you’ll use

#import, like this:

#import <Foundation/Foundation.h>

#import is a feature provided by the compiler that Xcode uses, which is what Xcode uses when

you’re compiling Objective-C, C, and C++ programs. #import guarantees that a header ﬁle will

be included only once, no matter how many times the #import directive is actually seen for

that ﬁle.

Note In C, programmers typically use a scheme based on the #ifdef directive to avoid the situation

where one ﬁle includes a second ﬁle, which then, recursively, includes the ﬁrst.

In Objective-C, programmers use #import to accomplish the same thing.

Chapter 2: Extensions to C

The #import <Foundation/Foundation.h> statement tells the compiler to look at the

Foundation.h header ﬁle in the Foundation framework.

Introducing Frameworks

What’s a framework? We’re glad you asked. A framework is a collection of parts—header

ﬁles, libraries, images, sounds, and more—collected together into a single unit. Apple ships

technologies such as Cocoa, Carbon, QuickTime, and OpenGL as sets of frameworks. Cocoa

consists of a pair of frameworks, Foundation and Application Kit (also known as AppKit), along

with a suite of supporting frameworks, including Core Animation and Core Image, which add all

sorts of cool stuff to Cocoa.

The Foundation framework handles features found in the layers beneath the user interface, such

as data structures and communication mechanisms. All the programs in this book are based on

the Foundation framework.

Note Once you ﬁnish this book, your next step along the road to becoming a Cocoa guru is to master

Cocoa’s Application Kit, which contains Cocoa’s high-level features: user interface elements, printing,

color and sound management, AppleScript support, and so on. To ﬁnd out more, check out Learn

Cocoa on the Mac by Jack Nutting, David Mark, and Jeff LaMarche (Apress 2010).

Each framework is a signiﬁcant collection of technology, often containing dozens or even

hundreds of header ﬁles. Each framework has a master header ﬁle that includes all the

framework’s individual header ﬁles. By using #import on the master header ﬁle, you have access

to all the framework’s features.

The header ﬁles for the Foundation framework take up nearly a megabyte of disk storage and

contain more than 14,000 lines of code, spread across over a hundred ﬁles. When you include

the master header ﬁle with #import <Foundation/Foundation.h>, you get that whole vast

collection. You might think wading through all that text for every ﬁle would take the compiler a lot

of time, but Xcode is smart: it speeds up the task by using precompiled headers, a compressed

and digested form of the header that’s loaded quickly when you #import it.

If you’re curious about which headers are included with the Foundation framework, you can

peek inside its Headers directory (/System/Library/Frameworks/Foundation.framework/Headers/).

You won’t break anything if you browse the ﬁles in there; just don’t remove or change anything.

NSLog() and @"strings"

Now that we have used #import on the master header ﬁle for the Foundation framework, you’re

ready to write code that takes advantage of some Cocoa features. The ﬁrst (and only) real line of

code in Hello Objective-C uses the NSLog() function, like so:

NSLog (@"Hello, Objective-C!");

Chapter 2: Extensions to C14

This prints “Hello, Objective-C!” to the console. If you’ve used C at all, you have undoubtedly

encountered printf() in your travels. NSLog() is a Cocoa function that works very much like printf().

Just like printf(), NSLog() takes a string as its ﬁrst argument. This string can contain format

speciﬁers (such as %d), and the function takes additional parameters that match the format

speciﬁers. printf() plugs these extra parameters into the string before it gets printed.

As we’ve said before, Objective-C is just C with a little bit of special sauce, so you’re welcome to

use printf() instead of NSLog() if you want. We recommend NSLog(), however, because it adds

features such as time and date stamps, as well as automatically appending the newline ('\n')

character for you.

The NS Preﬁx: A Prescription Against Name Collisions

You might be thinking that NSLog() is kind of a strange name for a function. What is that “NS”

doing there? It turns out that Cocoa preﬁxes all its function, constant, and type names with

“NS”. This preﬁx tells you the function comes from Cocoa instead of some other toolkit.

The preﬁx helps prevent name collisions, big problems that result when the same identiﬁer is

used for two different things. If Cocoa had named this function Log(), there’s a good chance

the name would clash with a Log() function created by some innocent programmer somewhere.

When a program containing Log() is built with Cocoa included, Xcode complains that Log() is

deﬁned multiple times, and sadness results.

Now that you have an idea why a preﬁx is a good idea, you might wonder about the speciﬁc

choice: why “NS” instead of “Cocoa,” for example? Well, the “NS” preﬁx dates back from the

time when the toolkit was called NextSTEP and was the product of NeXT Software (formerly

NeXT, Inc.), which was acquired by Apple in 1996. Rather than break compatibility with code

already written for NextSTEP, Apple just continued to use the “NS” preﬁx. It’s a historical

curiosity now, like your appendix.

Cocoa has staked its claim on the “NS” preﬁx, so obviously, you should not preﬁx any of your

own variables or function names with “NS”. If you do, you will confuse the readers of your code,

making them think your stuff actually belongs to Cocoa. Also, your code might break in the

future if Apple happens to add a function to Cocoa with the same name as yours. There is no

centralized preﬁx registry, so you can pick your own preﬁx. Many people preﬁx names with their

initials or company names. To make our examples a little simpler, we won’t use a preﬁx for the

code in this book.

NSString: Where it’s @

Let’s take another look at that NSLog() statement: NSLog (@"Hello, Objective-C!");

Did you notice the at sign before the string? It’s not a typo that made it past our vigilant editors.

The at sign is one of the features that Objective-C adds to standard C. A string in double quotes

preceded by an at sign means that the quoted string should be treated as a Cocoa NSString

element.

So what’s an NSString element? Peel the “NS” preﬁx off the name and you see a familiar term:

“String.” You already know that a string is a sequence of characters, usually human-readable, so

you can probably guess (correctly) that an NSString is a sequence of characters in Cocoa.

Chapter 2: Extensions to C16

Here’s another cool fact about NSString: the name itself highlights one of the nice features of

Cocoa. Most Cocoa elements are named in a very straightforward manner, striving to describe

the features they implement. For instance, NSArray provides arrays; NSDateFormatter helps you

format dates in different ways; NSThread gives you tools for multithreaded programming; and

NSSpeechSynthesizer lets you hear speech.

Now, we’ll get back to stepping through our little program. The last line of the program is the

return statement that ends the execution of main() and ﬁnishes the program:

return (0);

The zero value returned says that our program completed successfully. This is just the way

return statements work in C.

Congratulations, again! You’ve just written, compiled, run, and dissected your ﬁrst Objective-C

program.

Are You the Boolean Type?

Many languages have a Boolean type, which is, of course, a fancy term for variables that store

true and false values. Objective-C is no exception.

C has a Boolean data type, bool, which can take on the values true and false. Objective-C

provides a similar type, BOOL, which can have the values YES and NO. Objective-C’s BOOL type,

incidentally, predates C’s bool type by over a decade. The two different Boolean types can

coexist in the same program, but when you’re writing Cocoa code, you’ll be using BOOL.

Note BOOL in Objective-C is actually just a type deﬁnition (typedef) for the signed character type

(signed char), which uses 8 bits of storage. YES is deﬁned as 1 and NO as 0 (using #deﬁne).

Objective-C doesn’t treat BOOL as a true Boolean type that can hold only YES or NO values. The compiler

considers BOOL to be an 8-bit number, and the values of YES and NO are just a convention. This causes a

subtle gotcha: if you inadvertently assign an integer value that’s more than 1 byte long, such as a short or

an int value, to a BOOL variable, only the lowest byte is used for the value of the BOOL. If that byte happens

to be zero (as with 8960, which in hexadecimal is 0x2300), the BOOL value will be zero, the NO value.

Mighty BOOL in Action

To show mighty BOOL in action, we move on to our next project, 02.02 - BOOL Party, which

compares pairs of integers to see if they’re different. Aside from main(), the program deﬁnes

two functions. The ﬁrst, areIntsDifferent(), takes two integer values and returns a BOOL: YES if

the integers are different and NO if they are the same. A second function, boolString(), takes a

BOOL parameter and returns the string @"YES" if the parameter is YES and @"NO" if the parameter

is NO. This function is handy to have around when you want to print out a human-readable

representation of BOOL values. main() uses these two functions to compare integers and print out

the results.

剩余370页未读，继续阅读

ypf20062008

粉丝: 27

精通Objective-C：Mac与iOS平台编程指南(第2版)

Learn.Objective-C.on.the.Mac.2nd.Edition.SourceCode

Learn Objective-C on the Mac For OS X and iOS 2nd Edition

Learn Objective-c on the Mac 2nd edition

已知x=[-2.3178 -2.3343 -2.3508 -2.3674 -2.3840 -2.4006 -2.4173 -2.4340 -2.4448 -2.4507 -2.4675 -2.4844 -2.5013],y=[-1.4227 -1.4286 -1.4346 -1.4406 -1.4465 -1.4525 -1.4585 -1.4644 -1.4683 -1.4704 -1.4764 -1.4823]

将给出二维数组[[ 1., -1., 3.],[ 2., 4., 2.],[ 4., 6., -1.]]标准化缩放的函数方法

请列100个Python的库

swiftui object-c对比

ERROR: Could not build wheels for numpy, scikit-learn, scipy, which is required to install pyproject.toml-based projects

有哪些软件是Python做的

Could not build wheels for scikit-learn, which is required to install pyproject.toml-based projects

最新资源