C语言初阶——函数第一节课代码练习-CSDN博客

本文链接：https://blog.csdn.net/2302_76415010/article/details/139613947

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>

库函数

strcpy的用法：、

将一个字符串拷贝至另一个字符串中。
如：拷贝“hello bit”

#include<string.h>//strcpy函数的头文件
int main()
{
char arr1[20] = { 0 };//容量为20的空字符串
char arr2[] = "hello bit";

   strcpy(arr1,arr2);//写法一：
                   //即(char *destination, const char * source);。
                   //其中，char *destination与char * source都是指针。
   char* ret = strcpy(arr1, arr2);//写法二：
                               //strcpy的返回类型：char*。
                               //当strcpy把源字符串内容拷贝到目标字符串中时，它会把目标字符串的地址返回来。
                               //故，这里便可以用char*指针来接收它的返回类型。
   //不能这样写：char* strcpy(char* arr1, const char* arr2);或char* strcpy(char* arr1, char* arr2);
   printf("%s\n", arr1);
   printf("%s\n", ret);

   return 0;
}

训练：

#include<string.h>
int main()
{
char arr1[20] = { 0 };
char arr2[] = "hello bit";

strcpy(arr1, arr2);
char* ret = strcpy(arr1, arr2);

printf("%s\n", arr1);
printf("%s\n", ret);

return 0;
}

#include<string.h>
int main()
{
char arr1[20] = { 0 };
char arr2[] = "hello bit";

strcpy(arr1, arr2);
char* ret = strcpy(arr1, arr2);

   printf("%s\n", arr1);
   printf("%s\n", ret);
   return 0;
}

#include<string.h>
int main()
{
char arr1[20] = { 0 };
char arr2[] = "hello bit";

strcpy(arr1, arr2);
char* ret = strcpy(arr1, arr2);

   printf("%s\n", arr1);
   printf("%s\n", ret);

   return 0;
}

memset——设置内存

memory——记忆——计算机中：内存
memset定义：将指针所指的内存块中的前num个字节设置成特定的值。

memset用法：这个函数通常为新申请的内存做初始化工作。

函数介绍
void* memset(void* s, int ch, size_t n);/*或者是void* memset(void* ptr, int value, size_t sum);*/
函数解释：将s中当前位置后面的n个字节（typedef unsigned int size_t ）用 ch 替换并返回 s 。
memset：作用是在一段内存块中填充某个给定的值，它是对较大的结构体或数组进行清零操作的一种最快方法[1]。

memset()函数原型是extern void* memset(void* buffer, int c, int count)
buffer：为指针或是数组, c：是赋给buffer的值, count：是buffer的长度.

           或者是void* memset(void* ptr, int value, size_t sum);
                   ptr：Pointer to the block of memory to fill——为填充内存块的指针或是数组。
                   value：Value to be set——是赋给ptr的值。
                   num：Number of bytes to be set to the value——是ptr的长度。

int main()
{
   char arr[20] = "hello bit";
   //此时内存块已经确定：hello bit\0 (后面还有10“空位”)
   printf("%s\n", arr);

   //现在想把这个数组前5个字符都改成x
   memset(arr, 'x', 5);//用.逗号隔开
   printf("%s\n", arr);

/*memset(arr, "pijiu", 5);
printf("%s\n", arr);*///这样修改并不能达到想要的结果——pijiu bit，只能得到——" bit" (四个字符)。

return 0;
}

训练：

int main()
{
char arr[20] = "hello bit";

memset(arr,'x',5);

printf("%s\n", arr);

return 0;
}

int main()
{
char arr[20] = "hello bit";

memset(arr, 'x', 5);

printf("%s\n", arr);

return 0;
}

int main()
{
char arr[20] = "hello bit";

memset(arr, 'x', 5);

printf("%s\n", arr);

return 0;
}

自定义函数

练习一：写一个函数可以找出两个整数中的最大值

第(1)步：推演函数使用场景

int main()
{
   int a = 0;
   int b = 0;
   scanf("%d %d", &a, &b);

int max = get_max(a, b);
printf("%d\n", max);

   return 0;
}
       ↓
       ↓

第(2)步：get_max函数的设计

