20201022-成信大-C语言程序设计-补充内容-功能封装与调用，以最大值为例

知识点导读

• 宏定义常量
• 定定义函数
• 条件语句与条件运算符
• 普通函数【返回值，名，形参表】
• 函数功能复用
• 数组作为函数的参数
• 数组与循环的结合处理
• 数组的形参表达形态

#include <stdio.h>
// 宏定义常量
#define N 10
// 宏定义函数，注意括号，整体替换
#define MUL1(a, b) (a) * (b)
#define MUL2(a, b) a *b
#define MAX(a, b) a > b ? a : b
#define MIN(a, b) a > b ? b : a

/* 
    求两个数的最大值
        1. 注意常见的写法和形式
        2. 条件表达式
        3. 条件运算符的应用
        4. 返回值的使用，要确保可以返回 
 */
int getMax2(int x, int y);
int getMax3(int x, int y);
int getMax4(int x, int y);
int getMax5(int x, int y);

/* 
    复用两个数的最大值，求3个数的最大值
    复用两个数的最大值，求4个数的最大值
 */
int get3Max(int x, int y, int z);
int get4Max(int w, int x, int y, int z);

/* 
    求一个数组n个数的最大值
        1. 数组的表示方式，形参和实参的不同
        2. 数组不可以整体操作，只能操作元素，故要给入一个数组的有效长度，即元素个数
        3. 打擂算法，最终一定可以找出最大/最小值
        4. 多种形式时，注意，不可以做越界的访问
            A 数组下标法定位元素
            B 指针偏移法定位元素
            C 指针变量移动法定位元素
 */
int getNMax1(int a[], int n);
int getNMax2(int *a, int n);
int getNMax3(int *a, int n);

/* 
    主调函数
    1. 驱动
    2. 测试
    3. 产生命令行
 */
int main(int argc, char const *argv[])
{
    
    
    int arr[N] = {
    
    11, 33, 55, 22, 44, 99, 88, 77, 65, 56};
    // 测试 两个数取最大值
    printf("max is %d\n", getMax2(arr[0], arr[1]));
    printf("max is %d\n", getMax3(arr[2], arr[3]));
    printf("max is %d\n", getMax4(arr[4], arr[5]));
    printf("max is %d\n", getMax5(arr[6], arr[7]));

    // 测试 3个数取最大值
    printf("max is %d\n", get3Max(arr[0], arr[1], arr[2]));
    // 测试 4个数取最大值
    printf("max is %d\n", get4Max(arr[0], arr[1], arr[2], arr[3]));

    // 测试 N个数取最大值
    printf("max is %d\n", getNMax1(arr, N));
    printf("max is %d\n", getNMax2(arr, N));
    printf("max is %d\n", getNMax3(arr, N));

    printf("\n");
    return 0;
}

int getMax2(int x, int y)
{
    
    
    return x > y ? x : y;
}
int getMax3(int x, int y)
{
    
    
    if (x > y)
    {
    
    
        return x;
    }
    return y;
}
int getMax4(int x, int y)
{
    
    
    int res = x;
    if (x < y)
    {
    
    
        res = y;
    }
    return res;
}
int getMax5(int x, int y)
{
    
    
    int res;
    if (x > y)
    {
    
    
        res = x;
    }
    else
    {
    
    
        res = y;
    }
    return res;
}

/* 
    功能调用，产生新的功能
 */
int get3Max(int x, int y, int z)
{
    
    
    return getMax2(getMax2(x, y), z);
}
/* 
    功能调用，产生新的功能
 */
int get4Max(int w, int x, int y, int z)
{
    
    
    return getMax2(get3Max(x, y, z), w);
}


/* 
    打擂法搜索最大元素，并返回最大元素
    1. 使用数组下标索引法
    2. 从第0下标开始，打擂搜索，即顺序查找
    3. 数组天然与循环在一起，逐个元素地进行检查
 */
int getNMax1(int a[], int n)
{
    
    
    int i;
    int max = a[0];
    for (i = 1; i < n; i++)
    {
    
    
        if (max < a[i])
        {
    
    
            max = a[i];
        }
    }
    return max;
}
/* 
    打擂法搜索最大元素，并返回最大元素
    1. 使用常指针偏法，数组名即为常指针
    2. 从首地址开始，逐个偏移，打擂搜索，即顺序查找
    3. 数组天然与循环在一起，逐个元素地进行检查
 */
int getNMax2(int *a, int n)
{
    
    
    int i;
    int max = *(a + 0);
    for (i = 1; i < n; i++)
    {
    
    
        if (max < *(a + i))
        {
    
    
            max = *(a + i);
        }
    }
    return max;
}
/* 
    打擂法搜索最大元素，并返回最大元素
    1. 使用指针变量移动，额外定义指定变量，用于移动，注意，数组名【常指针】不可以移动
    2. 从首个元素的地址开始，打擂搜索，即顺序查找
    3. 数组天然与循环在一起，逐个元素地进行检查
    4. 注意，不可以越界，基准点即首地址不可以变更，建议直接使用数组名
    5. 值操作与指针操作要区别开
    6. 这个样操作，效率很高，性能很好
 */
int getNMax3(int *a, int n)
{
    
    
    int max;
    int *p;
    p = a;
    max = *p;   // 首地址元素
    while(p++<a+n)  // 移动指针，遍历每一个元素，注意，不要越界
    {
    
    
      if (max < *p)
        {
    
    
            max = *p;
        }
    }
    return max;
}

数组作为函数形参的两种形态

• 数组方式
• 指针方式

数组作为实参使用的形态

• 数组索引方式
• 数组名指针偏移方式
• 指针变量移动方式

取值与取址

• 可以直接使用a[i]方式操作数组元素
• 可以直接使用*(a+i)方式操作数组元素
• 当p指针指向数组名后，可以移动*(p++)即可实现元素遍历，但要注意，不可以越界操作