iOS正確使用const,static,extern

static

• 修飾局部變量

  • 讓局部變量只初始化一次
  • 局部變量在程序中只有一分內存
  • 並不會改變局部變量的做用域，僅僅是改變了局部變量的生命週期（只到程序結束，這個局部變量纔會銷燬）

• 修飾全局變量

  • 全局變量的做用域僅限於當前文件

const

• 沒有const修飾的指針

  • 指針p和*p都能被修改

    // 定義一個指針變量
    int *p = NULL;
    
    // 定義2個int類型的變量
    int a = 10;
    int b = 30;
    
    // p指向a
    p = &a;
    *p = 20;
    
    // p指向b
    p = &b;
    *p = 40;
    
    NSLog(@"%d %d", a, b);

• const修飾的*p

  • 被const修飾的*p只能被賦值一次，之後不能賦值，不然編譯器報錯

    // const修飾的*p
    const int *p = NULL;
    int const *p = null;
    
    *p = 20; // 編譯器報錯，不能修改*p的值

• const修飾的p

  • 被const修飾的p只能存一次地址，之後不再能其它存地址了，不然編譯器報錯

    // const修飾的指針變量p
    int * const p = NULL;
    int a = 20;
    
    p = &a; // 編譯器報錯，不能修改指針變量p

• const在聲明字符串的用法

  NSString * const ZMJName = @"jack";

static和const聯合使用

• static將一個全局變量變成局部變量
• const將一個局部變量變成局部常量

  // 定義了一個局部常量
    static const CGFloat ZMJRed = 0.4;
    static const CGFloat ZMJGreen = 0.6;
    static const CGFloat ZMJBlue = 0.7;

使用static const 與 #define

• 使用static const修飾變量和宏定義的比較
  • 相同點
    • 都不能再被修改
    • 一處修改，其它都改了
  • 不一樣點
    • static const修飾變量只有一分內存
    • 宏定義，只是簡單的替換，每次使用都須要建立一分內存
• 結論
  • 使用static const修飾更加高效，在同一個文件內可使用static const取代#define

// static const修飾變量只有一分內存
    static const CGFloat ZMJRed = 0.4;

    // 宏定義，只是用0.4替換ZMJRed，每次使用都須要建立一分內存
    #define ZMJRed 0.4

const實際開發的應用

• 通常會先新建ZMJConst.h文件專門存放常量的引用

  // 引用某變量，若是沒有使用const修飾，就不能直接在編譯的時候就能檢測是否修改了ZMJRed
  extern const CGFloat ZMJRed;
  extern NSString * const ZMJName;

  • 能夠模仿系統UIKIT_EXTERN來代替extern，逼格更高！

    UIKIT_EXTERN const CGFloat ZMJRed;
    UIKIT_EXTERN NSString * const ZMJName;

• 通常會新建ZMJConst.m文件專門存放static const修飾的變量，須要用的時候導入頭文件就能夠了。

  // 定義了整個程序都能訪問的常量
  const CGFloat ZMJRed = 0.4;
  NSString * const ZMJName = @"jack";

 

文／zhazha（簡書做者）
原文連接：http://www.jianshu.com/p/0a9d2d8062da
著做權歸做者全部，轉載請聯繫做者得到受權，並標註「簡書做者」。


 

1、const與宏的區別（面試題）:

• const簡介:以前經常使用的字符串常量，通常是抽成宏，可是蘋果不推薦咱們抽成宏，推薦咱們使用const常量。

  • 編譯時刻:宏是預編譯（編譯以前處理），const是編譯階段。
  • 編譯檢查:宏不作檢查，不會報編譯錯誤，只是替換，const會編譯檢查，會報編譯錯誤。
  • 宏的好處:宏能定義一些函數，方法。 const不能。

  • 宏的壞處:使用大量宏，容易形成編譯時間久，每次都須要從新替換。

    注意:不少Blog都說使用宏，會消耗不少內存，我這驗證並不會生成不少內存，宏定義的是常量，常量都放在常量區，只會生成一分內存。

Snip20151014_1.png

// 常見的常量：抽成宏
#define XMGAccount @"account"

#define XMGUserDefault [NSUserDefaults standardUserDefaults]

// 字符串常量
static NSString * const account = @"account";

- (void)viewDidLoad {
    [super viewDidLoad];

    // 偏好設置存儲
    // 使用宏
    [XMGUserDefault setValue:@"123" forKey:XMGAccount];

    // 使用const常量
    [[NSUserDefaults standardUserDefaults] setValue:@"123" forKey:account];

}

2、const做用：限制類型

• 1.const僅僅用來修飾右邊的變量（基本數據變量p，指針變量*p）
• 2.被const修飾的變量是隻讀的。
• const基本使用

