iOS开发之const与属性详解-优快云博客

本文详细介绍了iOS开发中const关键字的使用方法及其与宏定义的区别，同时深入探讨了属性property的概念、声明与实现，包括公共属性与专有属性的区别。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

内容转载自宏创学院

如果不想让某些变量的值改变，可以使用const关键字来修饰这些变量，如果添加const关键字，这些变量的值从头到尾都不会改变了。在iOS开发中，经常把字符串常量添加const关键字，从而替代宏（#define），因为const的执行性能要比宏定义要高。

1、const介绍

给变量添加const关键字，主要目的是为了防止定义的对象被修改。在定义有const关键字的对象时，要设置初始值。

在iOS开发中，有关const最常用的就是用来修饰NSString类型的字符串常量，这种使用方法在苹果提供的系统框架中随处可见。如下：

 UIKIT_EXTERN NSString *const UIViewControllerHierarchyInconsistencyException NS_AVAILABLE_IOS(5_0);
UIKIT_EXTERN NSString *const UIViewControllerShowDetailTargetDidChangeNotification NS_AVAILABLE_IOS(8_0);

对于const的使用，只要掌握一条原则即可，即：const用来修饰离其最近的变量。

如下面的代码所示：

当const修饰的是*x时，即指向字符串@”www.hcios.com”的指针指向是不能改变的，但是字符串的内容是可以改变的；
当const修饰的是y时，即指向的字符串内容@”宏创学院”是不能改变的，但是指向的地址是可以改变的。

 void constString () {
    //const修饰的是指针变量*x
    NSString const *x = @"www.hcios.com";
    x = @"宏创学院";
    
    //const修饰的是字符串
    NSString * const y = @"宏创学院";
    /*不能修改
     y = @"www.hcios.com";
     */
    
    NSLog(@"x = %@",x);
    NSLog(@"y = %@",y);
 
}

2、const使用方法

在实际的iOS开发中，const最常用于定义字符串常量，并且为了维护方便，会把工程中所有的字符串常量都统一放在一个const类中。具体的实现方法如下：

新建一个MyConst类；
在.h文件中，声明所有的常量，需要注意一点：每个常量前面都加上extern关键字，否则在编译时会报声明重复错误。如下所示：

 #import <Foundation/Foundation.h>
 
/**高度*/
extern int const height;
 
/**启动成功通知*/
extern NSString * const launchSuccessNotification;

在.m文件中，为每个常量赋值。如下所示：

 #import "MyConst.h"
 
int const height = 44;
 
NSString * const launchSuccessNotification = @"launchSuccessNotification";

当需要使用const修饰的常量时，引入MyConst类即可。如下所示：

 #import <Foundation/Foundation.h>
#import "MyConst.h"
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        /*const使用*/
        NSLog(@"my const height:%d",height);
        NSLog(@"my const notification string: %@",launchSuccessNotification);
    }
    return 0;
}

运行结果：

3、const与宏#define的区别

在开发过程中，如果涉及到字符串常量的定义，建议都用const，其处理性能比宏定义要高。当多次使用该常量时，只要在内存中创建一个对象即可。当使用宏#define来定义字符串常量时，在程序编译的过程中，所有使用到宏的地方都会使用设置的字符串来【替换】，因此当程序运行时，会创建多个对象，占用多个内存区域，执行效率低一些。

对于const和宏的使用，只要把握一个要点即可：凡是涉及到常量的定义都建议用const，并且所有使用const修饰的常量都统一放在一个类中，其他的都可以使用宏来定义。

属性property介绍：1-属性定义

属性property在类定义中使用非常普遍，属性定义后，会创建一个与该属性名称同名且带下划线的实例变量，与此同时，编译器会根据属性的特性，自动合成该属性对应实例变量的存取方法。

1、属性中的一些概念

属性property：通常指的是由对象封装或者存储的数据，例如对于UIView视图类对象，可以具有多个描述该视图类的属性，例如：大小、位置、颜色、是否可以响应用户交互等等。
存取方法setter/getter：设置/获取该类的对象的属性值，执行设置/获取操作的方法称为存取方法；
getter方法：返回属性的值，名称与属性名相同。在实际开发中，常说的懒加载(lazy loading)就是对应了getter方法；
setter方法：设定属性的值，setter方法的形式为“setPropertyName:”，其中属性名称的第一个字母大写。

2、属性的声明

当声明一个属性时，需要在类的@interface代码部分编写，格式如下：

 @property (attributes) type name;

其中：

