嵌入式学习第九天

桮酒

已于 2024-01-25 18:21:24 修改

阅读量1.2k

点赞数 41

文章标签：学习 c语言嵌入式硬件

于 2024-01-24 19:10:39 首次发布

本文链接：https://blog.csdn.net/m0_75240018/article/details/135829099

版权

本文详细介绍了C语言中的函数定义、调用、不同类型的变量作用域和生存周期，包括自动、寄存器、外部和静态变量，以及递归函数的概念和注意事项。通过斐波那契数列和汉诺塔示例展示函数的运用，并探讨了传参方式和数组传递。最后提供了冒泡排序、数字每一位求和和素数判断的函数实现。

摘要由CSDN通过智能技术生成

1.函数定义：
函数类型函数名(数据类型1 形参1, 数据类型2 形参2, ...)
{
函数体;

return 返回值;
}

2.函数的调用
函数名(实参1, 实参2, ...);

3.函数的声明

4.变量作用域和生存周期:
1.作用域:
变量能够使用的范围

变量作用域默认为离定义该变量最近的大括号内

局部变量:变量作用域在某个大括号范围内
全局变量:变量作用域在整个文件中
全局变量都在所有函数的外面定义

2.生存周期:
变量从空间被开辟到被回收的整个过程称为生存周期

存储类型数据类型变量名;

1.auto(默认)
自动型变量、局部变量

将变量存放在栈区:
1.未经初始化值为随机值
2.执行到变量定义时开辟空间
3.执行到超过变量作用域范围回收变量空间

2.register
寄存器变量

寄存器存满了，会将变量存放到栈区（等价于auto类型）

3.extern
外部变量
extern int a;

声明一个变量为外部存储的变量

4.static
静态变量

将变量存放在数据区中:
1.未经初始化值为0值
2.编译时开辟空间,程序运行时加载该空间
3.程序结束时回收空间

static作用:
1.将变量定义为静态变量
2.可以将变量的作用域限定到本文件中
3.可以防止多文件全局变量名冲突

5.递归函数:
函数定义时调用函数本身
1.递归一定要有结束条件
2.避免深层次的递归

练习:从终端输入一个n,封装函数获得斐波那契数列第n项的值
1 1 2 3 5 8 13 21 34 55 ...

  1 #include <stdio.h>                                                                                                                                                                                                                                                
  2 
  3 int feibonaqie(int a)
  4 {
  5     int ret = 0;
  6 
  7     if( a == 1 || a == 2 )
  8     {
  9         return 1;
 10     }
 11     else
 12     {
 13     ret = feibonaqie(a-1) + feibonaqie(a - 2);
 14     }
 15     return ret;
 16 
 17 }
 18 
 19 int main(void)
 20 {
 21     int n = 0;
 22     int s = 0;
 23 
 24     scanf("%d",&n);
 25 
 26     s = feibonaqie(n);
 27 
 28     printf("%d\n",s);
 29     return 0;
 30 }

练习：汉诺塔

  1 #include <stdio.h>
  2 
  3 int hannuota(int n,char a,char b,char c)
  4 {
  5     if (n == 1)                                                                                                                                                                                                                                                   
  6     {
  7     printf("%c -> %c\n",a ,c);
  8     }
  9     else
 10     {
 11     hannuota(n - 1,a,c,b);
 12     printf("%c -> %c\n",a ,c);
 13     hannuota(n-1,b,a,c);
 14     }
 15     return 0;
 16 }
 17 
 18 int main(void)
 19 {
 20     int sum = 0;
 21 
 22     scanf("%d",&sum);
 23 
 24     hannuota(sum,'A','B','C');
 25 
 26     return 0;
 27 }

6.函数的传参:
1.赋值传递(复制传递)
实参将值拷贝一份给形参,形参是实参的副本,形参的值发生改变不会影响实参

函数体内部想使用函数体外部变量值的时候使用复制传递

