03 - const static extern

const是一个C语言的关键字，它限定一个变量不允许被改变。使用const可以在一定程度上提高程序的安全性和可靠性，再者在看别人的代码作品的时候也可以有助于清晰理解const所起的作用。

1、const和#define的区别

　　（1）编译器处理的方式不相同

　　define定义的宏是在预处理阶段展开的，而const定义的常量则是在编译阶段使用的

　　（2）类型和安全检查不同

　　define宏没有类型，并且不做任何的类型检查，仅仅是展开

　　const常量具有具体的类型，在编译阶段会执行类型检查

　　（3）存储方式不同

　　　define定义的宏替换是在编译前完成，并且有多少地方使用，就会出现多少个临时常量的内存，并不会分配内存

　　　const常量会在内存中分配

　2、const变量vs常量

　　常量，例如5和“abc”等，肯定是只读的，因为常量是被编译器放在内存中的只读区域，当然不能够去修改。而只读变量则是在内存中开辟一个地方来存放它的值，只不过这个值不允许被修改。C语言关键字const就是用来限定一个变量不允许被改变的修饰符。

const int n = 5; 　　int a[n]; 

　　在上面的这个例子当中，虽然变量n被修饰为一个只读变量，但是并不是常量，而数组定义的时候，规定数组长度必须是常量，所以会报错。也就是说，常量并不等于不可变的变量

　3、const来限定内容　

1 typedef char * pStr; 　　
2 char string[4] = "abc"; 　
3 const char *p1 = string; //1式 　　
4 const pStr p2 = string; //2式 　　
5 p1++; 　　
6 p2++; 

const使用的基本形式是：

 const type m; 　//　限定m不可变。

　　在第3行代码中const这个关键词修饰的是*p1，所以*p1是不可变的，但是p1是可变的，所以p1++是没有问题的

　　在第4行代码中，const修饰的是p2，所以p2是不可变的，也就是说第6行的代码是错误的。

4、const vs指针

　　1）const在前面

1 const int nValue； // nValue是const
2  const char *pContent; // *pContent是const, pContent可变
3  const char* const pContent;  // pContent和*pContent都是const

　　2）const在后面

1 int const nValue;  // nValue是const
2 char const * pContent;  // *pContent是const, pContent可变
3 char* const pContent;  // pContent是const,*pContent可变
4 char const* const pContent;  // pContent和*pContent都是const

　1）和2）所做的声明是一样的效果

　　例子：　

int const * p1,p2;

　　在这里p2是const修饰的，而（*p1）是作为一个整体收到const修饰的。换句话说，也就是p1是可变的。在这个例子当中，p1是指向整形的指针，

——指针指向的变量不可变，但是指向可以改变

1  　　int x = 1;
2  　　int y = 2;
3  　　const int* px = &x;　　int const* px = &x; //这两句表达式一样效果
4  　　px = &y; //正确，允许改变指向
5  　　*px = 3; //错误，不允许改变指针指向的变量的值

——指针指向的变量的值可以改变，指向不变

1 　　 int x = 1;
2  　　int y = 2;
3  　　int* const px = &x;
4 　　 px = &y; //错误，不允许改变指针指向
5  　　*px = 3; //正确，允许改变指针指向的变量的值

——指针指向的变量不可变，指向不可变

　　 int x = 1;
 　　int y = 2;
 　　const int* const px = &x;　　int const* const px = &x;
　　 px = &y; //错误，不允许改变指针指向
 　　*px = 3; //错误，不允许改变指针指向的变量的值

5、在定义宏的时候，也可以使用const来进行定义

　　在定义宏的时候，也可以使用const来进行定义宏，但是要注意一些问题。比如说，如果把const修饰的宏全部放到pch文件当中的话，会造成，项目中所有的.m文件中都会有这段声明，产生重读定义的问题，解决办法就是重新新建一个.h 和.m文件，然后在.m中定义常量，然后在.h中用extern关键字进行引用就可以了

例如：

——在.m文件中做如下定义：

1 NSString * const HWAppKey = @"3235932662";
2 NSString * const HWRedirectURI = @"http://www.baidu.com";
3 NSString * const HWAppSecret = @"227141af66d895d0dd8baca62f73b700";
4 NSString * const HWMyAge = @"20";

——在.h文件当中用extern关键字进行引用

1 extern NSString * const HWAppKey;
2 extern NSString * const HWRedirectURI;
3 extern NSString * const HWAppSecret;
4 extern NSString * const HWMyAge;

　　在用到这些声明的全局变量的时候只要包含这个文件的头文件即可。

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
        static NSString *ID = @"cell";
        UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:ID];

        if (!cell) {
            cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleSubtitle reuseIdentifier:ID];
        }

        cell.textLabel.text = [NSString stringWithFormat:@"第%ld行数据",indexPath.row];

        return cell;
    }

在使用tableViewCell 的时候经常会出现上述的写法，并且会定义一个static变量，这个变量在编译期会对这个变量进行初始化赋值，也就是说这个变量要么是nil要么就是在定义初期的时候对其进行赋值，一般情况下，只能用NSString或者是基本类型。

static修饰的变量存储在内存中的静态存储区，这块内存在程序的运行期间都会存在。所以保证了static变量的唯一性和持久性。

——static变量不能写在interface里面，会直接报错。static变量只能放在方法里面或者放在implementation外面（通常放在implementation文件开始处），

#import "Printer.h"

static int pageCount;

@implemenation Printer

...

@end

简单的来说，const是静态变量，在声明过后即存在在内存中的特殊位置，下次使用的时候，从该内存中读取上次的存储的值

参考：

http://blog.163.com/[email protected]/blog/static/13174582620139319928864/