[Objective-C语言教程]函数（11）

函数是一组一起执行任务的语句。每个Objective-C程序都有一个C函数，也就是main()函数，所有最简单的程序都可以定义为函数。

可将代码划分为单独的函数。如何在不同的函数之间划分代码取决于程序员，但逻辑上这个划分通常是这样，每个函数执行一个特定的任务。

函数声明告诉编译器函数的名称，返回类型和参数。函数定义提供函数的实际主体。

在Objective-C中，基本上会将函数称为方法。

Objective-C基础框架提供了程序可以调用的许多内置方法。例如，appendString()方法将字符串附加到另一个字符串。

已知一种方法具有各种名称，如函数或子程序或程序等。

1. 定义方法

Objective-C编程语言中方法定义的一般形式如下 -

1 - (return_type) method_name:( argumentType1 )argumentName1 
2     joiningArgument2:( argumentType2 )argumentName2 ... 
3     joiningArgumentn:( argumentTypen )argumentNamen {
4     body of the function
5 }

Objective-C编程语言中的方法定义由方法头和方法体组成。以下是方法的所有部分 -

返回类型 - 方法可以返回值。return_type是函数返回的值的数据类型。某些方法执行所需的操作而不返回值。在这种情况下，return_type是关键字void。
方法名称 - 这是方法的实际名称。方法名称和参数列表一起构成方法签名。
参数 - 参数就像一个占位符。调用函数时，将值传递给参数。该值称为实际参数或参数。参数列表指的是方法的参数的类型，顺序和数量。参数是可选的; 也就是说，方法可能不包含任何参数。
连接参数 - 一个连接的参数是让它更易于阅读并在调用时清楚地表达它。
方法体 - 方法体包含一组语句，用于定义方法的作用。

示例
以下是名为max()的方法的源代码。这个方法有两个参数num1和num2，并返回两个参数的最大值 -

 1 /* 返回两个参数的最大值 */
 2 - (int) max:(int) num1 secondNumber:(int) num2 {
 3 
 4    /* 局部变量声明 */
 5    int result;
 6 
 7    if (num1 > num2) {
 8       result = num1;
 9    } else {
10       result = num2;
11    }
12 
13    return result; 
14 }

2. 方法声明

方法声明告诉编译器有关函数名称以及如何调用该方法的信息。函数的实际主体可以单独定义。

方法声明包含以下部分 -

1 - (return_type) function_name:( argumentType1 )argumentName1 
2 joiningArgument2:( argumentType2 )argumentName2 ... 
3 joiningArgumentn:( argumentTypen )argumentNamen;

对于上面定义的max()函数，以下是方法声明 -

-(int) max:(int)num1 andNum2:(int)num2;

在一个源文件中定义方法并在另一个文件中调用该方法时，需要方法声明。在这种情况下，应该在调用该函数的文件顶部声明该函数。

3. 调用方法

在创建Objective-C方法时，可以定义函数必须执行的操作。要使用方法，必须调用该函数来执行定义的任务。

当程序调用函数时，程序控制将转移到被调用的方法。

被调用的方法执行已定义的任务，当执行其返回语句或达到其函数结束右括号时，它将程序控制返回给主程序。

要调用方法，只需要传递必需的参数和方法名称，如果方法返回值，则可以存储返回的值。例如 -

 1 #import <Foundation/Foundation.h>
 2 
 3 @interface SampleClass:NSObject
 4 /* 方法声明 */
 5 - (int)max:(int)num1 andNum2:(int)num2;
 6 @end
 7 
 8 @implementation SampleClass
 9 
