函数

一、函数的定义

     1.1  函数定义格式

           ① 无参函数（函数仅完成某种固定操作时，可将函数定义为无参函数）

               格式：<返回值类型>  <函数名> （）

                             {.......};

                   当函数定义在前调用在后且函数返回值为整形时，可省略函数的返回值类型；

                   当函数没有返回值时，必须指定其类型为void；

           ② 有参函数

                格式： <返回值类型>   <函数名>  （<类型标识符> arg1，<类型标识符>arg2）

                              {......};

    1.2函数的实参，形参，返回值

         形式参数（实参）：在定义函数时，函数名后的圆括号中所列举的参数

         实际参数（实参）：函数调用时在函数名后圆括号中依次列出的参数

         返回值：格式    return <表达式>;

二、函数的调用

        调用一个函数，就是把程序控制转去执行该函数的函数体。

      数据流程：

              （1）在主程序中，先给实参赋值

              （2）通过函数调用，将数据从主调函数传递到被调函数

              （3）被调函数的形参带值后，即可进行相应的数据处理和运算

              （4）如果有返回值，通过return语句带回到主调函数

                       无参函数的函数调用语句一般格式为：<函数名> （）

                        有参函数的函数调用语句一般格式为：<函数名> （<实参表>）

#include <iostream>
using namespace std;

int add(int num1, int num2)
{
    int sum = num1 + num2;
    return sum;
}
int main()
{
    int a = 10;
    int b = 20;
    int c = add(a, b);
    cout << "c= " << c << endl;


    a = 100;
    b = 500;
    c = add(a, b);
    cout << "c= " << c << endl;

    system("pause");
    return 0;
}

                 形参=实参

三、函数的嵌套与递归调用

    3.1函数的嵌套调用

        C++的函数不允许嵌套定义，但是函数之间的嵌套调用是允许的

        

#include<iostream>
using namespace std;
int max(int x,inty,int z)
{
   int s;
   s=x>y?x:y;
   return (s>z?s:z);
}
int min(int x,int y,int z)
{
   int t;
   t=x<y?x:y;
   return (t<z?t:z);
}
int dif (int x,int y,int z)
{
    int sub;
    sub=max(x,y,z)-min(x,y,z);
    return sub;
}
 void ()
{
    int a,b,c;
    cin>>a>>b>>c;
    cout<<"最大值-最小值的差值为 : "<<dif(a,b,c)<<endl;

         3.2函数的递归调用

           间接递归：函数A的函数体中调用函数B，而在函数B的函数体中有调用函数A 

           直接调用：函数A的函数体中又出现调用函数A的情况

#include<iostream>
using namespace std;
double P(double x,double n)
{
	if(n==0)
		return 1;
	else if(n==1)
		return x;
	else 
		return((2*n-1)*x*P(x,n-1)-(n-1)*P(x,n-2))/n;
}
int main()
{
	double x,n;
	cout<<"please enter x and n:"<<endl;
	cin>>x>>n;
	cout<<"P(x,n)= "<<P(x,n)<<endl;
	return 0;
}

四、函数与数组

    4.1数组元素作函数的参数

        数组元素可以作为函数的实参进行值的单向传递

#include<iostream.h>
int add(int x,int y,int z)
{  int c[10];
   c[k]=x+y;
   return c[k];
}
void main()
{  int a[10]={1,2,3,4,5,6,7,8,9,10};
   int b[10]={10,9,8,7,6,5,4,3,2,1};
   int s[10];
   for(i=0;i<10;i++)
      s[i]=add(a[i],b[i],i);
   for(i=0;i<10;i++)
      cout<<s[i]<<"  ";
    cout<<'\n';
}


结果为 11 11 11 11 11 11 11 11 11 11
        

4.2数组名作函数的参数

   数组名不仅表示数组的名称，还表示数组的首地址。

   参数的传递实际上是一种地址的传递，当采用数组名作实参和形参时，将实参数组的首地址传递给形参数组，这时形参数组与实参数组共享内存中的存储空间。

#include<iostream.h>
void  input(int x[], int n)
{
    cout<<"输入"<<n<<"个整数：";
    for(int i-0;i<n;i++)
}
int big (int b[],int n)
{
   int max=b[0];
   for(int i=1;i<n;i++) if (max<b[i])  max=b[i];
   return max;
}
void main()
{
    int a[10],max;
    input(a,10);
    max=big(a,10);
    cout<<max<<endl;

五、函数的声明

作用：告知编译器函数名称及如何调用函数

           函数的实际主体可以单独定义

    声明可以多次，但是函数的定义只能一次

#include<iostream>
using namespace std；
// 函数的声明
int max(int a,int b)
// 定义
int max(int a, int b)

{
	 return a > b ? a : b;

}

int main()
{
	int a = 10;
	int b = 20;
	cout << max(a, b) << endl;


	return 0;

}