@property: 属性定义关键字；
attribute：属性的特性，提供了该属性的存储方式以及属性行为的说明，常见的关键字有: weak/strong, assign, copy, atomic/nonatomic；
type: 属性的类型说明，如：NSString, NSNumber，int, CGfloat以及一些自定义类；
name：属性的名称。

示例：

 #import <Foundation/Foundation.h>
#import "MyClass.h"
 
@interface MyPropertyClass : NSObject
 
@property (nonatomic, copy) NSString *name;
@property (nonatomic,assign) int age;
@property (nonatomic,strong) MyClass *myClass;
@property (nonatomic,weak) id delegate;
 
@end

3、属性的实现

声明的属性，编译器会自动生成一个与该属性同名且带下划线的一个实例变量，同时自动生成该实例变量的存取方法。只有在该对象的初始化方法中（懒加载lazy loading），应用程序才直接访问实例变量。一般情况下，当需要使用到对象的属性时，都需要使用“点语法”来直接获取属性的值或者设置属性的值。

懒加载lazy loading：其实就是属性的getter方法，在iOS开发过程中，经常会使用属性的懒加载，所谓懒加载就是当需要获取某个属性的值时，再对该属性对象的实例变量进行初始化，从而提升内存的使用效率。如下为使用懒加载初始化name属性，其中_name是name属性对应的实例变量；

 -(NSString *)name{
    if (_name == nil) {
        _name = [NSString stringWithFormat:@"www.hcios.com"];
    }
    return _name;
}

获取属性的值：可以使用点语法，即.properyname来获取属性的值，如下所示；
设置属性的值：可以使用点语法，来给属性直接设值（注意一点，属性不能是readonly的），如下所示。

 #import "MyPropertyClass.h"
 
int main(int argc, const char * argv[]) {
    @autoreleasepool {
 
        MyPropertyClass *properyClass = [[MyPropertyClass alloc] init];
        //获取属性的值，getter方法
        NSLog(@"初始值：%@",properyClass.name);
        
        //设置属性的值，setter方法
        properyClass.name = @"宏创学院";
        NSLog(@"最新值：%@",properyClass.name);
    }
    return 0;
}

运行结果：

属性property介绍：2-公共属性与专有属性

在自定义类中，既可以在.h文件中声明属性，也可以在.m文件中声明属性。在.h文件中声明的属性可以供外部调用，称为公共属性；在.m文件中声明的属性，即该类扩展中声明的属性，只能在该类的实现部分使用，称为专有属性。

1、定义专有属性

在类实现的.m文件中，可以定义供类内部使用的专用属性。

 #import "MyPropertyClass.h"
 
@interface MyPropertyClass ()
 
@property (nonatomic, copy) NSString *firstName;
@property (nonatomic, copy) NSString *lastName;
 
@end

2、专有属性懒加载

使用懒加载的方式，初始化两个属性。

 /**
 *  firstName懒加载
 *
 *  @return firstName
 */
-(NSString *)firstName{
    if (_firstName == nil) {
        _firstName = [NSString stringWithFormat:@"www."];
    }
    return _firstName;
}
 
/**
 *  lastName懒加载
 *
 *  @return lastName
 */
-(NSString *)lastName{
    if (_lastName == nil) {
        _lastName = [NSString stringWithFormat:@"hcios.com"];
    }
    return _lastName;
}

3、定义公共属性

在类定义的.h文件中，定义供外部调用的公共属性。

 #import <Foundation/Foundation.h>
 
@interface MyPropertyClass : NSObject
 
@property (nonatomic, copy) NSString *name;
 
@end

4、公共属性懒加载

在.m文件中，使用懒加载初始化公共属性。在懒加载中，使用点语法获取firstName以及lastName属性的值，并进行拼接。

 /**
 *  name公共属性懒加载，拼接firstName与lastName
 *
 *  @return name
 */
-(NSString *)name{
    if (_name == nil) {
        self.firstName = [self.firstName stringByAppendingString:self.lastName];
        _name = self.firstName;
    }
    return _name;
}

5、main()中打印公共属性

在外部只能打印公共属性，不能打印专用属性。

 #import <Foundation/Foundation.h>
#import "MyClass.h"
#import "MyConst.h"
#import "MyPropertyClass.h"
 
int main(int argc, const char * argv[]) {
@autoreleasepool {
 
MyPropertyClass *properyClass = [[MyPropertyClass alloc] init];
NSLog(@"初始值：%@",properyClass.name);
 
properyClass.name = @"宏创学院";
NSLog(@"最新值：%@",properyClass.name);
 
}
return 0;
}

