C语言回顾 六 函数

一、函数的定义
函数定义的四种形式
函数是实现某一个功能的代码段
注意： 返回值   参数
1.第一种 无参无返回值
void printHello() //小括号不能丢
{
    printf("大家好！\n");
    return;// 作用2 提前返回到主调函数（或者提前结束函数的调用）
    printf("我呢？ \n");
}
2.第二种 无参有返回值
int numberOne()
{   //return 将结果返回
    //返回的值的类型要与返回值类型保持一致（不然结果可能不准确）
    //注意；return 后面的代码不在执行
    //注意：
    return 10;
}
3.第三种 有参无返回值 （参数可以没有也可以是多个，有参的至少有一个），调用的时候参数需要一一赋值
void maxValue1(int a, int b)
{   int max = a > b ? a : b;
    printf("%d和%d的最大值是%d\n", a,b,max);
}
4.第四种 有参有返回值
int maxValue2(int a, int b)
{
    return a > b ? a : b;
}
函数的声明 （同文件中的函数声明，不是一定要写，但是要求大家都写）；
//完整函数步骤1.函数声明 类型 函数名（参数列表）；
int maxValue2(int a, int b);//分号不要丢
//完整函数步骤2.函数定义 类型 函数名（参数列表）{语句}
//完整函数步骤3.函数的调用
//5.编写函数int sumValue(int n)：计算1到n的和。
int sumValue(int n);//函数的声明
int sumValue(int n) //函数的定义
{    printf("请输入一个数：");
    scanf("%d",&n);
    int sum = 0;
    for (int i = 1; i <= n; i++) {
        sum = sum + i;
        
    }return sum;
}
6.编写函数 void dayOfYear(year, mouth,day),使得函数返回由这三个参数确定的那⼀一天是⼀一年中的第⼏几天。
    void dayofYear(int year, int month, int day);//函数的声明
    void dayofYear(int year, int month, int day)//函数的定义
{   int yearrun = 0;
    if (year%400 == 0 || (0 == year % 4 && 0 != year %100)) {
        yearrun = 1;
    }
        int dayCount = 0;
        switch (month - 1) {
            case 11:
                dayCount += 30;
            case 10:
                dayCount += 31;
            case 9:
                dayCount += 30;
            case 8:
                dayCount += 31;
            case 7:
                dayCount += 31;
            case 6:
                dayCount += 30;
            case 5:
                dayCount += 31;
            case 4:
                dayCount += 30;
            case 3:
                dayCount += 31;
            case 2:
                dayCount += 29 + yearrun;
            case 1:
                dayCount += 31;
            case 0:
                dayCount += day;
            default:
                break;
        }printf("%d",dayCount);
}
7.编写函数，返回三个整数的中间数
int midNumber(int a,int b,int c);
int midNumber(int a,int b,int c)
{   int max = 0;
    max = a > b ? a : b;
    max = max > c ? max : c;
    int min = 0;
    min = a < b ? a : b;
    min = min < c ? min : c;
    int sum = a + b + c;
    int mid = 0;
    mid = sum - max - min;
    printf("%d",mid);
    return mid;
}
8.编写函数，返回正整数n中的数字的个数。
int number(int n);
int number(int n)
{
    int a = 0;
    while (n != 0) {
        n /= 10;
        a++;
    }
    return a;
}



int main(int argc, const char * argv[])
    { 
     
1.函数调用 ：函数名 （参数值列表）
         printHello();
         
2、有返回值无参的函数的调用
         printf("%d \n",numberOne());//直接打印
         int num = numberOne();      //接收返回值再操作
         num++;
         printf("%d \n",num);
         
3、有参无返回值函数的调用
         int a1 = 5, a2 = 20;
         maxValue1(a1, a2); //
4、有参有返回值的函数调用
         int a3 = 34, a4 = 20;
         int maxValue = maxValue2(a3, a4);
         maxValue += 10;
         printf("%d \n",maxValue);
5.编写函数int sumValue(int n)：计算1到n的和。
         int a =0;
         printf("%d \n",sumValue(a)); //函数的调用
/6.编写函数 void dayOfYear(year, mouth,day),使得函数返回由这三个参数确定的那⼀一天是⼀一年中的第⼏几天
        dayofYear(2013, 4, 5); //函数的调用
7.编写函数，返回三个整数的中间数
        midNumber(5, 7, 2);
8.编写函数，返回正整数n中的数字的个数。
        int a = 56236778;
        printf("%d",number(a));
 
      return 0;
    }




