面向对象

——————————————————————————————

#import <Foundation/Foundation.h>

// #include <Foundation/Foundation.h>

// #import 地位与 #include 一样

// #include 是 C 语言中引用头文件的语法

// #import 是 OC 中引用头文件的语法

// #import 会自动的排除重复引用的头文件, #import是 Xcode 编译器指令

// main 函数还是程序的入口函数

// 参数也是与 C语言一样

int main(int argc,const char *argv[]) {

  // 自动释放池

  // 使用 @ 开头, 在 OC 中, OC 提供的很多关键字都是使用 @ 开头

  @autoreleasepool {

    // 在 OC 中, 字符串也是个对象, 使用 @ 开头

    // NSLog(@"我的第一个 OC程序, 嘢!");

    // NSLog([NSString stringWithUTF8String:"我是一个 C语言字符串"]);

    // NSLog 是一个函数

    // void NSLog(NSString *format, ...);

    // NSLog(@"Hello World");

    // 与 C 语言中 printf 的定义

    // int printf(const char *format, ...);

    // priontf("Hello World");

    // NSLog 是将数据写入到 stderr 流中, 将数据写入到了 日志数据的缓存流 中

    // NSLog(@"打印函数");

    // 1, 会自动换行

    // 2, 会打印出其他的信息

    // 3, 使用 OC 的字符串对象

    // 4, 与 printf 一样支持格式化控制输出(字符串使用 %@)

    //     %d %c %f %@  %u  %lu ...

   int num = 123;

   float fNum = 1.23;

   char ch = 'a';

   char *str = "abc你好def";

    // printf("%d, %f, %c, %s\n", num, fNum, ch, str);

    // NSLog(@"%d, %f, %c, %@", num, fNum, ch, @"abc你好def");

   NSLog(@"%lu",sizeof(int));

    // printf("123"); // stdout

  }

  return 0;

——————————————————————————————

如果需要使用面向对象编程, 有一些概念需要了解

    类    class      类就是对象的模板, 用于创建对象

    实例  instance  实例就是对象, 只是一般指某一个类的实例,对象一般是泛称,

   或统称

                    在面向对象的的概念中,用类创建出对象的过程, 常常也称为实例化

    对象  object

    方法  method    方法和函数是一样的东西, 都是代码的封装,或是过程的封装

                    方法是指对象具备的能力

                    方法和函数的区别

    字段  field       描述人: 身高, 体重, 眼睛个数, 姓名, 年龄, 性别 ...

                      定义在类中, 用于存储特征的数据的变量, 就是字段

                     每一个由类创建出来的实例,都具备这个变量

    属性  property    是限制字段读取而定义的特殊的方法

——————————————————————————————

/*

    定义类的语法

    类的定义分成两个部分, 分别是 interface 和 implementaion

    语法:

    @interface 类名 : 父类名 {

        // 写字段

    }

    // 写方法

    @end

    @implementation 类名

    // 方法的具体实现

    @end

 */

// 写一个 Person 类

// 年龄:int age, 性别:char gender, 姓名: NSString *name

@interface Person :NSObject { // 花括号中的所有字段, 对外默认是不可见的,

                              // 如果需要对外可见,添加 @public

@public

 NSString *name;

 int age;

 char gender;

}

@end

@implementation Person

@end

// 将这个类实例化,就是创建出对象

// 语法

//  类型名 *变量名 = [类型名 new];

int main(int argc,const char *argv[]) {

  @autoreleasepool {

   Person *p = [Personnew];

    // 此时向 Person 发送一个 new 消息, 来创建对象

    // 给 p 的成员赋值

    p->name =@"张三";

    p->age =19;

    p->gender ='m';

    // 将其打印出来

   NSLog(@"%@, %c, %d", p->name, p->gender, p->age);

  }

  return 0;

}

——————————————————————————————

/*

    方法 就是对象具备的能力, 可以执行的代码

    从面相对象的角度看,方法具有两种

    1, 类方法(在其他的编程语言中,常常称为静态方法)

    2, 实例方法

    语法:

    无参无返回值的语法

    类方法

    + (void) 方法名;   // 声明

    + (void) 方法名 { ... }  // 具体的实现

    实例方法

    - (void) 方法名;

    - (void) 方法名 { ... }

    如何使用方法

    1, 类方法,使用类名进行执行

        [类名 方法名]

    2, 实例方法,使用实例对象进行执行

        [实例 方法名]

 */

    // 调用类方法

    // 向 TestMethod 类 发送一个 classMethod 的消息

    // [TestMethod classMethod];

    //实例方法, 必须先创建实例对象

    TestMethod *p = [TestMethodnew];

    // 向实例 p 发送一个 instanceMethod消息

    [p instanceMethod];

———————————带返回值———————————————————

//

// 带有返回值的方法语法

// 1, 类方法语法

// + (类型) 方法名;

// + (类型) 方法名 { ... return ...}

// 2, 实例方法

// - (类型) 方法名;

// - (类型) 方法名 { ... return ...}

——————————————————————————————

// 语法

// + (返回类型)方法名:(参数类型)参数名;

// + (返回类型) 方法名:(参数类型) 参数名 { ... }

// C 语言的函数

// 打印一个数字的两倍

//   void      func     (int      num) { printf("%d\n", num * 2); }

// + (void)    func:    (int)    num  { ... }

// OC 中方法名是需要跟冒号的

// Func

// Func:

#import <Foundation/Foundation.h>

@interface Test : NSObject

+ (void) Func: (int) num;

@end

@implementation Test

+ (void) Func:(int)num {

   NSLog(@"%d", num *2);

}

@end

——————————————————————————————

/ 语法

// + (void) Func: (类型)变量名    :(类型名)变量名  :(...)...;

#import <Foundation/Foundation.h>

// sum(int num1, int num2, ...)

/*

@interface Test : NSObject

+ (void) Sum:(int)num1  :(int)num2;

// 方法名是     Sum::

@end

@implementation Test

+ (void)Sum:(int)num1 :(int)num2 {

    NSLog(@"%d + %d = %d", num1, num2, num1 + num2);

}

@end

*/

@interface Test : NSObject

// + (void) SumWithNum:(int)num1 andNum:(int)num2 andNum:(int)num3;

// 方法名是

+ (void)___求数字的和_数字有:(int)num1和:(int)num2和:(int)num3;

// 方法名是  ___求数字的和_数字有:和: 和:

@end

@implementation Test

+ (void)___求数字的和_数字有:(int)num1和:(int)num2和:(int)num3 {

 NSLog(@"求得的和为 %d", num1 + num2 + num3);

}

@end

int main(int argc,const char *argv[]) {

  @autoreleasepool {

    // [Test Sum:10 :5];

    [Test___求数字的和_数字有:1和:2和:3];

  }

  return 0;

——————————————————————————————

typedef enum {

    iPhoneColorSilver,

    iPhoneColorWhite,

    iPhoneColorGold

} iPhoneColor;

——————————————————————————————

/*

    字段 Field

    就是存储对象的特征的变量

    如何访问字段?

    1, 在类的外面

        p->name   字段需要是 @public

    2, 在类的里面(在方法中访问字段)

        在方法中,直接使用字段的名字即可

 */

——————————————————————————————

// 如果需要访问字段,并为其设置数据或修改数据, 一般需要添加两个 方法

// 一个是用于设置数据的 set方法, 一个是用于获得数据的 get方法

// 一般的语法为

// 字段名为 name, age

// 给 name 设置方法

// - (NSString *)name ; // get 方法不带有 get名字, 但是这个方法也叫 get 方法

// - (void)setName:(NSString *)value ;

// 给 age 设置方法

// - (int)age;

// - (void)setAge:(int)value

——————————————————————————————

// 一般在 OC 中, set 属性带有的参数名字一般与字段的名字一样

// 1, 一般会使用 self->字段名显式的表示当前字段

// 2, 一般在字段的名字前面会加上一个下划线

@interface Person :NSObject {

 NSString *_name;

 int _age;

 char _gender;

}

- (NSString *)name;

- (void)setName:(NSString *)name;

- (int)age;

- (void)setAge:(int)age;

- (char)gender;

- (void)setGender:(char)gender;

- (void)sayHello;

@end

@implementation Person

- (NSString *)name {

  return _name;

}

- (void)setName:(NSString *)name {

  // name = name;

  //传入的参数, 与字段的名字一样,那么会影响到字段变量的作用域

  //因此此时都是局部变量, 没有字段在里面

  //为了解决这个问题, 应该让左边的 name显式的描述成是 这个类的字段

  // 使用 self 表示当前对象

 self->_name = name;

}

- (int)age {

  return _age;

}

- (void)setAge:(int)age {

 int num = 10;

 char abc = '1';

  // age    参数

  // _age   字段

  // num, abc  局部变量

 self->_age = age;

}

- (char)gender {

  return_gender;

}

- (void)setGender:(char)gender {

 self->_gender = gender;

}

- (void)sayHello {

  NSLog(@"你好,我是 %@, 我今年 %d 岁了, 我是 %@ 的",_name, _age,

       _gender == 'm' ?@"男" :@"女");

}

@end

int main(int argc,const char *argv[]) {

  @autoreleasepool {

   Person *p = [Personnew];

    // [p abcdef]; // interface

    // 标准用法

    [psetName:@"张三"];

    [psetAge:19];

    [psetGender:'m'];

    [psayHello];

   NSLog(@"%@, %c, %d", [pname], [p gender], [page]);

    // OC 2.0 借鉴了 Java 的用法, 为编译器进行了优化

    // 编译器在底层, 将其会转换为 [p name] 的使用形式

    p.name =@"李四";

    p.gender ='f';

    p.age =19;

    [psayHello];

   NSLog(@"%@, %c, %d", p.name, p.gender, p.age);

    // 称其为 属性

  }

  return 0;

}

——————————————————————————————

Test *p;

    // nil就是和 C 语言中 NULL一样,表示一个0地址,意义为不指向任何对象

    //创建类的目的? 为了利用类这个模板创建很多很多的对象

   Test *p1 = [Testnew];

   Test *p2 = [Testnew];

   Test *p3 = [Testnew];

    // 在默认情况下, new 的含义

    // 1, 向操作系统申请内存空间, 类似于 C 语言中的 malloc

    // 2, 在将所有的内存清零

    // 3, 返回首地址

   Test *p4 = [[Testalloc] init];

    // initWith...

    // 与 Java 中 创建对象的

    // Person p = new Person();

    // 一样

    // new 表示申请内粗空间, 类似于 OC 中的 alloc

    //后面的构造方法是对内存进行初始化, 类似于 OC中的 init

    //在函数中声明的所有的局部变量,实际上在函数一开始运行的时候就分配内存了

    // p1, p2, p3 本质是什么东西? 是指针

   NSLog(@"%p", p1);

   NSLog(@"%p", p2);

   NSLog(@"%p", p3);

    // p里面存储的这个地址代表什么含义?

   NSLog(@"%p", &p1);

   NSLog(@"%p", &p2);

   NSLog(@"%p", &p3);

    //这些地址都表示的是什么?

    // 一个 OC 的源文件(.m)  -> 编译器 -> 目标文件 -> 连接 -> 可执行文件

    //一个可执行文件中, 到底有什么东西?

    //实际上这个文件中包含编写代码中的代码内容和数据常量以及"文件头(Mach-O)"

    //在运行程序的时候, 这些数据会加载到内存中

    //这些数据中的代码就会成为"代码区"

    // 这些常量,会成为"常量区"

    //没有初始化的全局变量这个时候进行初始化

    // 找到 main 函数开始执行

    //在每一个操作系统中都会有一个可执行程序的标准,

    //这个标准记录了程序的加载规范

    // 在 Linux 比较流行 LEF

    // 在 Windows 是 PE

    // 在 Mac 是 Mach-O

    //记录了程序运行与跳转的指令

    //首先将可执行文件加载到内存中, 然后开始执行 main函数

    //此时在内存中, 一定会有一个区域存储索要执行的代码

    //类, 方法,函数 等等都在内存中有一个区域存储

    //一旦执行应用程序中的函数, 就会开辟一个栈内存

    //如果创建了一个对象, 那么对象的引用指针在函数的栈区

    //对象本身的数据在 堆区

———————————对象做方法的参数$———————————————————

// 1, 对象作为方法的参数

// 2, 对象作为方法的返回值

#import <Foundation/Foundation.h>

#pragma mark - Test1

@interface Test1 :NSObject {

@public

 int num;

}

- (void)method1;

@end

@implementation Test1

- (void)method1 {

 NSLog(@"%d",num);

}

@end

#pragma mark - Test2

@interface Test2 :NSObject {

@public

 int num;

}

- (void)method2:(Test1 *)t;

@end

@implementation Test2

- (void)method2:(Test1 *)t {

  [tmethod1];

  NSLog(@"method2 === %d",num);

}

@end

int main(int argc,const char *argv[]) {

  @autoreleasepool {

   //

   Test1 *t1 = [Test1new]; // 剑

   Test2 *t2 = [Test2new]; // 勇士

    t1->num =123;

    t2->num =456;

    [t2method2:t1];

  }

  return 0;

}

——————————————————————————————

#import <Foundation/Foundation.h>

#import <stdlib.h>

// 创建两个类

@interface Gun : NSObject {

@public

   int _count;

}

- (void)shoot;

@end

@implementation Gun

- (void)shoot {

    printf("biu...\n");

   _count--;

}

@end

@interface ZhanShi :NSObject {

@public

   int _blood;

   Gun *_gun;

}

- (void)catchGun:(Gun *)gun;

- (int)fire:(int)count;

@end

@implementation ZhanShi

- (void)catchGun:(Gun *)gun {

    //提示一下是否需要捡起手枪

    printf("请问是否捡起手枪:1捡起, ...\n");

   int isCatch;

   scanf("%d", &isCatch);

   if(isCatch != 1) {

       printf("忽略\n");

       return;

    }

    

    

    // 捡起手枪, 并装配手枪

   _gun = gun;

    printf("已经装配号了手枪\n");

}

- (int)fire:(int)count {

    // 开火

    //先判断手枪里有没有子弹, 如果没有子弹就警告

    

    //如果子弹数少于count,就全部打出,并返回发射子弹的数量

    

   if(_gun == nil) {

        printf("没有手枪....\n");

       return 0;

    }

    

   int temp = 0;

   if(_gun->_count ==0) {

        printf("子弹没有了,僵尸来袭\n");

        temp =0;

    }else if(_gun->_count < count) {

       printf("子弹不够...\n");

        temp =_gun->_count;

    }else {

        temp = count;

    }

    

   for (int i =0; i < temp; ++i) {

        [_gunshoot];

    }

    

   return temp;

}

@end

int main(int argc,const char * argv[]) {

    @autoreleasepool {

        // 创造一个战士对象

        //随机的创造有一定子弹数的手枪

       ZhanShi *p = [ZhanShinew];

       // 初始化

        p->_blood =10;

        

       /*

        Gun *gun = [Gun new];

        gun->_count = 9;

        

        [p catchGun:gun];

        

        int temp = [p fire:10];

        printf("发射了 %d 发子弹\n", temp);

        */

        

       // 创建战士

       int i = 0;

       while(i < 5) {

           system("clear");

            

            // printf("--------%d--------\n", p->_blood);

            

            // 创建手枪, 子弹是随机的

           Gun *gun = [Gunnew];

            gun->_count =arc4random_uniform(15);

           printf("有子弹 %d发\n", gun->_count);

            

            //战士发现了手枪, 询问是否捡起来,如果捡起来, 需要替换原来的手枪

            [pcatchGun:gun];

            

            

           // 一大波僵尸来袭

           int jCount = arc4random_uniform(15);

           printf("前方有 %d个僵尸来袭\n", jCount);

            

            // 传一个数字, 表示开枪数, 子弹的个数

           printf("请确定开多少枪\n");

           int zidanCount;

           scanf("%d", &zidanCount);

           while(getchar() !='\n');

            

            //僵尸的个数也是随机的, 如果子弹数少于僵尸的个数,那么僵尸会打不完, 你就被僵尸咬一口

           // 血就会减少

            

           int temp = [p fire:zidanCount];

           printf("杀掉了 %d个僵尸,还有 %d个僵尸\n", temp, jCount -= temp);

            

            // printf("--------%d--------\n", p->_blood);

            

            

            // 僵尸有多少被咬几口, 减多少滴血

            p->_blood -= jCount;

            

           printf("还剩 %d滴写\n", p->_blood);

            

           if(p->_blood <=0) {

               printf("you are died...");

               break;

            }

            

           printf("安回车继续....");

           getchar();

            

            i++;

        }

        

        

    }

   return 0;

}

——————————————————————————————

 在实际开发过程中, OC与 C 语言一样,利用文件将封装的内容区分开来

    写一个类需要两个部分,一个是声明, 一个是实现,与 C 与中一样

    那么一般将 @interface 的声明部分放到 .h 文件中

    将 @implementation 的实现 放到 .m 文件中

 

    在 Xcode 中的操作步骤

    1) 选中项目文件夹(需要添加文件的地方)

    2) 右键 new file

    3) 选择框架中的 Cocoa Class

    4) 填写 类名, 同时设置 父类, 选择 语言

    5) 添加, 下一步等

    6) 得到两个文件,文件名相同, 只是后缀名一个是 .h一个是 .m

    

 

    最后在使用的时候,需要导入头文件

    

