足球盘口软件
当前位置: 足球盘口软件 > 前端 >
C语言的关键字,中的变量

Objective-c 中的变量,Objective-c变量

 

  OC中的语言变量,按作用域可分为两种:局部变量和全局变量。

  局部变量:也称为内部变量,局部变量是在方法内部声明的。其作用域仅限于方法内,离开该方法再使用这个变量就是非法的。

  全局变量:也称为外部变量,它是方法外部定义的变量。它不属于哪一个方法,而属于一个源程序文件,其作用域是整个源程序。全局变量的说明符为:extern ,比如:extern int intX; 

  如果一个源文件中的外部变量与局部变量同名,则在局部变量的作用范围内,外部变量被“屏蔽”,而不起作用。通常尽量不使用 extern 变量。

  在类中的实例变量,是可以在各个方法内使用。在这些实例变量上,你可以设置访问控制。

  下面举例来说明局部变量和实例变量的区别:

  

 1 #import <Foundation/Foundation.h>
 2 
 3 @interface Test : NSObject{
 4     int _x;  // 实例变量
 5     int _y;
 6 }
 7 
 8 - (void)setX:(int)x;
 9 - (int)x;
10 
11 - (void)setY:(int)y;
12 - (int)y;
13 
14 - (void)print;
15 
16 @end
17 
18 @implementation Test
19 
20 - (void)setX:(int)x{
21     _x = x;
22 }
23 - (int)x{
24     return _x;
25 }
26 
27 
28 - (void)setY:(int)y{
29     _y = y;
30 }
31 - (int)y{
32     return _y;
33 }
34 
35 - (void)print{
36     int i = 1;  // 局部变量
37     NSLog(@"i = %i",i);
38     NSLog(@"相加的结果:%i",_x + _y);
39 }
40 
41 
42 @end
43 
44 int main(int argc , const char * argv[]){
45     @autoreleasepool {
46         Test *test = [[Test alloc] init];
47         [test setX:10];
48         [test setY:10];
49         NSLog(@"x = %i , y = %i",[test x],[test y]);
50         [test print];
51     }
52     return 0;
53 }

 

   理解 static 变量:

  被 static 修饰的变量称为静态变量。静态变量有以下优点:可以节省内存,因为它是所有对象所公有的,因此,对多个对象来说,静态变量只存储一处,供所有对象共用。静态变量的值对每个对象都一样,但它的值是可以更新的。只要某一个对象对静态变量的值更新一次,所有对象都能访问更新后的值,这样可以提高效率。下面通过代码来演示它的用法:

  

 1 #import <Foundation/Foundation.h>
 2 
 3 @interface Test : NSObject{
 4     
 5 }
 6 - (int)staticIntY;
 7 @end
 8 
 9 @implementation Test
10 
11 static int Y = 10;
12 
13 - (int)staticIntY{
14     Y+=1;
15     return Y;
16 }
17 
18 @end
19 
20 int main(int argc , const char *argv[]){
21     @autoreleasepool {
22         Test *test = [Test new];
23         NSLog(@"Y = %i",[test staticIntY]);  // Y = 11;
24         NSLog(@"Y = %i",[test staticIntY]);  // Y = 12;
25         
26     }
27     return 0;
28 }

 

  变量的存储类别:

  前面已经使用了一些变量存储类别的说明符,例如 extern 和 static,下面将介绍另外三个变量存储类别的说明符:

  1. auto 用于声明一个自动全局变量,是方法内部变量的声明方式,一般省略它,比如:auto int x = int x;

   注意:自动变量没有默认的初始值,除非我们显示的给它赋值,否则它的值不是确定的。

  2. const 可声明程序中的值为不可改变的值,它会告诉编译器,这个变量在程序的运行期间都有恒定的值。是一个常数,例如:const double pi = 3.14;

  3. volatile 这个修饰符和 const 修饰符相反,它告诉编译器,该变量的值会发生改变。例如:

  *char1 = 'a';

  *char1 = 'b';

  如果没有使用 volatile ,那么,当编译器遇到这两行代码的时候,因为这是对一个地址进行两次连续的赋值,所以编译器就将第一个语句从程序中删除掉。为了防止这种情况出现。应该把 char1 声明为一个 volatile 变量;

  volatile char *char1;

 

  下面通过一个例子来演示一下这三个标识符的用法:

  

 1 #import <Foundation/Foundation.h>
 2 
 3 @interface Test  : NSObject{
 4     
 5 }
 6 
 7 - (void)print;
 8 @end
 9 