方法一：
int get_max(int x, int y)
{
   return(x > y) ? (x) : (y); //return (x > y ? x : y);
}
int main()
{
   int a = 10;
   int b = 20;
   int max = get_max(a, b);

   printf("max = %d\n", max);
   return 0;
}
方法二：
int get_max(int x, int y)
{
   if (x > y)
       return x;
   else
       return y;
}
int main()
{
   int a = 10;
   int b = 20;
   int max1 = get_max(a, b);//变量
   int max2 = get_max(30,20);//常量
   int max3 = get_max(15+15,30+10);//表达式
   int max4 = get_max(get_max(3,50), 10 + 10);//函数

   printf("max1 = %d\n", max1);
   printf("max2 = %d\n", max2);
   printf("max3 = %d\n", max3);
   printf("max4 = %d\n", max4);
   return 0;
}

训练：

int get_max(int x, int y)
{
   return (x > y) ? (x) : (y);
}
int main()
{
   int a = 0;
   int b = 0;
   scanf("%d %d", &a, &b);

int max = get_max(a, b);

printf("max = %d\n", max);
return 0;
}

int get_max(int x, int y)
{
   if (x > y)
       return x;
   else
       return y;
}
int main()
{
   int a = 0;
   int b = 0;

scanf("%d %d", &a, &b);
int max = get_max(a, b);

printf("max = %d\n", max);

return 0;
}

void的使用场景
①void test：函数在调用完后什么都不需要返回。
②test(void)：这个函数没有参数，不能用来传参。

①
void test()
{
   printf("hehe\n");
}
int main()
{
   test();
   return 0;
}

②
test(void)
{
   printf("hehe\n");
}
int main()
{
   test();
   return 0;
}

练习二：写一个函数可以交换两个整形变量的内容。

(非函数版)

#include<stdlib.h>//system头文件
#include<windows.h>//windows头文件
int main()
{
   int a = 0;
   int b = 0;
   //输入
   scanf("%d %d", &a, &b);
   system("cls");
   printf("交换前：%d %d\n", a, b);
   int tmp = 0;//第三个变量
   //交换
   tmp = a;
   a = b;
   b = tmp;

   Sleep(1000);
   system("cls");
   printf("交换后：%d %d\n", a, b);

return 0;
}

函数版

#include <stdio.h>
实现成函数，但是不能完成任务：通过调试可以发现，在进行交换的过程中，swap仅仅只把a,b(实际参数)的值赋给了x,y(形数式参)，[这时形参只相当于实参的一份临时拷贝]，并对x,y进行了交换，但是实际参数并不会因为形式参数(形参有自己的独立空间)的改变而改变，因此在返回主函数时并不能实现a,b的交换。所以需要把a,b的地址与x,y进行一一对应，建立联系(注意：这里不是说交换地址，地址是无法交换的)，这样在返回主函数时才能实现交换a,b。
void Swap1(int x, int y)//x,y：形式参数（形参）
{
   int tmp = 0;
   tmp = x;
   x = y;
   y = tmp;
}
//正确的版本①：把a,b的地址与x,y进行一一对应
void Swap2(int* px, int* py)//px,py：形参。int* 指针类型，px,py指针变量。
{
   int tmp = 0;
   tmp = *px;
   *px = *py;
   *py = tmp;
}
int main()
{
   int a = 1;
   int b = 2;//a,b；实际参数（实参）
   Swap1(a, b);
   printf("Swap1::a = %d b = %d\n", a, b);
   Swap2(&a, &b);//&a,&b都是实参。
   printf("Swap2::a = %d b = %d\n", a, b);
   return 0;
}
//正确版本②：
void Swap(int* pa, int* pb)
{
   int tmp = 0;
   tmp = *pa;
   *pa = *pb;
   *pb = tmp;
}
int main()
{
   int a = 0;
   int b = 0;
   scanf("%d %d", &a, &b);
   Swap(&a, &b);//对a,b取地址，准备将a,b地址与px,py建立联系。
   printf("Swap:a = %d b = %d\n", a, b);
   return 0;
}

训练：