——————————————————————————————

 在实际开发过程中, OC与 C 语言一样,利用文件将封装的内容区分开来

    写一个类需要两个部分,一个是声明, 一个是实现,与 C 与中一样

    那么一般将 @interface 的声明部分放到 .h 文件中

    将 @implementation 的实现 放到 .m 文件中

 

    在 Xcode 中的操作步骤

    1) 选中项目文件夹(需要添加文件的地方)

    2) 右键 new file

    3) 选择框架中的 Cocoa Class

    4) 填写 类名, 同时设置 父类, 选择 语言

    5) 添加, 下一步等

    6) 得到两个文件,文件名相同, 只是后缀名一个是 .h一个是 .m

    

 

    最后在使用的时候,需要导入头文件

—————————————$—————————————————

  结构体和类

 *  1, 定义

 *      结构体的定义     struct 名字 { ... }

 *      类的定义    @interface ... @end         @implementation ... @end

 *      

 *      结构体定义的成员都是公有,而类定义的成员是受保护

 *      

 *      结构体没有方法,但是可以定义函数指针, 指向一个函数

 *      结构体中定义的函数指针是不能直接访问成员,换句话说, 结构体中函数与数据是分离的

 *  2, 声明变量

 *      类似:  

 *      struct 结构体名 变量名;

 *      类名 *变量名 = [... new];

 *  3, 存储

 *      结构体变量存储在栈内存空间中

 *      对象存储在堆中

 *

 *      结构体是值类型,对象是引用类型

 *

 *  4, 方法的使用

 *  5, 面向对象的观点上

 *

 */

 

        //使用结构体模拟面向对象, 但是数据与函数是分离的,在

        //面向对象的观点中, 方法是为数据服务的,是对象具有某些能力

        // 但是这里的结构体中 sayHello 与 函数 funcSayHello 是

        //完全没有依赖关系的, 可以随时替换的

        

        