10 @implementation Test
11 
12 const double d = 3.14;  // 表示d是不会改变的
13 
14 volatile char c = 'c';  // 表示c是随时都可变的
15 
16 - (void)print{
17     auto int i = 10;  // 局部变量
18     NSLog(@"i = %i",i);
19     NSLog(@"d = %f",d);
20     NSLog(@"c = %c",c);
21 }
22 
23 @end
24 
25 int main(int argc , const char *argv[]){
26     @autoreleasepool {
27         Test *test = [Test new];
28         [test print];
29     }
30     return 0;
31 }

 

  

 

 

  

中的变量,Objective-c变量 OC中的语言变量,按作用域可分为两种:局部变量和全局变量。 局部变量:也称为内部变量,局部变量是...

一、C语言的关键字共有32个,根据关键字的作用,可分其为数据类型关键字、控制语句关键字、存储类型关键字和其它关键字四类。

 

1 数据类型关键字(12个):

(1) char :声明字符型变量或函数

(2) double :声明双精度变量或函数

(3) enum :声明枚举类型

(4) float:声明浮点型变量或函数

(5) int: 声明整型变量或函数

(6) long :声明长整型变量或函数

(7) short :声明短整型变量或函数

(8) signed:声明有符号类型变量或函数

(9) struct:声明结构体变量或函数

(10) union:声明共用体(联合)数据类型

(11) unsigned:声明无符号类型变量或函数

(12) void :声明函数无返回值或无参数,声明无类型指针(基本上就这三个作用)

 

2控制语句关键字(12个):

A循环语句

(1) for:一种循环语句(可意会不可言传)

(2) do :循环语句的循环体

(3) while :循环语句的循环条件

(4) break:跳出当前循环

(5) continue:结束当前循环,开始下一轮循环

B条件语句

(1)if: 条件语句

(2)else :条件语句否定分支(与 if 连用)

(3)goto:无条件跳转语句

C开关语句

(1)switch :用于开关语句

(2)case:开关语句分支

(3)default:开关语句中的“其他”分支

D返回语句

return :子程序返回语句(可以带参数,也看不带参数)

 

3 存储类型关键字(4个)

(1)auto :声明自动变量 一般不使用

(2)extern:声明变量是在其他文件正声明(也可以看做是引用变量)

(3)register:声明积存器变量

(4)static :声明静态变量

 

4 其它关键字(4个):

(1)const :声明只读变量

(2)sizeof:计算数据类型长度

(3)typedef:用以给数据类型取别名(当然还有其他作用

(4)volatile:说明变量在程序执行中可被隐含地改变

 

二、C语言中的9中控制语句

goto语句:无条件转向;

if语句:判断语句;

while循环语句;

do-while语句:先执行循环体,然后判断循环条件是否成立. 之后继续循环;

for语句:循环,可替代while语句; 只是用法不同;

break语句跳出本层的循环;(只跳出包含此语句的循环)

continue语句:继续(一般放到循环语句里,不在执行它下面的语句,直接跳到判断语句例:for语句,就直接跳到第二个分号处,while语句,就直接跳到while()的括号里;

switch语句:多相选择;

return语句:返回;

 

第一个关键字:auto  

 

用来声明自动变量。 可以显式的声明变量为自动变量。只要不是声明在所有函数之前的变量,即使没加auto关键字,也默认为自动变量。并且只在声明它的函数内有效。而且当使用完毕后,它的值会自动还原为最初所赋的值。自动变量使用时要先赋值,因为其中包含的是未知的值。例:auto int name=1;

 

第二个关键字:static

 

用来声明静态变量。可以显式的声明变量为静态变量。也为局部变量。只在声明它的函数内有效。它的生命周期从程序开始起一直到程序结束。而且即使使用完毕后,它的值仍旧不还原。即使没有给静态变量赋值,它也会自动初始化为0.例:static int name=1.

有三个明显的作用:

  1). 在函数体,一个被声明为静态的变量在这一函数被调用过程中维持其值不变。

  2). 在模块内(但在函数体外),一个被声明为静态的变量可以被模块内所用函数访问,但不能被模块外其它函数访问。它是一个本地的全局变量。

  3). 在模块内,一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是,这个函数被限制在声明它的模块的本地范围内使用。