10 /* 返回两个数的最大值 */
11 - (int)max:(int)num1 andNum2:(int)num2 {
12 
13    /* 声明局部变量 */
14    int result;
15 
16    if (num1 > num2) {
17       result = num1;
18    } else {
19       result = num2;
20    }
21 
22    return result; 
23 }
24 
25 @end
26 
27 int main () {
28 
29    /* 定义局部变量 */
30    int a = 119;
31    int b = 199;
32    int ret;
33 
34    SampleClass *sampleClass = [[SampleClass alloc]init];
35 
36    /* 调用方法来获取最大值 */
37    ret = [sampleClass max:a andNum2:b];
38 
39    NSLog(@"Max value is : %d
", ret );
40    return 0;
41 }

执行上面示例代码，得到以下结果：

2018-11-15 01:18:49.962 main[43680] Max value is : 199

4. 函数参数

这些变量称为函数的形式参数。形式参数的行为与函数内部的其他局部变量相似，并在进入函数时创建，并在退出时销毁。
在调用函数时，有两种方法可以将参数传递给函数 -

编号	调用类型	描述
1	按值调用	此方法将参数的实际值复制到函数的形式参数中。在这种情况中，对函数内部参数所做的更改不会对参数产生影响。
2	按引用调用	此方法将参数的地址复制到形式参数中。在函数内部，该地址用于访问调用中使用的实际参数。对参数所做的更改会影响参数。

默认情况下，Objective-C使用按值调用来传递参数。所以函数内的代码改变用于调用函数的参数不会反应到函数外部，而上述示例在调用max()函数时使用相同的方法。

4.1 按值调用

将参数传递给函数的按值调用方法是将参数的实际值复制到函数的形式参数中。在这种情况下，对函数内部参数所做的更改不会对参数产生影响。

默认情况下，Objective-C编程语言使用按值调用方法来传递参数。通常，这意味着函数内的代码不能改变用于调用函数的参数。考虑函数swap()定义如下 -

 1 /* 定义用于交换值的函数 */
 2 - (void)swap:(int)num1 andNum2:(int)num2 {
 3    int temp;
 4 
 5    temp = num1;   /* 保存num1的值 */
 6    num1 = num2;   /* 将num2的值放入到num1 */
 7    num2 = temp;   /* 将temp的值放入到num2 */
 8 
 9    return;
10 }

现在，通过传递实际值来调用函数swap()，如下例所示 -

 1 #import <Foundation/Foundation.h>
 2 
 3 @interface SampleClass:NSObject
 4 /* 方法声明 */
 5 - (void)swap:(int)num1 andNum2:(int)num2;
 6 @end
 7 
 8 @implementation SampleClass
 9 
10 - (void)swap:(int)num1 andNum2:(int)num2 {
11    int temp;
12 
13    temp = num1;   /* 保存num1的值到temp */
14    num1 = num2;   /* 将 num2 的值保存到 num1 */
15    num2 = temp;   /* 将 temp 的值保存到 num2 */
16 
17 }
18 
19 @end
20 
21 int main () {
22 
23    /* 局变变量 */
24    int a = 100;
25    int b = 200;
26 
27    SampleClass *sampleClass = [[SampleClass alloc]init];
28 
29    NSLog(@"Before swap, value of a : %d
", a );
30    NSLog(@"Before swap, value of b : %d
", b );
31 
32    /* 调用函数用来交换值 */
33    [sampleClass swap:a andNum2:b];
34 
35    NSLog(@"After swap, value of a : %d
", a );
36    NSLog(@"After swap, value of b : %d
", b );
37 
38    return 0;
39 }

执行上面示例代码，得到以下结果：

1 2018-11-15 01:31:40.328 main[143345] Before swap, value of a : 100
2 2018-11-15 01:31:40.330 main[143345] Before swap, value of b : 200
3 2018-11-15 01:31:40.330 main[143345] After swap, value of a : 100
4 2018-11-15 01:31:40.330 main[143345] After swap, value of b : 200

4.2 按引用调用

将参数传递给函数的引用调用方法是将参数的地址复制到形式参数中。在函数内部，该地址用于访问调用中使用的实际参数。这意味着对参数所做的更改会影响传递参数的值。

要通过引用传递值，参数指针将像任何其他值一样传递给函数。因此，需要将函数参数声明为指针类型，如以下函数swap()中所示，该函数swap()的参数指向两个整数变量的值。

 1 /* 定义一个用来交换两个参数值的函数 */
 2 - (void)swap:(int *)num1 andNum2:(int *)num2 {
 3    int temp;
 4 
 5    temp = *num1;  /* 保存 num1 的值到 temp  */
 6    *num1 = *num2; /* 将 num2 的值分配给 num1 */
 7    *num2 = temp;  /* 将 temp 的值分配给 num2 */
 8 
 9    return;
10 }

要查看有关Objective-指针的更多详细信息，可以查看Objective-C指针章节。

现在，通过引用传递值来调用函数swap()，如下例所示 -

 1 #import <Foundation/Foundation.h>
 2 
 3 @interface SampleClass:NSObject
 4 /* 方法声明 */
 5 - (void)swap:(int *)num1 andNum2:(int *)num2;
 6 @end
 7 
 8 @implementation SampleClass
 9 
10 - (void)swap:(int *)num1 andNum2:(int *)num2 {
11    int temp;
12 
13    temp = *num1;  /* 保存 num1 的值到 temp  */
14    *num1 = *num2; /* 将 num2 的值分配给 num1 */
15    *num2 = temp;  /* 将 temp 的值分配给 num2 */
16 
17    return;
18 
19 }
20 
21 @end
22 
23 int main () {
24 
25    /* 局部变量声明 */
26    int a = 100;
27    int b = 200;
28 
29    SampleClass *sampleClass = [[SampleClass alloc]init];
30 
31    NSLog(@"Before swap, value of a : %d
", a );
32    NSLog(@"Before swap, value of b : %d
", b );
33 
34    /* 调用函数来交换参数的值 */
35    [sampleClass swap:&a andNum2:&b];
36 
37    NSLog(@"After swap, value of a : %d
", a );
38    NSLog(@"After swap, value of b : %d
", b );
39 
40    return 0;
41 }

执行上面示例代码，得到以下结果：

1 2018-11-15 01:38:32.473 main[137544] Before swap, value of a : 100
2 2018-11-15 01:38:32.475 main[137544] Before swap, value of b : 200
3 2018-11-15 01:38:32.475 main[137544] After swap, value of a : 200
4 2018-11-15 01:38:32.475 main[137544] After swap, value of b : 100

从上面输出的结果中可以看到，参数值的变化已经反映在函数之外，它不像按值调用那样，函数内的参数值变化不会反映在函数之外。