operator.h文件里写函数声明
//这里面是接口文件（需要把函数的声明放到.h这个文件里）

//1.1声明*****求两个数的和
int addValue(int a, int b);
//2.1声明*****求两个数的差
int redValue(int a, int b);
//3.1声明*****求两个数的积
int accValue(int a, int b);
//4.1声明*****求两个数的商
int conValue(int a, int b);
//数组作为参数 形参是 类型 数组名[] 的形式，元素个数根据实参的的数组个数确定
//注意: 数组作为参数，还要把数组的元素个数作为参数
//打印任意一个数组的元素，打印所有值，没有返回值
void printfArr(int arr[], int count);
//找一个数组中的最大值，并返回
int maxofArray(int array[], int count);
//对一个数组进行排序
void rankofArray(int array[],int count);
//练习三
//两个数中最大值
int maxofTwo(int a, int b);
//三个数中的最大值
int maxofThree(int a, int b, int c);
//四个数中的最大值
int maxofFour(int a, int b, int c, int d);
//五个数中的最大值
int maxofFive(int a, int b, int c, int d,int e);
/*计算s = (1*1)! + (2*)! + (3*3)! */
//1.整型数的平方
int pingFang(int a);
//2.一个整型数的阶乘
int jiCheng(int i);
void sumJJ(int a);
int jieCheng2(int n);

operator.m文件里写函数定义
#import "operator.h"
#import <Foundation/Foundation.h>
//这是文件的实现部分，（我们需要把函数的定义写在这文件里面）
//1.2定义*****求两个数的和
int addValue(int a, int b)
{ return a + b;  }
//2.2定义*****求两个数的差
int redValue(int a, int b)
{ return a - b; }
//3.2定义*****求两个数的积
int accValue(int a, int b)
{ return a * b; }
//4.2定义*****求两个数的商
int conValue(int a, int b)
{
    while (b == 0) {
        break;
    }
    return a / b;
}
//打印数组
void printfArr(int arr[], int count)
{
    for (int i = 0; i < count; i++) {
        printf("%d ",arr[i]);
    }printf("\n");
}
//找一个数组中的最大值，并返回
int maxofArray(int array[], int count)
{   int max = 0;
    for (int i = 0; i < count; i++) {
        max = max > array[i] ? max : array[i];
    }return max;
}



//对一个数组进行排序
void rankofArray(int array[],int count)
{
    for (int i = 0; i < count - 1; i++) {
        for (int j = 0; j < count - 1 - i; j++) {
            if (array[j] > array[j + 1]) {
                int temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
                
            }
        }
    }
}

//练习三

//两个数中最大值
int maxofTwo(int a, int b)
{
    int max = a > b ? a : b;
    return max;
}
//三个数中的最大值
int maxofThree(int a, int b, int c)
{
    return maxofTwo(maxofTwo(a, b), c);;
}
//四个数中的最大值
int maxofFour(int a, int b, int c, int d)
{
    return maxofTwo(maxofThree(a, b, c), d);;
}
//五个数中的最大值
int maxofFive(int a, int b, int c, int d,int e)
{
    return maxofTwo(maxofFour(a, b, c, d), e);
}

/*计算s = (1*1)! + (2*)! + (3*3)! */
 //1.整型数的平方
 int pingFang(int a)
{
    return a*a;
}
 //2.一个整型数的阶乘
int jiCheng(int i)
{
    int j = 1;
    
    for (; i >= 1; i--) {
        j *= i;
    }
    return j;
}
 void sumJJ(int a)
{ int sum = 0;
    for (int i = 1; i <= a; i++) {
        sum += jiCheng(pingFang(i));
    }
    printf("%d ",sum);
}
//一个 整型数 的阶乘（递归调用）
int jieCheng2(int n)
{
    //递归调用一定要有出口4*3*2*1
    if (n == 0) {
        return 1;
    }
    return n* jieCheng2(n - 1);
}
//4 * (3 * (2 * (1)))