static全局变量与普通的全局变量区别 static局部变量和普通局部变量区别 static函数与普通函数区别

全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。全局变量本身就是静态存储方式, 静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序,当一个源程序由多个源文件组成时,非静态的全局变量在各个源文件中都是有效的。 而静态全局变量则限制了其作用域, 即只在定义该变量的源文件内有效,在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内,只能为该源文件内的函数公用,因此可以避免在其它源文件中引起错误。

从以上分析可以看出, 把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域, 限制了它的使用范围。

static函数与普通函数作用域不同。仅在本文件。只在当前源文件中使用的函数应该说明为内部函数(static),内部函数应该在当前源文件中说明和定义。对于可在当前源文件以外使用的函数,应该在一个头文件中说明,要使用这些函数的源文件要包含这个头文件

 

static全局变量与普通的

对于标准数据类型,它的地址只要是它的长度的整数倍就行了,而非标准数据类型按下面的原则对齐:

 

  
  数组 :按照基本数据类型对齐,第一个对齐了后面的自然也就对齐了。 
  联合 :按其包含的长度最大的数据类型对齐。 

 

  结构体: 结构体中每个数据类型都要对齐。

全局变量有什么区别:static全局变量只初使化一次,防止在其他文件单元中被引用;静态全局变量则限制了其作用域, 即只在定义该变量的源文件内有效,在同一源程序的其它源文件中不能使用它

 

static局部变量和普通局部变量有什么区别:static局部变量只被初始化一次,下一次依据上一次结果值;

static函数与普通函数有什么区别:static函数在内存中只有一份,普通函数在每个被调用中维持一份拷贝

程序的局部变量存在于(栈)中,全局变量存在于(静态区)中,动态申请数据存在于(堆)中。

第三个关键字:extern

 

用来声明全局变量。同时声明在main函数之前的变量也叫全局变量。它可以在程序的任何地方使用。程序运行期间它是一直存在的。全局变量也会初始化为0.例:extern int name;

 

第四个关键字:register

 

用来声明为寄存器变量。也为局部变量,只在声明它的函数内有效。它是保存在寄存器之中的。速度要快很多。对于需要频繁使用的变量使用它来声明会提高程序运行速度。例:register int name=1;

声明一个变量常驻寄存器,以达到提高程序运行效率的目的,在嵌入式开发中尤其常用,但它是一个建议性的声明,编译器会根据程序情况决定是否申请成功。

 

第五个关键字:int

 

用来声明变量的类型。int为整型。注意在16位和32位系统中它的范围是不同的。16位中占用2个字节。32位中占用4个字节。还可以显式的声明为无符号或有符号:unsigned int    signed int .有符号和无符号的区别就是把符号位也当作数字位来存储。也可用short和long来声明为短整型,或长整行。例:int num;

 

第六个关键字:float

 

用来声明变量的类型。float为浮点型,也叫实型。它的范围固定为4个字节。其中6位为小数位。其他为整数位。例:float name;

 

第七个关键字:double

 

用来声明为双精度类型。它的范围为8个字节。14位为小数位。也可使用更高精度的long double 它的范围则更大,达到10字节。例:double name;

 

第八个关键字:struct

 

用来声明结构体类型。结构体可以包含各种不同类型的量。比如可以把整型,字符型等类型的变量声明在同一个结构体种,使用的时候使用结构体变量直接可以调用。

 

第九个关键字:char

 

用来定义为字符型变量。它的范围通常为1个字节。它在内存中是以ASC||玛来表示的。所以它也可以跟整型来运算。也可使用无符号或有符号来定义。sigened char    unsigned char例:char c;

 