运行结果：

属性property介绍：3-属性关键字

在定义属性的时候，需要在括号(）内说明该属性的特性(attribute)。属性的特性决定了属性在原子性、存取方法以及内存管理三个方面的特性。常用的特性关键字有8个，分别为nonatomic/atomic、readonly/readwrite、strong/weak/assign/copy。

1、原子性（nonatomic、atomic）

atomic（默认）：atomic意为操作是原子的，意味着只有一个线程访问实例变量。atomic是线程安全的，至少在当前的存取器上是安全的。它是一个默认的特性，但是很少使用，因为比较影响效率，这跟ARM平台和内部锁机制有关。

当一个变量声明为atomic时，意味着在多线程中只能有一个线程能对它进行访问
当一个变量声明为atomic时，该变量为线程安全型，但是会影响访问速度，
当一个变量声明为atomic时，在非ARC编译环境下，需要设置访问锁来保证对该变量进行正确的getter/setter。

nonatomic(常用)：nonatomic跟atomic刚好相反。表示非原子的，可以被多个线程访问。它的效率比atomic快，但不能保证在多线程环境下的安全性，在单线程和明确只有一个线程访问的情况下广泛使用。

当一个变量声明为nonatomic时，意味着多个线程可以同时对其进行访问
当一个变量声明为nonatomic时，它是非线程安全型，访问速度快；
当一个变量声明为nonatomic时，当两个不同的线程对其访问时，容易失控。

2、存取方法（readonly、readwrite）

readwrite（默认）：readwrite是默认值，表示该属性同时拥有setter和getter。

readonly： readonly表示只有getter没有setter。

有时，在声明属性时，可以指定存取方法的自定义名称，通常在Bool类型的属性的getter方法会采用这种方式，例如：UIView的hidden和opaque属性的getter方法名为:isHidden和isOpaque。

 @property(nonatomic,getter=isHidden) BOOL              hidden; 
@property(nonatomic,getter=isOpaque) BOOL              opaque;

3、内存管理(strong、weak、assign、copy)

由于苹果自iOS5开始引入了ARC（Automatic Reference Counting），且经过几年发展ARC已然成为主流，因此在管理属性有关内存管理的特性时，我们都假设在ARC环境下使用，不考虑MRC的情况。

strong（ARC中为默认）：强引用，表示实例变量对传入的对象要有所有权关系，引用计数+1；
weak：弱引用，在setter方法中，需要对传入的对象不进行引用计数加1的操作。简单来说，就是对传入的对象没有所有权，当该对象引用计数为0时，即该对象被释放后，用weak声明的实例变量指向nil，即实例变量的值为0。
assign: 简单赋值，不更改索引计数，适用简单数据类型。如int、float、double和NSInteger，CGFloat等。
copy: 用于希望保持一份传入值的拷贝，而不是值自身的情况，即把原来的对象完整的赋值到另外一地方，重新加载一内存区，一个地方变了不影响另一个地方的对象。copy与strong类似，但区别在于实例变量是对传入对象的副本拥有所有权，而非对象本身。

示例代码：

创建一个ClassA类，并添加3个NSMutableString类型的属性，但关键词不同，如下所示：

 #import <Foundation/Foundation.h>
 
@interface ClassA : NSObject
 
@property (nonatomic, copy) NSMutableString * name;
 
@property (nonatomic, strong) NSMutableString *strongName;
 
@property (nonatomic, weak) NSMutableString *weakName;
 
@end

在main()中，添加如下代码，通过属性对应的实例变量的内存地址，可以对strong/weak/copy有所理解。其中strong/weak直接指向string的地址，而copy会创建一个新的副本，故内存地址也不一样。

 #import <Foundation/Foundation.h>
 
#import "ClassA.h"
 
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        NSMutableString *string = [[NSMutableString alloc] initWithFormat:@"normal"];
        
        ClassA *classA = [[ClassA alloc] init];
        classA.name = string;
        classA.strongName = string;
        classA.weakName = string;
        
        NSLog(@"string : %@  address: %p", string ,string);
        NSLog(@"copy Property : %@  address: %p", classA.name ,classA.name);
        NSLog(@"strong Property : %@  address: %p", classA.strongName,classA.strongName);
        NSLog(@"weak Property : %@  address: %p", classA.weakName ,classA.weakName);
    }
    return 0;
}

运行结果：

4、速记法