// 数据与方法(函数)是紧密联系在一起,也就是说对象与行为是一致

        

——————————————————————————————

 //获取字符串长度的方法

       NSString *str = @"你好abc";

        // 字符串的长度应该是多少呢?

       NSUInteger i = [str length];

        

       NSLog(@"%lu", i);

—————————————$—————————————————

 *  类方法与实力方法的调用特点

 *  实例方法

 *      [实例对象 方法]

 *  类方法

 *      [类名 方法]

 *  一般提供类方法的目的是为了方便操作,简化过程, 并提高性能

 *

 *  一般对象会提供一个构造方法来进行初始化,这个方法是实例方法,

 *那么就会有一个类方法与之对应,完成更简单的执行

 *

 *  类方法一般使用在通用功能上

 *

 *  类方法会提升执行效率

——————————————————————————————

char *str = "你好123abc";

   NSString *str1 = [[NSStringalloc] initWithUTF8String:str];

    // 在 OC 中有一个编码习惯

    //凡是提供一个 initWith 的实例方法,都会提供一个对应的类方法,

    //命名一般以类名开始, 后面的内容一样

   NSString *str2 = [NSStringstringWithUTF8String:str];

——————————————————————————————

1、类方法与实例方法可以重名

 2、类方法可以从父类继承

 3、类方法的声明与实现也是分开的

 4、类方法只能使用类名进行调用，即只允许向类发消息

 5、实例方法可以访问类方法

 6、类方法无法直接调用实例方法，和访问实例成员