void Swap(int* px, int* py)
{
   int tmp = 0;
   tmp = *px;
   *px = *py;
   *py = tmp;
}
int main()
{
   int a = 0;
   int b = 0;

scanf("%d %d", &a, &b);
printf("交换前：a=%d b=%d\n", a, b);

Swap(&a, &b);
printf("交换后：a=%d b=%d\n", a, b);

return 0;
}

void Swap(int* px, int* py)
{
   int tmp = 0;
   tmp = *px;
   *px = *py;
   *py = tmp;
}
int main()
{
   int a = 0;
   int b = 0;

scanf("%d %d", &a, &b);
printf("交换前：a = %d,b = %d\n",a,b);

Swap(&a, &b);
printf("交换后：a = %d,b = %d\n", a, b);

return 0;
}

指针内容回顾：

int main()
{
   int a = 20;
   int* pa = &a;//pa = &a：将a的地址托付给pa。int* pa：pa的类型是int*。
   *pa = 10;//由上可知pa里存的地址，所以*pa就是a(pa前加上*：解引用详见讲义初识C语言——指针部分)。
   return 0;
}

总结：我们可以发现练习一与练习二不同。前者并没有将a,b地址传给x,y，是因为它只用求最大值(a,b最大值始终都是一样的)，故不需要将a,b值改变；而后者却相反，它会因为a,b值的大小，可能对二者值进行交换，所以需要将a,b地址传过去，建立联系，进而远程遥控对而这进行重新排序。即当自定义函数里的变量需要与主函数里的变量建立联系时，主函数就需要传地址，自定义函数就需要通过指针接收地址。

练习

1. 写一个函数可以判断一个数是不是素数。

求100~200之间的素数(不用函数版)

错误写法：
int main()
{
   int i = 0;
   for (int a = 100; a >= 100 && a <= 200; a++)
   {
       for (i = 2; i >= 2 && i <= a; i++)
       {
           int b = a % i;
           switch (b)
           {
           case 0:
               break;//只break了switch——break只能跳出一次循环。
                   //即，在i > a之前，不管b是否等于0，i一直++，a值不变。
           default:
               continue;
           }//这种写法会导致a所在范围内所有的数字都被打印。
       }
       if (i == a+1)//只break了switch——break只能跳出一次循环。当最后一次循环时，进循环前i=a；出循环时，i++=a。
           printf("%d ", a);
   }
   return 0;
}

正确写法：
int main()
{
   int i = 0;

   for (int a=100;a >=100 && a <= 200;a++)
   {
       //方法一：
       for (i = 2;i >= 2 && i <= a;i++)
       {
           if (a % i == 0)
               break;
           else
               continue;
       }
       //printf("%d ", a);//直接这样写，即便是if语句break以后，还会从这里经过，而不是跳过printf，进行a++。
                       //因此，要给printf加限制条件——满足素数的条件。

       if(i == a)//break只会跳出switch和循环语句，并不会跳出if，因此，最后一次循环结束时，不会进行i++。
           printf("%d \n", a);

       //方法二：
       for (i = 2; i >= 2 && i <= a/2; i++)//已知a=b*c，在[0~(a/2)),和((a/2)~a]这两个区间内，
                                           //至少还有一组数字相乘=a——1*a。如果只有1*a，则这个数必是素数。
       {
           if (a % i == 0)
               break;
           else
               continue;//continue只会作用于switch和循环语句，并不会跳出循环，最后一次循环——i = a / 2结束时，仍会进行i++。故后面if中需要+1。
       }
       if (i == (a / 2) + 1)
       {
           printf("%d ", a);
           printf("i=%d ", i);
           printf("c=%d \n", (a / 2) + 1);
       }
   }
   return 0;
}//不用函数的方法远不止这些，其中更简单的方法不乏其例——要知道“人外有人，山外有山。”，要多多学习。

训练：

int main()
{
int a = 0;

   for (a = 100; a <= 200; a++)
   {
       int j = 2;
       int flag;
       for (j = 2; j <= a - 1; j++)
       {
           if (a % j == 0)
           {
               flag = 0;
               break;
           }
           else
               flag = 1;
       }
       if (flag == 1)
           printf("%d ", a);
   }

return 0;
}