如果在开始学习阶段难以理解有关内存管理相关参数的使用，可以记住如下要点，虽然不是完全规范，但使用起来问题不大。

strong：自定义对象，控制器对象；
weak：代理对象，IBOutlet；
assign：基本数据类型，int、float、double和NSInteger，CGFloat；
copy：NSString，NSArray，NSDictionary及其可变子类。

示例代码：

 @property (nonatomic,copy) NSString *name;
@property (nonatomic,copy) NSArray *courseResults;
@property (nonatomic,assign) int age;
@property (nonatomic,strong) MyClass *myClass;
@property (nonatomic,weak) id delegate;

对象Object介绍：2-对象操作

本节主要介绍对象的一些常见操作，例如判断对象的类型、判断对象是否响应消息、对象间的比较以及对象复制。

1、判断对象的类型

可以让对象调用isKindOfClass:方法，来判断某个对象的类型。isKindOfClass:方法是NSObject类的方法，将类型为Class的对象aClass作为参数传入，返回一个BOOL类型的返回值。

 - (BOOL)isKindOfClass:(Class)aClass;

例如，下面的代码用来判断str是否是NSString类型，如果是NSString类型，则打印一段日志。

         //使用类方法创建字符串对象
        NSString *str = [NSString stringWithFormat:@"www.hcios.com"];
        //判断对象的类
        if ([str isKindOfClass:[NSString class]]) {
            NSLog(@"str class is NSString");
        }

另外，isKindOfClass:方法还可以用于判断子类对象的类型，如下面的代码所示，NSMutableString是NSString的子类，代码执行后，isKindOfClass:方法也会认定mutableStr对象也是属于NSString类型。

         NSMutableString *mutableStr = [NSMutableString string];
        if ([mutableStr isKindOfClass:[NSString class]]) {
            NSLog(@"mutableStr class is NSString");
        }

2、判断对象是否响应消息

要判断一个对象是否响应一则消息，则可以调用respondsToSelector:方法。应用程序通常在验证一个对象响应一则消息后，才将消息发送给该对象。

这种机制，常常用于代理中，先判断代理对象是否响应代理方法，如果响应则代表代理中已经实现了代理方法，然后再通知代理执行代理方法。

示例代码：

在自定义类.h文件中，添加一个属性

 #import <Foundation/Foundation.h>
 
@interface HCClass : NSObject
 
@property (nonatomic, copy) NSString * myName;
 
@end

在自定义类.m文件中，对属性进行懒加载(getter方法)

 -(NSString *)myName{
    if (_myName == nil) {
        _myName = @"this is my name!";
    }
    return _myName;
}

在main()中，判断自定义类是否实现了属性的getter方法

         //判断对象是否响应消息
        HCClass *myClass = [[HCClass alloc] init];
        if ([myClass respondsToSelector:@selector(myName)]) {
            NSLog(@"MyName method exist!");
        }

3、对象比较

可以使用isEqual:方法对比两个对象，如果相同，则该方法返回YES。

在最常用的Foundation框架中，也提供了isEqualToString:或者isEqualToDictionary:等方法，在实际开发中使用比较广泛。

下方的示例代码中，对字符串进行了比较操作，使用了isEqual:方法以及isEqualToString:方法。

 int main(int argc, const char * argv[]) {
    @autoreleasepool {
 
        NSString *str = [NSString stringWithFormat:@"www.hcios.com"];        
        NSString *str2 = @"宏创学院";
       
        //对象比较
        if ([str isEqual:str2]) {
            NSLog(@"str is equal str2!");
        }else {
            NSLog(@"str is NOT equal str2!");
        }
        
        if ([str isEqualToString:@"www.hcios.com"]) {
            NSLog(@"str is equal to string: \"www.hcios.com\"!");
        }  
    }
    return 0;
}

4、对象复制

通过调用copy方法，可以创建对象的副本。调用copy方法，有个前提条件，即接收的对象的类必须遵守NSCopying协议。

下面的示例代码中，对NSString类型的字符串对象进行复制，NSString类在定义中遵守了NSCopying协议。

 @interface NSString : NSObject <NSCopying, NSMutableCopying, NSSecureCoding>//遵守了NSCopying协议

 int main(int argc, const char * argv[]) {
    @autoreleasepool {
 
        NSString *str = [NSString stringWithFormat:@"www.hcios.com"];        
        
        //对象复制
        NSString *str3 = [str copy];
        NSLog(@"str3 is :%@ A",str3);
        }  
    }
    return 0;