——————————————————————————————

#import <Foundation/Foundation.h>

@interface Jisuanqi : NSObject

+ (int)jiafa:(int)num1 and:(int)num2;

+ (int)jianfa:(int)num1 and:(int)num2;

+ (int)chengfa:(int)num1 and:(int)num2;

+ (double)chufa:(int)num1 and:(int)num2;

+ (int)inputNum:(NSString *)message;

+ (char)inputChar:(NSString *)message;

+ (double)JiSuan:(int)num1 and:(char)oper and:(int)num2;

+ (void)run;

@end

@implementation Jisuanqi

+ (int)jiafa:(int)num1 and:(int)num2 {

 return num1 + num2;

}

+ (int)jianfa:(int)num1 and:(int)num2 {

 return num1 - num2;

}

+ (int)chengfa:(int)num1 and:(int)num2 {

 return num1 * num2;

}

+ (double)chufa:(int)num1 and:(int)num2 {

 return num1 * 1.0 / num2;

}

+ (int)inputNum:(NSString *)message {

  printf("%s:", [message UTF8String]);

 int temp;

 scanf("%d", &temp);

 while (getchar() !='\n')

    ;

 return temp;

}

+ (char)inputChar:(NSString *)message {

 printf("%s:", [messageUTF8String]);

 char temp;

 scanf("%c", &temp);

 while (getchar() !='\n')

    ;

 return temp;

}

