函数要先声明再使用，函数的声明需要在函数主体int main前面；

type name (argument1, argument2...) statement
type 是返回类型
name 是定义的函数名
argument是上传的参数
statement是语句

加法函数

//例如
#include#include#includeusing namespace std;
int func(int a, int b)
{int c = a + b;
	return c;
}
int main()
{int d = func(1, 3);  // 调用函数
	cout<< d;
}

//显示
4

入口参数的隐式转换
入口参数做值拷贝，就是只有值一样，函数内部会对拷贝得到的数据进行执行运算，不会对原数据有任何影响

//例如
#include#include#includeusing namespace std;
int func(int a)
{a = 10;  // 对a进行复制，此时a是值拷贝得到的a，
	return 0;
}
int main()
{int a = 3;
	int d = func(a); // 将a= 3 传进去，会对a做值拷贝，
	cout<< d<< "\n"; // d是返回值，是return的值
	cout<< a;//调用完函数之后应该是a = 10,但那是函数内部，在函数外部的a没有改变，还是3
}

//显示
0
3

函数只能有一个数值，如果要返回两个数值，可以返回引用，或者内存地址

//例如
#include#include#includeusing namespace std;
float func(float r, float &D)  //此处引用D
{float S = 3.14 * r * r;
	D = 2 * 3.14 * r;
	return S;
}
int main()
{int a = 10;
	float d1;
	float d = func(a,d1);  // 相当于有一个&D = d1，此时D和d1是引用和被引用关系，一方被修改，则两方都被修改，而函数体中的D = 2 * 3.14 * r;就是修改D，那么d1也会被修改，那么就可以从函数体中得到另一个参数了
	cout<< d<< "\n";
	cout<< d1;

//例如
#include#include#includeusing namespace std;
float func(float r, float *D)
{float S = 3.14 * r * r;
	*D = 2 * 3.14 * r;
	return S;
}
int main()
{int a = 10;
	float d1;
	float d = func(a, &d1);  相当于有一个*D = &d1，此时D直接指向d1的内存地址，一方被修改，则两方都被修改，而函数体中的D = 2 * 3.14 * r;就是修改D，那么d1也会被修改，那么就可以从函数体中得到另一个参数了
	cout<< d<< "\n";
	cout<< d1;
}

一、利用引用

//例如
#include#include#includeusing namespace std;
void func(float &a, float &b)
{float temp = a;
	a = b;
	b = temp;
}
int main()
{float a = 2;
	float b = 3;
	func(a, b);
	cout<< a<< "\n";
	cout<< b;
}

二、利用指针指向地址

//例如
#include#include#includeusing namespace std;
void func(float *a, float *b)
{float temp = *a;
	*a = *b;
	*b = temp;
}
int main()
{float a = 2;
	float b = 3;
	func(&a, &b);
	cout<< a<< "\n";
	cout<< b;
}

int func () // 不上传参数的函数是可以存在的，一般用功能性参数
{return 1.0;
}

可以存在函数名相同的函数，但是上传参数的类型或上传参数的个数不能一样
在c++中，输入1.5其实是double类型，1.5f才是float类型
double双精度浮点数

//例如
#include#include#includeusing namespace std;
void func(int a)
{cout<< "运行了整型func";
}
void func(float a)  //两个函数名一样，但是上传参数的类型不一样
{cout<< "运行了浮点型func";
}
int main()
{float a = 2;
	int b = 3;
	func(a);  //a是浮点型，调用浮点型func
	func(b);  //b是整型，调用整型func
	double c = 4;
	func(4);  // 会报错，因为没有定义双精度浮点型的func，不知道选哪一个，但是如果去掉一个func,只留一个func，就会隐式转换**
}

//显示
运行了浮点型func运行了整型func  //没有加换行

如果有两个func，不知道选哪一个，就会报错，但是如果去掉一个func,只留一个func，就会隐式转换
函数可以在int main前面声明，然后在int main后面写函数，也不会报错

函数里面可以有默认参数

//例如
#include#include#includeusing namespace std;
int func(int a,int b=5)
{int c = a + b;
	cout<< c<< "\n";
	return c;
}

int main()
{float a = 2;
	int b = 3;
	func(a);  //默认b=5
	func(a,b); // 上传参数的时候优先使用上传的参数
}

//显示
7
5

递归深度是跟程序内存占据大小有关
递归实现n的阶乘

//例如
#include#include#includeusing namespace std;
int func(int n)
{if (n<= 1)
	{return 1;
	}
	return n * func(n-1);
}

int main()
{int res = func(3);
	cout<< res;
}

//显示
6

递归实现x*x+sin(x)-2求解

//例如
#include#include#includeusing namespace std;
// x*x+sin(x)-2
float func(float left, float right)
{if ((abs(left - right))< 0.00001)
	{return left;
	}
	float r_left = left * left + sin(left) - 2;
	float r_right = right * right + sin(right) - 2;
	float mid = (left + right) / 2;
	float r_mid = mid * mid + sin(mid) - 2;
	if (r_left * r_mid< 0)
	{return func(left, mid);
	}
	else
	{return func(mid, right);
	}
}

int main()
{float res = func(0, 10);
	cout<< res;
}

//显示
1.06154

无返回值的函数定义为void

static，静态函数，在函数内部存在的变量，函数内部共享

//例如
#include#include#includeusing namespace std;
void func()
{static int a = 0;  //静态函数的初始化只会执行一次
	a++;
	cout<< a<< "\n";
}

int main()
{func();
	func();
	func();
	func();
	func();
}

//显示
1
2
3
4
5

两个函数之间的静态变量互不关联，没有影响

//例如
#include#include#includeusing namespace std;
void F2()
{static int b = 0;
	b++;
	cout<< "F2的静态函数"<< b<< "\n";
}
void F1()
{static int a = 0;
	a++;
	cout<< "F1的静态函数"<< a<< "\n";
	F2();
}


int main()
{F1();
	F1();
	F2();
}

//显示
F1的静态函数1  // F1和F2的静态函数的计数互不影响，没有关联
F2的静态函数1
F1的静态函数2
F2的静态函数2
F2的静态函数3

你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