【转】Objective-C学习笔记三：基本数据类型和表达式

原文地址：http://sarin.iteye.com/blog/1756872

  任何编程语言都会有数据类型，比如在Java中，数据类型可分为基本数据类型（如int，long等）和引用类型（类类型，如String等）。数据类型在所有语言中又是大同小异的。在O-C中我们已经见过int，那么还有三种最基本的数据类型，float，double和char。 
    int类型表示整数，float和double表示浮点数，只是double可以表示更大的范围，char表示单个字符，如果在O-C中使用字符串，可以使用NSString类型，就是之前我们见过的@""部分。 
    下面来看一段代码，测试基本数据类型的使用：

 

#import <Foundation/Foundation.h>

int main(int argc, const char *argv[])
{
    @autoreleasepool{
        int integerVar = 411;
        float floatVar = 3.79;
        double doubleVar = 1.16e+12;
        char charVar = 'N';

        NSLog(@"integer var = %i", integerVar);
        NSLog(@"float var = %f", floatVar);
        NSLog(@"double var = %e", doubleVar);
        NSLog(@"double var = %g", doubleVar);
        NSLog(@"char var = %c", charVar);
    }
    return 0;
}

 

 这里我们定义了四个变量，各自的内容很好看出，之后我们使用了5条NSLog语句来打印，只是设定的显示数据类型对doubleVar有2个。那么我们在vi中编辑上述代码： 

 

    之后使用clang来进行编译，运行程序得到输出： 

 
    对于int类型的输出没有任何异议，对于float类型，可以看到输出的是六位小数，这是计算机系统本身决定的，因为float型在计算机内的存储方式就比int型特殊。那么之后对double类型的变量处理也是如此，只是不同的表示方式，取得的精度会有所不同。char类型的就不多说了。 
    在使用基本数据类型时，我们只介绍了简单的的四种。其实在O-C中还有long，long long，short，unsigned和signed限定修饰词。前三种其实都是int的扩充，比如长整型，更长的整型，短整型等。在Java中可以直接使用long来声明变量，而在O-C中就要使用long int来声明。那么unsigned和signed表示无符号型和有符号型变量，比如unsigned int表示无符号型整数，也就是正数范围。 
    清楚了基本的数据类型，下面来看一下基本表达式，这也和其它程序设计语言是相同的，最简单的表达式就是算术表达式了。看下面的代码：

 

#import <Foundation/Foundation.h>
int main(int argc, const char * argv[])
{
    @autoreleasepool{
        int a=200,b=20,c=50,d=8,result;
        
        result = a + b;
        NSLog(@"a + b = %i",result);

        result = a * c + b;
        NSLog(@"a * c + b = %i",result);

        result = d + a / c;
        NSLog(@"d + a / c = %i",result);

        result = (a - c) * d;
        NSLog(@"(a - c) * d = %i",result);
    }
    return 0;
}

 

 将代码用vi编辑后使用clang进行编译： 

 

    运行后得到如下输出： 

 
    来分析一下这个程序，包含了最简单的四则元算，只要按照算术运算的法则来算就可以了，优先级在所有编程语言中都是一致的。我们修改一下数值类型，再看下面的程序：

 

#import <Foundation/Foundation.h>
int main(int argc, const char * argv[])
{
    @autoreleasepool{
        int a=200,b=20;
        float c=50.0,d=8.0;
        
        NSLog(@"a + b = %i",a+b);

        NSLog(@"a * c + b = %f",a*c+b);

        NSLog(@"d + a / c = %f",d+a/c);

        NSLog(@"(a - c) * d = %f",(a-c)*d);

        NSLog(@"-a = %i",-a);
    }
    return 0;
}

 

使用vi编辑后编译运行得到如下结果： 

 
    可以看到当数据类型修改后精度改变，那么输出的结果就是精度比较大的类型，这里中间的三个表达式就是float类型的结果，因为有c和d参与了运算。下面来看一下自增和自减运算：

 

#import <Foundation/Foundation.h>
int main(int argc, const char * argv[])
{
    @autoreleasepool{
        int a=5,b=8;
        
        NSLog(@"a++ = %i",a++);

        NSLog(@"--b = %i",--b);

        NSLog(@"++a * b-- = %i",++a * b--);

        NSLog(@"a-- * b++ = %i",a-- * b++);

        NSLog(@"a = %i, b = %i",a,b);
    }
    return 0;
}

 

 编译运行之后我们看到下面的结果： 

 
    自增和自减非常具有迷惑性，这里解释一下，初始值a为5，b为8，执行完第一行后a的值变为6，所以第一行是输出5的，第二行先执行b的自减，因为--在前面，那么得到结果是7。第三行中a先自增变为7，然后参与运算，结果得到49，之后b自减为6。此时第四行中a和b先参与运算结果为42，之后一个减一个增，得到第五行的最终结果。 
    下面来看求模运算：

 