- (void)viewDidLoad {
    [super viewDidLoad];

    // 定義變量
    int a = 1;

    // 容許修改值
    a = 20;

    // const兩種用法
    // const:修飾基本變量p
    // 這兩種寫法是同樣的，const只修飾右邊的基本變量b
    const int b = 20; // b:只讀變量
    int const b = 20; // b:只讀變量

    // 不容許修改值
    b = 1;

    // const:修飾指針變量*p，帶*的變量，就是指針變量.
    // 定義一個指向int類型的指針變量，指向a的地址
    int *p = &a;

    int c = 10;

    p = &c;

    // 容許修改p指向的地址，
    // 容許修改p訪問內存空間的值
    *p = 20;

    // const修飾指針變量訪問的內存空間，修飾的是右邊*p1，
    // 兩種方式同樣
    const int *p1; // *p1：常量 p1:變量
    int const *p1; // *p1：常量 p1:變量

    // const修飾指針變量p1
    int * const p1; // *p1:變量 p1:常量


    // 第一個const修飾*p1 第二個const修飾 p1
    // 兩種方式同樣
    const int * const p1; // *p1：常量 p1：常量

    int const * const p1;  // *p1：常量 p1：常量



}

3、const開發中使用場景:

• 1.需求1:提供一個方法，這個方法的參數是地址，裏面只能經過地址讀取值,不能經過地址修改值
• 2.需求2:提供一個方法，這個方法的參數是地址，裏面不能修改參數的地址。

@implementation ViewController

// const放*前面約束參數，表示*a只讀
// 只能修改地址a,不能經過a修改訪問的內存空間
- (void)test:(const int * )a
{
//    *a = 20;
}

// const放*後面約束參數，表示a只讀
// 不能修改a的地址，只能修改a訪問的值
- (void)test1:(int * const)a
{
    int b;
    // 會報錯
    a = &b;

    *a = 2;
}

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.

    int a = 10;

    // 需求1:提供一個方法，這個方法的參數是地址，裏面只能經過地址讀取值,不能經過地址修改值。

    // 這時候就須要使用const，約束方法的參數只讀.
    [self test:&a];

    // 需求2:提供一個方法，這個方法的參數是地址，裏面不能修改參數的地址。
    [self test1:&a];
}


@end

4、static和extern簡單使用(要使用一個東西，先了解其做用)

• static做用:

  • 修飾局部變量：

    1.延長局部變量的生命週期,程序結束纔會銷燬。

    2.局部變量只會生成一分內存,只會初始化一次。

    3.改變局部變量的做用域。

  • 修飾全局變量

    1.只能在本文件中訪問,修改全局變量的做用域,生命週期不會改

    2.避免重複定義全局變量

• extern做用:
  • 只是用來獲取全局變量(包括全局靜態變量)的值，不能用於定義變量
• extern工做原理:
  • 先在當前文件查找有沒有全局變量，沒有找到，纔會去其餘文件查找。

// 全局變量：只有一分內存，全部文件共享，與extern聯合使用。
int a = 20;

// static修飾全局變量
static int age = 20;

- (void)test
{
    // static修飾局部變量
    static int age = 0;
    age++;
    NSLog(@"%d",age);
}

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.


    [self test];
    [self test];

    extern int age;
    NSLog(@"%d",age);
}
I

5、static與const聯合使用

• static與const做用:聲明一個只讀的靜態變量
• 開發使用場景:在一個文件中常用的字符串常量，可使用static與const組合

// 開發中經常使用static修飾全局變量,只改變做用域

// 爲何要改變全局變量做用域，防止重複聲明全局變量。

// 開發中聲明的全局變量，有些不但願外界改動，只容許讀取。

// 好比一個基本數據類型不但願別人改動

// 聲明一個靜態的全局只讀常量
static const int a = 20;

// staic和const聯合的做用:聲明一個靜態的全局只讀常量

// iOS中staic和const經常使用使用場景，是用來代替宏，把一個常用的字符串常量，定義成靜態全局只讀變量.

// 開發中常常拿到key修改值，所以用const修飾key,表示key只讀，不容許修改。
static  NSString * const key = @"name";

// 若是 const修飾 *key1,表示*key1只讀，key1仍是能改變。

static  NSString const *key1 = @"name";

6、extern與const聯合使用

• 開發中使用場景:在多個文件中常用的同一個字符串常量，可使用extern與const組合。
• 緣由:
  • static與const組合：在每一個文件都須要定義一份靜態全局變量。
  • extern與const組合:只須要定義一份全局變量，多個文件共享。
• 全局常量正規寫法:開發中便於管理全部的全局變量，一般搞一個GlobeConst文件，裏面專門定義全局變量，統一管理，要否則項目文件多很差找。

• GlobeConst.h

/*******************************首頁****************************/

extern NSString * const nameKey = @"name";

/*******************************首頁****************************/

• GlobeConst.m

#import <Foundation/Foundation.h>

/*******************************首頁****************************/

NSString * const nameKey = @"name";


/*******************************首頁****************************/

 

文／崢吖（簡書做者） 原文連接：http://www.jianshu.com/p/2fd58ed2cf55 著做權歸做者全部，轉載請聯繫做者得到受權，並標註「簡書做者」。