求100~200之间的素数(用函数版)

约定：是素数的话，返回1；不是素数，返回0。
#include<math.h>
int is_prime(int n)//不管返回1，还是返回0，都是整数，所以函数名前要用int来定义。
{
   int j = 0;
   for (j = 2; j <= sqrt(n); j++)
   {
       if (n % j == 0)
       {
           return 0;//返回到主函数（*）if语句，而不是本for循环。
                   //不是素数
       }
   }
   return 1;//返回到主函数（*）if语句。
           //是素数
}
int main()
{
   int i = 0;
   for (i = 100; i <= 200; i++)
   {
       if (is_prime(i) == 1)//（*）返还的值就是is_prime(i)
           //if (is_prime(i)):VS中，也能这样写。因为如果自定义函数返回值为0，即为假，则不进入 if；
//如果自定义函数返回值为1，即为真，则进入if打印结果。
       {
           printf("%d ", i);
       }
   }
   return 0;
}

训练：

#include<math.h>
int is_prime(int n)
{
int j = 0;

   for (j = 2; j <= sqrt(n); j++)
   {
       if (n % j == 0)
           return 0;
   }
   return 1;
}
int main()
{
   int a = 0;

   for (a = 100; a <= 200; a++)
   {
       if (is_prime(a))
           printf("%d ", a);
   }

return 0;
}

#include<math.h>
int is_prime(int a)
{
   int j = 0;
   for (j = 2; j <= sqrt(a); j++)
   {
       if (a % j == 0)
           return 0;
   }
   return 1;
}
int main()
{
   int a = 0;
   for (a = 100; a <= 200; a++)
   {
       if (is_prime(a))
           printf("%d ", a);
   }

return 0;
}

2. 写一个函数判断一年是不是闰年。

约定：是闰年——返回1；不是闰年——返回0。、

方法一：
int is_leap_year(int n)
{
   if (n % 4 == 0 && n % 100 != 0)
   {
       return 1;
   }
   if (n % 400 == 0)//这里不能加else。
   {
       return 1;
   }

   return 0;//必须加，否则会在每个能被400整除的数字y后，再多出一个不合格的结果——y+1。
}
int main()
{
   int y = 0;
   for (y = 1000; y <= 2000; y++)//这里可以将y++改成y+=4。
   {
       if (is_leap_year(y))//if (is_leap_year(y)==1)也行
       {
           printf("%d ", y);
       }
   }

return 0;
}

方法二：

int is_leap_year(int n)
{
   if (((n % 4 == 0) && (n % 100 != 0)) || (n % 400 == 0))
       return 1;
   else//这里可加可不加
       return 0;
}
int main()
{
   int y = 0;
   for (y = 1000; y <= 2000; y++)
   {
       if (is_leap_year(y))
       {
           printf("%d ", y);
       }
   }
   return 0;
}

或
int is_leap_year(int y)
{
   if (((y % 4 == 0) && (y % 100 != 0)) || (y % 400 == 0))
       return 1;
   else
       return 0;
}
int main()
{
   int y = 0;
   for (y = 1000; y <= 2000; y++)
   {
       if (is_leap_year(y))
       {
           printf("%d ", y);
       }
   }
   return 0;
}

方法三：
int is_leap_year(int n)
{
   return (((n % 4 == 0) && (n % 100 != 0)) || (n % 400 == 0));
}
int main()
{
   int y = 0;
   for (y = 1000; y <= 2000; y++)
   {
       if (is_leap_year(y))
       {
           printf("%d ", y);
       }
   }
   return 0;
}

训练：

int is_leap_year(int n)
{
   return (n % 4 == 0 && n % 100 != 0 || n % 400 == 0);
}
int main()
{
   int y = 0;
   for (y = 1000; y <= 2000; y++)
   {
       if (is_leap_year(y))
           printf("%d ", y);
   }
   return 0;
}

int is_leap_year(int n)
{
   return (n % 4 == 0 && n % 100 != 0 || n % 400 == 0);
}
int main()
{
   int y = 0;
   for (y = 1000; y <= 2000; y++)
   {
       if (is_leap_year(y))
           printf("%d ", y);
   }

return 0;
}