#import <Foundation/Foundation.h>
int main(int argc, const char * argv[])
{
    @autoreleasepool{
        int a=5,b=8,c=3,d=2;
        
        NSLog(@"a %% b = %i",a%b);

        NSLog(@"c %% d = %i",c%d);

        NSLog(@"++a %% b = %i",++a % b);

        NSLog(@"a-- %% c++ = %i",a-- % c++);

        NSLog(@"a = %i, b = %i",a,b);
    }
    return 0;
}

 

 编译运行，得到如下结果： 

 
    来分析一下结果：a%b就是a/b的余数，显然是5，那么c%d得到1。第三行a先自增变成6，然后模8，得到6。第四行a为6时参与运算，而c为3，整除后得到0，然后c自增，a自减。最后a为5而b为8。 
    下面来看一下（强制）类型转换，这也是数据类型中的一个问题，程序设计如下： 

#import <Foundation/Foundation.h>
int main(int argc, const char * argv[])
{
    @autoreleasepool{
        int i1,i2=-120;
        float f1=150.625,f2;
        
        i1=f1;
        NSLog(@"i1 = %i",i1);
        f2=i2;
        NSLog(@"f2 = %f",f2);
        f2=i2/100;
        NSLog(@"f2 = %f",f2);
        f2=i2/100.0;
        NSLog(@"f2 = %f",f2);
        f2=(float)i2/100;
        NSLog(@"f2 = %f",f2);
    }
    return 0;
}

 编译运行后，我们得到如下结果： 

 
    第三个输出是-1.000000而不是-1.200000，原因就是整数做除法时小数会丢失，再将结果赋值给浮点型也是丢失结果后再转化精度，其余的就很好理解了。最后一行运算是先进行强制类型转换，用浮点数做除法，小数就会保留下来。这和其它编程语言也是相同的。 
    赋值运算符在O-C中也是一样的，比如a+=10，就是a=a+10，将a的数值加10后再次赋值给a。同理，b-=8等同于b=b-8，而a/=b-c就是a=a/(b-c)，注意运算的优先级就可以了，这里不再给出具体的示例。 
    最后我们结合面向对象的思想来编写一个简单的计算机。首先定义Calculator类，打开XCode，编写如下代码：

 

//
//  Calculator.h
//  Calculator
//
//  Created by Nan Lei on 12-12-28.
//  Copyright (c) 2012年Nan Lei. All rights reserved.
//
#import<Foundation/Foundation.h>

@interface Calculator : NSObject

-(void) setAccmulator:(double) val;
-(void) clear;
-(double) accmulator;

-(void) add:(double) val;
-(void) subtract:(double) val;
-(void) multiply:(double) val;
-(void) divide:(double)val;

@end

 这是一个计算器类的定义，首先定义设置初始累加数的方法setAccmulator，然后提供一个清零累加数的方法clear，最后给出获取累加数的方法accmulator。对累加数进行四则运算的方法定义很一致，就是方法名不一样，下面来看看这个类的实现： 

 

#import "Calculator.h"

@implementation Calculator
{
    double accmulator;
}

-(void) setAccmulator:(double) val
{
    accmulator=val;
}

-(void) clear
{
    accmulator=0;
}

-(double) accmulator
{
    return accmulator;
}

-(void) add:(double) val
{
    accmulator+=val;
}

-(void) subtract:(double) val
{
    accmulator-=val;
}

-(void) multiply:(double) val
{
    accmulator*=val;
}

-(void) divide:(double)val
{
    accmulator/=val;
}

@end

 

实现的过程就没有什么可多说的了，下面编写main函数来进行测试： 

 

int main(int argc, const char * argv[])
{
    
    @autoreleasepool {
        
        Calculator *calc = [Calculator new];
        
        [calc setAccmulator:10.0];
        [calc add:50.];
        [calc divide: 20.0];
        [calc multiply:40];
        [calc subtract:20];
        NSLog(@"The result is %g",[calc accmulator]);
        [calc clear];
        NSLog(@"The accmulator is %g",calc.accmulator);
        
    }
    return 0;
}

 

看一下运行结果： 
 
    这里我们使用了new方法来创建对象，经过一系列的算术运算我们得到最终结果。之后运行了清零方法，再次打印值是我们使用了对象名.属性名的方式，就看到最终的结果。