• C中的基本函数

    1函数是是什么

        1.1维基百科中对函数的定义：子程序

       在计算机科学中，子程序是一个大型程序中的某部分代码，由一个或多个语句块组成，他负责完成某项特定任务，而且相较于其他代码，具备相对的独立性。

       一般会有输入参数并有返回值，提供对过程的封装和细节的隐藏，这些代码通常被集成为软件库。

       c语言中把常用的功能，进行了封装，封装成一个个的函数，提供出来大家都可以使用。

    比如：scanf,printf,strlen,strcmp,rand,srand,time

        c语言并不直接去实现库函数，而是提供了c语言的标准和库函数的约定

    2库函数

        为什么有库函数？

         1我们知道在我们学习c语言编程的时候，总是在一个代码编写完成之后迫不及待的想知道结果，想把这个结果打印到我们屏幕上，这个时候我们就会使用printf

        2在编程的过程中我们会频繁的做一些字符串的拷贝工作（strcpy）

        3在编程是我们也会计算，总是会计算n的k次方这样的运算（pow）

    常用的库函数由：IO函数，字符串操作函数，字符操作函数，内存操作函数，时间/日期函数，数学函数，其他库函数  （scanf,printf,getchar,putchar,strlen,strcmp,islower,memset,time,sqrt,pow）

    3自定义函数

    1. //函数的组成：
    2. // ret_type fun_name(para1,*)
    3. // {
    4. //     statement;//语句项
    5. // }
    6. // ret_type 返回类型
    7. // fun_name 函数名
    8. // para1 函数参数
    9.  
    10.  
    11.  
    12. //自定义函数和库函数一样： 函数名，函数参数，返回类型
    13. //写一个函数可以找出两个整数中的最大值
    14. int main()
    15. {
    16.     int a = 0;
    17.     int b = 0;
    18.     //输入
    19.     scanf("%d %d",&a,&b);
    20.     //计算
    21.     int m = (a > b ? a : b);
    22.     //输出
    23.     printf("较大值是：%d\n",m);
    24.  
    25.     return 0;
    26. }
    27.  
    28. //自定义函数和库函数一样： 函数名，函数参数，返回类型
    29. //写一个函数可以找出两个整数中的最大值
    30. int  get_max(int x, int y)
    31. {
    32.     int z = (x > y ? x : y);
    33.     return z;
    34. }
    35. int main()
    36. {
    37.     int a = 0;
    38.     int b = 0;
    39.     //输入
    40.     scanf("%d %d",&a,&b);
    41.     //计算
    42.     //int m = (a > b ? a : b);
    43.     //使用函数来完成
    44.     int m = get_max(a,b);
    45.     //输出
    46.     printf("较大值是：%d\n",m);
    47.  
    48.     return 0;
    49. }
    50.  
    51. //形式参数 -形参
    52. // void Swap(int x,int y)
    53. // {
    54. //     int tmp = x;
    55. //     x = y;
    56. //     y = tmp;
    57. // }
    58. // int main()
    59. // {
    60. //     int a = 0;
    61. //     int b = 0;
    62. //     scanf("%d %d",&a,&b);
    63. //     printf("交换前:a=%d b=%d\n",a,b);
    64. //     //实际参数 - 实参
    65. //     //当实参传递给行参的时候
    66. //     //行参是实参的一份临时拷贝
    67. //     //使用对行参对修改不会影响实参
    68. //     Swap(a,b);
    69. //     printf("交换后:a=%d b=%d\n",a,b);
    70. //     return 0;
    71. // }
    72.  
    73. // int main()
    74. // {
    75. //     int num = 10;
    76. //     int* p = #
    77.  
    78. //     *p = 20;
    79. //     printf("%d\n",num);
    80.  
    81. //     return 0;
    82. // }
    83.  
    84. //形式参数 -形参
    85. void Swap(int *px,int *py)
    86. {
    87.     int tmp = *px;
    88.     *px = *py;
    89.     *py = tmp;
    90. }
    91. int main()
    92. {
    93.     int a = 0;
    94.     int b = 0;
    95.     scanf("%d %d",&a,&b);
    96.     printf("交换前:a=%d b=%d\n",a,b);
    97.     //实际参数 - 实参
    98.     //当实参传递给行参的时候
    99.     //行参是实参的一份临时拷贝
    100.     //使用对行参对修改不会影响实参
    101.     Swap(&a,&b);
    102.     printf("交换后:a=%d b=%d\n",a,b);
    103.     return 0;
    104. }

    4函数参数

        实际参数（实参）

        实参可以是：常量、变量、表达式、函数等；

        无论实参是何种类型的量，在进行函数调用时，他们都必须有确定的值，以便把这些值传送给行参。

        形式参数（形参）

        形式参数是指函数数名后括号中的变量，因为形式参数只有在函数被调用的过程中才实例化（分配内存单元），所以叫形式参数。形式参数当函数调用完成后呀自动销毁，因此形式参数只在函数中有效。

    5函数调用

    1. //写一个数，判断这个数是不是素数
    2. //是素数返回1
    3. //不说素数返回0
    4. //2~sqrt(n)
    5.  
    6. //判断素数
    7. int is_prime(int n)
    8. {
    9.     int j = 0;
    10.     for ( j = 2;j<=sqrt(n);j++) //sqrt需要使用math.h函数库
    11.     {
    12.         if(n % j == 0)
    13.         {
    14.             return 0;
    15.         }
    16.     }
    17.     return 1;
    18. }
    19.  
    20. int main()
    21. {
    22.     int i = 0;
    23.     int count = 0;
    24.     for(i = 100; i <= 200; i++)
    25.     {
    26.         //判断i是否为素数
    27.         if(is_prime(i) == 1)
    28.         {
    29.             printf("%d\n",i);
    30.             count++;
    31.         }
    32.     }
    33. }
    34.  
    35. //写一个函数判断一年是不是闰年
    36. //是润年返回1
    37. //非闰年返回0
    38. int is_leap_year(int y)
    39. {
    40.     // if((y%4==0)&&(y%100!=0) || (y%400 == 0))
    41.     // {
    42.     //     return 1;
    43.     // } else
    44.     // {
    45.     //     return 0;
    46.     // }
    47.     return ((y%4==0)&&(y%100!=0) || (y%400 == 0));
    48. }
    49. int main()
    50. {
    51.     int y = 0;
    52.     int count = 0;
    53.     for(y =1000;y<=2000;y++)
    54.     {
    55.         if (is_leap_year(y) == 1)
    56.         {
    57.             printf("%d\n",y);
    58.             count++;
    59.         }
    60.         
    61.     }
    62.     printf("\ncount = %d\n",count);
    63. }
    64.  
    65. //写一个函数，实现一个整形有序数组的二分查找
    66.  
    67. int binary_search(int arr[], int k, int sz)
    68. {
    69.     int left = 0;
    70.     int right = sz -1;
    71.     while(left <= right)
    72.     {
    73.         //int mid = (left+right)/2;
    74.         int mid = left + (right -left)/2;
    75.         if (arr[mid] < k)
    76.         {
    77.             left = mid + 1;
    78.         } else if(arr[mid] > k)
    79.         {
    80.             right = mid -1;
    81.         } else
    82.         {
    83.             return mid;
    84.         }
    85.     }
    86.     
    87. }
    88.  
    89. int main()
    90. {
    91.     int arr[] = {1,2,3,4,5,6,7,8,9,10};
    92.     int k = 5;
    93.     int sz = sizeof(arr) / sizeof(arr[0]);
    94.     //二分查找
    95.     //找到了返回下标
    96.     //找不到：返回-1
    97.     int ret = binary_search(arr,k,sz);
    98.     if (ret == 1)
    99.     {
    100.         printf("找不到\n");
    101.     } else
    102.     {
    103.         printf("找到了，下标是:%d\n",ret);
    104.     }
    105.  
    106.     return 0;
    107. }
    108.  
    109. void test(int* p)
    110. {
    111.     (*p)++;
    112. }
    113.  
    114. int main()
    115. {
    116.     int num = 0;
    117.     //调用函数，num增加1
    118.     test(&num);
    119.     test(&num);
    120.  
    121.     printf("%d\n",num);
    122.  
    123.     return 0;
    124.  
    125. }

    6函数的嵌套调用和链式访问

    1. //链式访问
    2. // int main()
    3. // {
    4. //     // int len = strlen("abcdef");
    5. //     // printf("%d\n",len);
    6.  
    7. //     printf("%d\n",strlen("abcdef"));
    8. //     return 0;
    9. // }
    10.  
    11. int main()
    12. {
    13.     printf("%d ",printf("%d ",printf("%d ",43)));// 43 3 2  多个空格就多个字符
    14.  
    15.     return 0;
    16. }

    7函数的声明和定义

        函数的声明一般出现在函数的使用之前，要满足先声明后使用

        函数的声明一般要放在头文件中

    函数的定义：放在源文件中

    使用：

    1. //函数的声明和定义通常不是这样使用的
    2. //函数的声明说放在头文件中的
    3.  
    4. //#include "add.h"
    5. //.lib -静态库
    6. //导入静态库
    7. //#pragma comment(lib,"add.lib");
    8. // int main()
    9. // {
    10. //     int a = 0;
    11. //     int b = 0;
    12. //     //输入å
    13. //     scanf("%d %d",&a,&b);
    14. //     //加法
    15. //     int c = Add(a,b);  //函数调用
    16.  
    17. //     printf("%d\n",c);
    18. // }

    8函数递归

        什么是递归？程序调用自身的编程技巧称为递归 ，函数自己调用了自己

    递归作为一种算法在程序设计语言中广泛应用，一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，他通常吧一个大型复杂的问题层层转化为一个原问题相似的规模较小的问题来求解，递归策略只需要少量的程序就可描述出解题过程所需呀的多次重复计算，大大减少了程序的代码量。

    递归的主要思考方式在于：把大事化小 

    递归的两个必要条件：1存在限制条件，当满足这个限制条件的时候，递归便不再继续  2每次递归调用之后越来越接近这个限制条件

    1. //求字符串的长度
    2.  
    3. // int my_strlen(char* s)
    4. // {
    5. //     int count = 0;
    6. //     while(*s != '\0')
    7. //     {
    8. //         count++;
    9. //         s++;
    10. //     }
    11.  
    12. //     return count;
    13. // }
    14.  
    15. int my_strlen(char* s)
    16. {
    17.     if(*s == '\0')
    18.     {
    19.         return 0;
    20.     } else
    21.     {
    22.         return 1 + my_strlen(s + 1);
    23.     }
    24. }
    25. int main()
    26. {
    27.     char arr[] = "abc";//[a b c \0]
    28.     int len = my_strlen(arr);
    29.     printf("%d\n",len);
    30.     //printf("abcvd");
    31. }

    1. //n! = 1*2*3*4*...*n
    2. //循环（迭代）
    3. // int Fac(int n)
    4. // {
    5. //     int r = 1;
    6. //     int i = 0;
    7. //     for(i=1;i<=n;i++)
    8. //     {
    9. //         r = r*i;
    10. //     }
    11.  
    12. //     return r;
    13. // }
    14.  
    15. //求阶乘
    16. // int Fac(int n)
    17. // {
    18. //     if (n <= 1)
    19. //     {
    20. //         return 1;
    21. //     } else
    22. //     {
    23. //         return n*Fac(n-1);//10 * 9 * 8....*1
    24. //     }
    25. // }
    26. // int main()
    27. // {
    28. //     int n = 0;
    29. //     scanf("%d",&n);
    30.  
    31. //     int ret = Fac(n);
    32. //     printf("%d\n",ret);
    33. // }
    34.  
    35. //求第n个斐波那契数
    36. //1 1 2 3 5 8 13 21 34 55 ....
    37. //前2个数的和是第三个数
    38. //递归方法可能会溢出
    39. // int Fib(int n)
    40. // {
    41. //     if (n <= 2)
    42. //     {
    43. //         return 1;
    44. //     } else 
    45. //     {
    46. //         return Fib(n -1) + Fib(n-2);
    47. //     }
    48.     
    49. // }
    50.  
    51. int Fib(int n)
    52. {
    53.     int a = 1;
    54.     int b = 1;
    55.     int c = 0;
    56.  
    57.     while( n >= 3)
    58.     {
    59.         c = a+b;
    60.         a = b;
    61.         b = c;
    62.  
    63.         n--;
    64.     }
    65.  
    66.     return c;
    67. }
    68.  
    69. int main()
    70. {
    71.     int n = 0;
    72.     scanf("%d",&n);
    73.     int ret = Fib(n);
    74.     printf("%d\n",ret);
    75. }

  • 相关阅读:
    Redux基础必知必会 reducer拆分 中间件 单向数据流
    py5_重要的缩进以及初识 Python 函数
    Git:代码回溯，分布式版本控制，团队协同开发，远程备份
    如何在Sage X3 ERP中使用集装箱管理和物流跟踪
    Spring Cloud Nacos实现动态配置加载的源码分析
    SRS Config 二 Stream Caster
    10 个适用于 Windows 的最佳 PDF 编辑器，用于轻松编辑 PDF 文件
    硬核!最全Java面试宝典+Java核心知识集一箭双雕杠秋招
    第一章 网络类型和数据链路层协议
    SQL INSERT INTO SELECT 语句
  • 原文地址：https://blog.csdn.net/qq_61658398/article/details/132699587