第十个关键字:break

 

用来表示中断。一般用在循环中。判断是否满足条件然后中断当前循环。例:break;

 

第十一个关键字:continue

 

用来表示跳过当前其后面的语句,继续下一次循环。例:continue;

 

第十二个关键字:long

 

用来声明长型的类型。比如long int long double .

 

第十三个关键字:if

 

判断语句,用来判断语句是否满足条件。

 

 

第十四个关键字:switch

 

条件选择语句,常用来判断用户选择的条件来执行特定语句。

第十五个关键字:case

 

配合switch一起使用,例子同上。

 

第十六个关键字:enum

 

用来声明枚举变量。.. 例:enum day{one,two,three,four,five,six,seven };

 

 

第十七的关键子:typedef

 

类型重定义..可以重定义类型,例:typedef unsigned int u_int;   //将无符号整形定义为u_int .

 

第十八个关键字:return;

 

返回语句。可以返回一个值。当我们定义一个函数为有返回值的时候则必须返回一个值。

 

第十九个关键字:unio

 

定义联共用体。用法用struct相同。不同的是共用体所有成员共享存储空间.

 

                                                   

第二十个关键字:const

 

定义为常量..   例: const int a;     //变量a的值不能被改变.

cons有什么主要的作用?

(1)可以定义const常量,具有不可变性。 例如:

const int Max=100; int Array[Max];

(2)便于进行类型检查,使编译器对处理内容有更多了解,消除了一些隐患。例如: void f(const int i) { .........} 编译器就会知道i是一个常量,不允许修改; (3)可以避免意义模糊的数字出现,同样可以很方便地进行参数的调整和修改。 同宏定义一样,可以做到不变则已,一变都变!如(1)中,如果想修改Max的内容,只需要:const int Max=you want;即可!

(4)可以保护被修饰的东西,防止意外的修改,增强程序的健壮性。 还是上面的例子,如果在函数体内修改了i,编译器就会报错; 例如:

void f(const int i) { i=10;//error! }

(5) 为函数重载提供了一个参考。

class A { ......

void f(int i) {......} //一个函数

void f(int i) const {......} //上一个函数的重载 ......

};

(6) 可以节省空间,避免不必要的内存分配。 例如:

#define PI 3.14159 //常量宏

const doulbe Pi=3.14159; //此时并未将Pi放入ROM中 ......

double i=Pi; //此时为Pi分配内存,以后不再分配!

double I=PI; //编译期间进行宏替换,分配内存

double j=Pi; //没有内存分配

double J=PI; //再进行宏替换,又一次分配内存!

const定义常量从汇编的角度来看,只是给出了对应的内存地址,而不是象#define一样给出的是立即数,所以,const定义的常量在程序运行过程中只有一份拷贝,而#define定义的常量在内存中有若干个拷贝。

(7) 提高了效率。 编译器通常不为普通const常量分配存储空间,而是将它们保存在符号表中,这使得它成为一个编译期间的常量,没有了存储与读内存的操作,使得它的效率也很高。

(1)修饰一般常量 一般常量是指简单类型的常量。这种常量在定义时,修饰符const可以用在类型说明符前,也可以用在类型说明符后。 例如:

int const x=2; 或 const int x=2;

(2)修饰常数组 定义或说明一个常数组可采用如下格式:

int const a[5]={1, 2, 3, 4, 5};

const int a[5]={1, 2, 3, 4, 5};

(3)修饰常对象 常对象是指对象常量,定义格式如下:

class A; const A a;

A const a; 定义常对象时,同样要进行初始化,并且该对象不能再被更新,修饰符const可以放在类名后面,也可以放在类名前面。

(4)修饰常指针

const int *A; //const修饰指向的对象,A可变,A指向的对象不可变

int const *A; //const修饰指向的对象,A可变,A指向的对象不可变

int *const A; //const修饰指针A, A不可变,A指向的对象可变

const int *const A;//指针A和A指向的对象都不可变

(5)修饰常引用 使用const修饰符也可以说明引用,被说明的引用为常引用,该引用所引用的对象不能被更新。其定义格式如下:

const double & v;

(6)修饰函数的常参数 const修饰符也可以修饰函数的传递参数,格式如下:

void Fun(const int Var); 告诉编译器Var在函数体中的无法改变,从而防止了使用者的一些无意的或错误的修改。

(7)修饰函数的返回值: const修饰符也可以修饰函数的返回值,是返回值不可被改变,格式如下:

const int Fun1(); const MyClass Fun2();

(8)修饰类的成员函数: const修饰符也可以修饰类的成员函数,格式如下:

class ClassName {

public:

int Fun() const; .....

}; 这样,在调用函数Fun时就不能修改类里面的数据

(9)在另一连接文件中引用const常量

extern const int i;//正确的引用

extern const int j=10;//错误!常量不可以被再次赋值 另外,还要注意,常量必须初始化! 例如: const int i=5;

 

第二十一个关键字:unsigned

 

定义为无符号的变量.. 默认变量都为有符号的.除非显示的声明为unsigned的.

 

第二十二个关键字:for

 

循环语句.可以指定程序循环多少次. 例: for (int i=0;i<5;i++)

                                                                {

                                                                        printf("程序将输出5次这段话!");

                                                                }

 

第二十三个关键字:signed

 

将变量声明为有符号型. 默认变量就为signed 型。一般可省略。

 

第二十四个关键字:void

 

空类型.. 一般用于声明函数为无返回值或无参数。

 

第二十五个关键字:default

 

用于在switch语句中。定义默认的处理. 用法见switch。

 

第二十六个关键字:goto

 

无条件跳转语句

第二十七个关键子字:sizeof

 

用来获取变量的存储空间大小. 例:

int a,b;

 b=sizeof(a);

 

第二十八个关键字:volatile

 

将变量声明为可变的.

提醒编译器它后面所定义的变量随时都有可能改变,因此编译后的程序每次需要存储或读取这个变量的时候,都会直接从变量地址中读取数据。如果没有volatile关键字,则编译器可能优化读取和存储,可能暂时使用寄存器中的值,如果这个变量由别的程序更新了的话,将出现不一致的现象。

一般说来,volatile用在如下的几个地方:

1、中断服务程序中修改的供其它程序检测的变量需要加volatile;

2、多任务环境下各任务间共享的标志应该加volatile;

3、存储器映射的硬件寄存器通常也要加volatile说明,因为每次对它的读写都可能由不同意义;

另外,以上这几种情况经常还要同时考虑数据的完整性(相互关联的几个标志读了一半被打断了重写),在1中可以通过关中断来实现,2中可以禁止任务调度,3中则只能依靠硬件的良好设计了。

 

 volatile总是与优化有关,编译器有一种技术叫做数据流分析,分析程序中的变量在哪里赋值、在哪里使用、在哪里失效,分析结果可以用于常量合并,常量传播等优化,进一步可以死代码消除。但有时这些优化不是程序所需要的,这时可以用volatile关键字禁止做这些优化,volatile的字面含义是易变的,它有下面的作用: 

 1 不会在两个操作之间把volatile变量缓存在寄存器中。在多任务、中断、甚至setjmp环境下,变量可能被其他的程序改变,编译器自己无法知道,volatile就是告诉编译器这种情况。

2 不做常量合并、常量传播等优化,所以像下面的代码: 

volatile int i = 1; 

if (i > 0) ... 

if的条件不会当作无条件真。 

3 对volatile变量的读写不会被优化掉。如果你对一个变量赋值但后面没用到,编译器常常可以省略那个赋值操作,然而对Memory Mapped IO的处理是不能这样优化的。 

 

第二十九个关键字:do

 

一般与while语句 配合使用. 构成的形式如

do while(

先执行再判断

) 或while do(

先判断再执行

 

第三十个关键字: while

 

循环控制语句。 只要表达式为真就一直循环. 

 

第三十一个关键字:else

 

常用来配合if一起使用。

第三十二个关键字:short

 

用于声明一个短整型变量: 例: short int a; 

 

返回顶部