+ (double)JiSuan:(int)num1 and:(char)oper and:(int)num2 {

 double result = 0;

 switch (oper) {

 case '+':

    result = [Jisuanqijiafa:num1 and:num2];

   break;

 case '-':

    result = [Jisuanqijianfa:num1 and:num2];

   break;

 case '*':

    result = [Jisuanqichengfa:num1 and:num2];

   break;

 case '/':

    result = [Jisuanqichufa:num1 and:num2];

   break;

  }

 return result;

}

+ (void)run {

 int num1 = [JisuanqiinputNum:@"请输入第一个数字"];

 char oper = [JisuanqiinputChar:@"请输入运算符"];

 int num2 = [JisuanqiinputNum:@"请输入第二个数字"];

 double result = [JisuanqiJiSuan:num1 and:operand:num2];

 printf("%d %c %d = %lf\n", num1, oper, num2, result);

}

@end

int main(int argc,const char *argv[]) {

  @autoreleasepool {

    [Jisuanqirun];

  }

  return 0;

}

——————————————————————————————

#import <Foundation/Foundation.h>

@interface Jisuanqi :NSObject {

 int _num1;

 char _oper;

 int _num2;

 double _result;

}

- (Jisuanqi *)myInit;

- (int)jiafa:(int)num1 and:(int)num2;

