函数一
函数：“代码块"
每一个具体功能，都可以写成一个函数
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\n",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 \n");
类型：
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\n",c);
//直接打印
cout<<add(3,5)<<end;
//独立语句
func1();
//有返回值的，可以做实参
cout<<add(1,add(3,5))<<endl;
//可以作判断条件
if(add(3,4) > 6)
{
printf("add(3,4)>6\n");
}
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 \n");
4.参数传递
1.值传递
只能改变形参的值，不能改变实参的值
//写函数，交换两个数的值
//值传递
void exchange1(int a1, int b1)
{
printf("交换前a1=%d b1=%d\n", a1, b1);
a1 = a1 ^ b1;
b1 = a1 ^ b1;
a1 = a1 ^ b1;
printf("交换后a1=%d b1=%d\n", a1, b1);
}
int main()
{
int m=10,n=20;
exchange1(m,n);
printf("m=%d n=%d\n",m,n);
}
2.址传递
可以改变实参的值
//址传递
void exchange3(int* a2, int* b2)
{
printf("交换前a1=%d b1=%d\n", *a2, *b2);
*a2 = *a2 ^ *b2;
*b2 = *a2 ^ *b2;
*a2 = *a2 ^ *b2;
printf("交换后a1=%d b1=%d\n", *a2, *b2);
}
int main()
{
int m = 10, n = 20;
printf("交换前m=%d n=%d\n", m, n);
//exchange3(&m, &n); 或者
int *pm=&m,*pn=&n;
exchange3(pm,pn);
//也可以交换m和n的值
printf("交换后m=%d n=%d\n", m, n);
return 0;
}
3.引用传递
可以改变实参的值
//引用传递
//因为用的是引用，所以a2就是m，b2就是n
void exchange2(int& a2, int& b2)
{
printf("交换前a1=%d b1=%d\n", a2, b2);
a2 = a2 ^ b2;
b2 = a2 ^ b2;
a2 = a2 ^ b2;
printf("交换后a1=%d b1=%d\n", a2, b2);
}
int main()
{
int m=10,n=20;
exchange2(m,n);
printf("m=%d n=%d\n");
}
四、文件引用
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\n", *pa);
printf("%d\n", *pa);
return 0;
}
2.函数指针 函数本身有地址
指针本身的类型：指针指向的类型和*
指针指向的类型(函数本身的类型)：
typedef int(*pp)(int int);
void func1()
{
printf("func1 is used\n");
}
//对于这个函数
//他的类型是 void ()
//指向的类型： void(*)()
int func2(inta , int b)
{
printf("func2 is used\n");
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;
}