2.全局变量传递

7.数组传递:
int a[5];
1.形式一:
int Fun(int array[5]);

2.形式二:
int Fun(int array[], int len);

注意:
数组传递时,函数体内部形参操作的数组和实参操作的数组为同一数组

作业:
1.封装冒泡排序函数
2.封装一个函数实现获得一个数字每位数上的和值
12345

3.封装一个函数判断给定的数字是否为素数

 1 #include <stdio.h>                                                                                                                                                                                                                                                
  2 
  3 int InPutArray(int array[], int len)
  4 {
  5     int i = 0;
  6     for (i = 0;i < len;i++)
  7     {
  8         scanf("%d",&array[i]);
  9     }
 10 
 11     return 0;
 12 }
 13 
 14 int SortArray(int array[],int len)
 15 {
 16     int i = 0;
 17     int j = 0;
 18     int tmp = 0;
 19 
 20     for (j = 0 ; j < len-1 ; j++ )
 21     {
 22         for ( i = 0 ; i < len - 1 - j ; i++ )
 23         {
 24             if (array[i] > array[i + 1])
 25             {
 26                 tmp = array[i];
 27                 array[i] = array[i + 1];
 28                 array[i + 1] = tmp;
 29             }
 30         }
 31     }
 32 
 33     return 0;
 34 }
 35 
 36 int OutPutArray(int array[], int len)
 37 {
 38     int i = 0;
 39     for ( i = 0 ; i < len ; i++ )
 40     {
 41         printf("%d ",array[i]);
 42     }
 43 
 44     printf("\n");
 45 
 46     return 0;
 47 }

 1 #include <stdio.h>
  2 
  3 int QiuHe(int num)
  4 {
  5     int sum = 0;
  6     int n = 0;
  7 
  8     while (num != 0)                                                                                                                                                                                                                                              
  9     {
 10         n = num % 10;
 11         sum += n;
 12         num = num / 10;
 13     }
 14 
 15     return sum;
 16 }
 17 
 18 int main(void)
 19 {
 20     int a = 0;
 21     int ret = 0;
 22 
 23     scanf("%d",&a);
 24 
 25     ret = QiuHe(a);
 26 
 27     printf("ret = %d\n",ret);
 28 
 29 
 30 
 31     return 0;
 32 }

  1 #include <stdio.h>                                                                                                                                                                                                                                                
  2 
  3 int SuShu(int a)
  4 {
  5     int i = 1;
  6     int cnt = 0;
  7 
  8     while (i < a)
  9     {
 10         if (0 == a % i )
 11         {
 12             cnt++;
 13         }
 14         i++;
 15     }
 16     if (cnt == 1)
 17     {
 18         return 1;
 19     }
 20     else
 21     {
 22         return 0;
 23     }
 24 }
 25 
 26 int main(void)
 27 {
 28     int num = 0;
 29     int ret = 0;
 30 
 31     scanf("%d",&num);
 32 
 33     ret = SuShu(num);
 34 
 35     printf("ret = %d\n",ret);
 36 
 37     return 0;
 38 }

桮酒

关注

41
点赞
踩
20

收藏

觉得还不错? 一键收藏
1
评论
嵌入式学习第九天

实参将值拷贝一份给形参,形参是实参的副本,形参的值发生改变不会影响实参。数组传递时,函数体内部形参操作的数组和实参操作的数组为同一数组。2.编译时开辟空间,程序运行时加载该空间。2.可以将变量的作用域限定到本文件中。函数体内部想使用函数体外部变量值的时候使用复制传递。3.执行到超过变量作用域范围回收变量空间。变量从空间被开辟到被回收的整个过程称为生存周期。变量作用域默认为离定义该变量最近的大括号内。2.执行到变量定义时开辟空间。声明一个变量为外部存储的变量。全局变量:变量作用域在整个文件中。
复制链接

扫一扫