函数一

函数：“代码块"

每一个具体功能，都可以写成一个函数

C语言：以函数为主体

一、函数定义

1.语法格式:

//返回值类型 函数名（形参表）   //函数头
{
    //函数体
    
}    

2.解释：

返回值类型：反馈

函数名：合法标识符（一般是动词）

形参表：规定参数格式

函数体：代码

3.举例

函数代码及调用

#include<stdio.h>
#include<iostream>
using namespace std;

int add(int a, int b);

void func1();

//函数的声明
int main()
{
    int c=add(3,5);//作右值
    //返回了一个值，所以定义一个int c去接收这个值
    printf("c=%d
",c);
    cout<<add(3,5)<<end;//直接打印
    
    func1();//独立语句
    return 0;
}

int add(int a, int b)  //因为是计算两个值的和
{						//所以肯定需要一个返回的答案
	//int c=a+b;		//也要int的类型
	//return c;			//和两个参数值，你自己填
	return a + b;
}

void func1()
{
    printf("fun1 was been used 
");

    

类型：

1.有类型，无参数

2.有类型，有参数

3.无类型，有参数

4.无类型，无参数

函数声明定义时小括号里的叫形参

函数调用时小括号里实际给的值，叫实参

二、函数声明

//返回值类型 函数名（形参表）; //函数头

三、函数调用

1.语法

//函数名（实参表）;

2.函数调用流程

1.从主函数进入被调用函数

主调函数：主函数

被调用函数：自己定义的

2.给形参分配临时内存，将实参的值拷贝给形参==》定义，声明阶段，形参没有内存

3.进入被调函数，执行函数体

4.系统自动回收临时内存

5.回到主调函数，有返回值的，带回返回值

3.用法

1.可以作为独立语句

2.如果有返回值，可以作右值，给变量赋值

3.可以直接用于打印

4.有返回值的，可以做实参

5.可以作为判断条件

#include<stdio.h>
#include<iostream>
using namespace std;

int add(int a, int b);

void func1();

//函数的声明
int main()
{
    //作右值
    int c=add(3,5);//返回了一个值，所以定义一个int c去接收这个值
    printf("c=%d
",c);
    
    //直接打印
    cout<<add(3,5)<<end;
    
    //独立语句
    func1();
    //有返回值的，可以做实参
    cout<<add(1,add(3,5))<<endl;
    
    //可以作判断条件
    if(add(3,4) > 6)
    {
		printf("add(3,4)>6
");
    }
    return 0;
}

int add(int a, int b)  //因为是计算两个值的和
{						//所以肯定需要一个返回的答案
	//int c=a+b;		//也要int的类型
	//return c;			//和两个参数值，你自己填
	return a + b;
}

void func1()
{
    printf("fun1 was been used 
");

    

4.参数传递

1.值传递

只能改变形参的值，不能改变实参的值

//写函数，交换两个数的值
	//值传递
void exchange1(int a1, int b1)
{
	printf("交换前a1=%d b1=%d
", a1, b1);
	a1 = a1 ^ b1;
	b1 = a1 ^ b1;
	a1 = a1 ^ b1;
	printf("交换后a1=%d b1=%d
", a1, b1);
}
int main()
{
    int m=10,n=20;
    exchange1(m,n);
    printf("m=%d n=%d
",m,n);
}

2.址传递

可以改变实参的值

//址传递
void exchange3(int* a2, int* b2)
{
	printf("交换前a1=%d b1=%d
", *a2, *b2);
	*a2 = *a2 ^ *b2;
	*b2 = *a2 ^ *b2;
	*a2 = *a2 ^ *b2;
	printf("交换后a1=%d b1=%d
", *a2, *b2);
}
int main()
{
    int m = 10, n = 20;
	printf("交换前m=%d n=%d
", m, n);
	//exchange3(&m, &n); 或者
    int *pm=&m,*pn=&n;
    exchange3(pm,pn);
    //也可以交换m和n的值
	printf("交换后m=%d n=%d
", m, n);
    return 0;
}

3.引用传递

可以改变实参的值

//引用传递
//因为用的是引用，所以a2就是m，b2就是n
void exchange2(int& a2, int& b2)
{
	printf("交换前a1=%d b1=%d
", a2, b2);
	a2 = a2 ^ b2;
	b2 = a2 ^ b2;
	a2 = a2 ^ b2;
	printf("交换后a1=%d b1=%d
", a2, b2);
}
int main()
{
    int m=10,n=20;
    exchange2(m,n);
    printf("m=%d n=%d
");
}

四、文件引用

include 系统文件

include"xxx" 自定义文件

box.h==>声明函数

box.cpp==>实现函数

main.cpp==>调用函数

五、函数与指针

1.指针函数

返回值是指针的叫指针函数

注意：使用指针函数，不能指向返回栈区变量的指针

int* function()
{
	int mn = 10;  //a:栈区变量
	int* p = &mn; //p:指针，指向栈区变量
	return p;   //1.返回p   2.释放a==>变成了野指针
}
int main()
{
	int* pa = function();
	printf("%d
", *pa);
	printf("%d
", *pa);
	return 0;
}

2.函数指针 函数本身有地址

指针本身的类型：指针指向的类型和*

指针指向的类型(函数本身的类型)：

typedef int(*pp)(int int);

void func1()
{
    printf("func1 is used
");
}
//对于这个函数
//他的类型是 void ()

//指向的类型： void(*)()

int func2(inta , int b)
{
    printf("func2 is used
");
    return 0;
}

int main()
{
    void (*p)()=&func1;//函数指针
    (*p)();
    //效果和 func1一样
    
    //或者
    void (*p1)()=func1;
    p1();//效果一样
    (*p1)();//效果一样
    //可以取内容，也可以不取内容
    //类型符合的函数都可以指==》同样的类型
    
    int(*pp)(int int)=func2;
    pp(1,2);
    //或者
    //（*pp)(1,2);
    
    pp pfunc=func2;
    //调用
    pfunc(1,2);
    return 0;
}

宏定义===》完全替换

#define sum(n,m) n+m
int main()
{
    int x=sum(2,5)*sum(6,5);
    printf("%d",x);
    //答案是2+5*6+5=37
    return 0;
}