- (int)jianfa:(int)num1 and:(int)num2;

- (int)chengfa:(int)num1 and:(int)num2;

- (double)chufa:(int)num1 and:(int)num2;

+ (int)inputNum:(NSString *)message;

+ (char)inputChar:(NSString *)message;

- (void)JiSuan;

@end

@implementation Jisuanqi

- (Jisuanqi *)myInit {

  //初始化就是要初始化所有的字段

  _num1 = [JisuanqiinputNum:@"请输入第一个数字"];

 _oper = [JisuanqiinputChar:@"请输入运算符"];

  _num2 = [JisuanqiinputNum:@"请输入第二个数字"];

  return self;

}

- (int)jiafa:(int)num1 and:(int)num2 {

 return num1 + num2;

}

- (int)jianfa:(int)num1 and:(int)num2 {

 return num1 - num2;

}

- (int)chengfa:(int)num1 and:(int)num2 {

 return num1 * num2;

}

- (double)chufa:(int)num1 and:(int)num2 {

 return num1 * 1.0 / num2;

}

+ (int)inputNum:(NSString *)message {

 printf("%s:", [messageUTF8String]);

 int temp;

 scanf("%d", &temp);

 while (getchar() !='\n')

    ;

 return temp;

}

+ (char)inputChar:(NSString *)message {

 printf("%s:", [messageUTF8String]);

 char temp;

 scanf("%c", &temp);

 while (getchar() !='\n')

    ;

 return temp;

}

- (void)JiSuan {

 switch (_oper) {

 case '+':

    _result = [selfjiafa:_num1and:_num2];

   break;

 case '-':

    _result = [selfjianfa:_num1and:_num2];

   break;

 case '*':

    _result = [selfchengfa:_num1and:_num2];

   break;

 case '/':

    _result = [selfchufa:_num1and:_num2];

   break;

  }

  printf("%d %c %d = %lf\n",_num1, _oper,_num2, _result);

}

@end

int main(int argc,const char *argv[]) {

  @autoreleasepool {

   /*

     Jisuanqi *ji = [[Jisuanqi new] myInit];

     [ji JiSuan];

    */

    Jisuanqi *j = [Jisuanqinew];

   while (1) {

      [[jmyInit] JiSuan];

      //            j = [j myInit];

     //

      //            [j JiSuan];

     getchar();

    }

  }

  return 0;

}

——————————————————————————————