当前位置：网站首页>C语言函数

#include<stdio.h>
#include<string.h>
int main ()
{
    char arr1[]="abcdef";      //a b c d e f
    char arr2[20]={0};
    strpy(arr1,arr2};
    printf("%s\n",arr2);
    return 0;
}

memset（内存设置）
void * memset ( void * ptr, int value, size_t num );

#include<stdio.h>
#include<string.h>
int main()
{
  char  arr[]="Hello World";
  memset(arr+6,'x',3);

//.设置内存的时候是以字节为单位,且每个字节的内容都是一样value，从第六个字节后开始，后面三个为x


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

二.自定义函数

自定义函数也是像库函数一样由函数名，返回值类型和函数参数组成。

返回的类型函数名（函数的参数）
{
语句项；
}

如：写一个两者比较大小值的函数。

#include<stdio.h>
int get_max(int x,int y)           //int  是返回类型   get_max是函数名   int x,int y是参数
{
   
   return (x>y) ? (x) : (y);       //语句项
}
int main ()
{
   int a=10;
   int b=20;
   int max = get_max(a,b);
 printf("%d\n",max);
return 0;
}

交换整型变量的函数：

//错误的形式
#include <stdio.h>
//实现成函数，但是不能完成任务
void Swap1(int x, int y) {
 int tmp = 0;
 tmp = x;
 x = y;
 y = tmp; }
//正确的形式
#include<stdio.h>
void Swap2(int *px, int *py)   //形参
{
 int tmp = 0;
 tmp = *px;
 *px = *py;
 *py = tmp;
 }
int main()
{
 int a= 4;
 int b = 8;
 Swap1(a, b);      //传值调用
 printf("交换前：a = %d b = %d\n", a, b);
//实参
 Swap2(&a, &b);    //传址调用
 printf("交换后:a = %d  b = %d\n", a, b);
 return 0;
 }

当实参传给形参的时候，形参是实参的一份临时拷贝，对形参的修改不会影响实参。

swap1:在调用过程中，我们将a和b的数值传给了x，y。然后在函数内将x，y进行数值交换，但没有改变原来的a，b。因为x，y是形参，用完了就销毁的东西，仅仅是用于临时储存原来的数值，所以根本不能改变a，b的值。

swap2:在调用过程中，传的是地址，将地址传给指针*px，*py。*px即a的地址，*py即b的地址，变量储存在地址中，那么就可以根据指针定位到原来的变量。

swap1 和 Swap2 函数中的参数 x，y，px，py 都是形式参数。在main函数中传给 swap1 的 a,b 和传给 Swap2 函数的 &a ， &b 是实际参数。Swap1 函数在调用的时候， x ， y 拥有自己的空间，同时拥有了和实参一模一样的内容。所以我们可以简单的认为：形参实例化之后其实相当于实参的一份临时拷贝。

函数的实参：

真实传给函数的参数，叫实参。
实参可以是：常量、变量、表达式、函数等。
无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。

函数的形参：

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

传值调用:

函数的形参和实参分别占有不同内存块，对形参的修改不会影响实参。

传址调用：

传址调用是把函数外部创建变量的内存地址传递给函数参数的一种调用函数的方式。
这种传参方式可以让函数和函数外边的变量建立起真正的联系，也就是函数内部可以直接操
作函数外部的变量。

函数的嵌套调用：

函数可以嵌套调用，但是不能嵌套定义(在一个函数体内不能包含另一个函数的定义)

#include <stdio.h>
void new_line()
{
 printf("hehe\n");
}
void three_line()
{
    int i = 0;
 for(i=0; i<3; i++)
   {
        new_line();
   }
}
int main()
{
 three_line();
 return 0;
}

main函数中调用了three_line函数，three_line函数每次执行循环都会调用一次new_line函数，new_line函数的作用是打印hehe。所以这个程序的最终结果就是打印3个hehe。这就是嵌套调用。

链式访问：

把一个函数的返回值作为另外一个函数的参数把一个函数的返回值作为另外一个函数的参数。

#include <stdio.h>
#include <string.h>
int main()
{
    char arr[20] = "hello";
 int ret = strlen(strcat(arr));
 printf("%d\n", ret);
 return 0; 
}
//#include <stdio.h>
//#include <string.h>
//int main()
//{
//    char arr[20] = "hello";
// printf("%d\n", strlen(strcat(arr)));
// return 0; 
//}

#include <stdio.h>
int main()
{
    printf("%d", printf("%d", printf("%d", 43)));
    return 0;
}

那这个最后的结果？

先是printf最里面的然后依次往外。

下面是printf的返回值：（可通过 https://cplusplus.com/ 查询）

大概意思是返回打印字符的个数。so先打印43 ，结果为

printf("%d", printf("%d"，43))；

因为'43'是两个字符，所以 printf("%d"，43) 的结果为2.之后：

printf("%d"，2)；

'2'是一个字符，所以打印为1.

最终的结果为4321

函数的声明：

定义：
1.告诉编译器有一个函数叫什么，参数是什么，返回类型是什么。但是具体是不是存在，函数声明决定不了。
2. 函数的声明一般出现在函数的使用之前。要满足先声明后使用。
3. 函数的声明一般要放在头文件中的

函数的定义：

定义：函数的定义是指函数的具体实现，交待函数的功能实现。

#include<stdio.h>
//函数的声明
int add(int x,int y);

int main()
{
  int a=10;
  int b=20;
  int sum=add(a,b);
  printf("%d\n",sum);
}
//函数的定义
int add(int x,int y)
{
  return (x+y);
}

递归

程序调用自身的编程技巧称为递归（ recursion）。
递归做为一种算法在程序设计语言中广泛应用。
一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求。
递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。
条件：
1.存在限制条件，当满足这个限制条件的时候，递归便不再继续。
2.每次递归调用之后越来越接近这个限制条件

例：接受一个整型值（无符号），按照顺序打印它的每一位。

#include <stdio.h>
void print(int n)
{
 if(n>9)
 {
 print(n/10);
 }
 printf("%d ", n%10);
}
int main()
{
 int num = 1234;
 print(num);
 return 0;
}

print函数可以把num的每一位按顺序打印出来。

首先num被赋值为1234，进入print函数里。经过/10后为123

再次进入print函数后为12

接着print函数后为1

因为1%10为1，打印出1，然后返回上一个函数里，print为12的函数里，12%10为2，打印出2 ，依此打印出3和4

过程：print（1234）---print（123）4---print（12）3 4---print（1） 2 3 4---print 1 2 3 4

例：不允许创建临时变量，用递归模拟strlen求字符串的长度。

#include <stdio.h>
int my_strlen(char* str)
{
	if (*str != '\0')
		return 1 + my_strlen(str+1);
}
int main()
{
	char arr [] = "abcdef";
	int len=my_strlen(arr);
	printf("%d\n",len);
	return 0;
}

求字符串的长度，遇到\0就停止，\0之前有几个字符就是字符串的长度。

刚开始 str是a不等于\0，str+1就是b，一直继续下去直到碰到 \0 ,终止代码。

迭代：

迭代是重复反馈过程的活动，其目的通常是为了逼近所需目标或结果。每一次对过程的重复称为一次“迭代”，而每一次迭代得到的结果会作为下一次迭代的初始值。重复执行一系列运算步骤，从前面的量依次求出后面的量的过程。此过程的每一次结果，都是由对前一次所得结果施行相同的运算步骤得到的。

例如求n的阶乘：(前提是不考虑栈溢出）

#include<stdio.h>
int fac(int n)
{
	if (n < 2)
		return 1;
	else
		return n * fac(n - 1);
 }
int main()
{
	int n = 0;
	scanf_s("%d\n", &n);
	int ret = fac(n);
	printf("%d\n", ret);
	return 0;
}

例2：求第n个斐波那契数列（不考虑栈溢出）

#include <stdio.h>
int count = 0;
int fuc(int n)
{
    if (n == 3)
        count++;//记录x==3调用了多少次
    if (n <= 2)
        return 1;
    else
        return fuc(n - 2) + fuc(n - 1);
}
int main()
{
    int n;
    printf("请输入一个数");
    scanf("%d",&n);
    printf("斐波那契数列的第%d项的值为%d", n, fuc(n));
    printf("调用次数为%d", count);
    return 0;
}

因为不考虑栈溢出的情况，当输入很大的值后，运算就很很麻烦，因为是在一直循环，可以把递归改成非递归的情况。

阶乘改后的情况：

#include <stdio.h>
int fac(int n)
{
    int result = 1;
    while (n > 1)
    {
        result *= n;
        n -= 1;
    }
    return result;
}
int main()
{
    int n;
    printf("请输入n=>");
    scanf("%d",&n);
    printf("%d的阶乘为%d",n,fac(n));   
    return 0;
}

如n>1，就把n的值累乘到result里面，然后n递减，继续累乘，循环下去，直到n<=1了，就返回结果。如果我们输入5，result=1*5=5→result=5*4=20→20*3=60→60*2=120

斐波那契数列改后：

#include <stdio.h>
int fuc(int n)

{
    int a = 1,b = 1, c = 1;
    int i;
    while (n>2)
    {
            c = a + b;
            a = b;
            b = c;
            n--;
    }
        return c;
    }
int main()
{
    int n;
    printf("请输入一个数");
    scanf("%d", &n);
    printf("斐波那契数列的第%d项的值为%ld", n, fuc(n));
    return 0;
}