C++函数概述

函数”这个名词是从英文function翻译过来的，其实function的原意是“功能”。顾名思义，一个函数就是一个功能。

在实际应用的程序中，主函数写得很简单，它的作用就是调用各个函数，程序各部分的功能全部都是由各函数实现的。主函数相当于总调度，调动各函数依次实现各项功能。

开发商和软件开发人员将一些常用的功能模块编写成函数，放在函数库中供公共选用。程序开发人员要善于利用库函数，以减少重复编写程序段的工作量。

例3.1】在主函数中调用其他函数。

#include <iostream>
using namespace std;
void printstar(void)   //定义printstar函数
{
    cout<<″****************************** ″<<endl; //输出30个“*”
}

void print_message(void) //定义print_message函数
{
    cout<<″Welcome  to  C++!″<<endl;  //输出一行文字
}

int main(void)
{
    printstar( );  //调用printstar 函数
    print_message( ); //调用print_message函数
    printstar( );  //调用printstar 函数
    return 0;
}

• 系统函数，即库函数。这是由编译系统提供的，用户不必自己定义这些函数，可以直接使用它们。
• 用户自己定义的函数。用以解决用户的专门需要。

• 无参函数。调用函数时不必给出参数。
• 有参函数。在调用函数时，要给出参数。在主调函数和被调用函数之间有数据传递。

int max(int x,int y)  //函数首部,函数值为整型,有两个整型形参
{
    int z;  //函数体中的声明部分
    z=x>y?x:y; //将x和y中的大者的值赋给整型变量z
    return (z);//将z的值作为函数值返回调用点
}

#include <iostream>
using namespace std;
int max(int x,int y)  //定义有参函数max
{
   int z;
   z=x>y?x:y;
   return(z);
}

int main( )
{
   int a,b,c;
   cout<<"please enter two integer numbers:";
   cin>>a>>b;
   c=max(a,b);//调用max函数,给定实参为a,b。函数值赋给c
   cout<<"max="<<c<<endl;
   return 0;
}

运行情况如下：
please enter two integer numbers:2 3↙
max=3

有关形参与实参的说明：
1) 在定义函数时指定的形参，在未出现函数调用时，它们并不占内存中的存储单元，因此称它们是形式参数或虚拟参数，表示它们并不是实际存在的数据，只有在发生函数调用时，函数max中的形参才被分配内存单元，以便接收从实参传来的数据。在调用结束后，形参所占的内存单元也被释放。

2) 实参可以是常量、变量或表达式，如max(3, a+b);但要求a和b有确定的值。以便在调用函数时将实参的值赋给形参。

3) 在定义函数时，必须在函数首部指定形参的类型(见例3.2程序第3行)。

4) 实参与形参的类型应相同或赋值兼容。例3.2中实参和形参都是整型，这是合法的、正确的。如果实参为整型而形参为实型，或者相反，则按不同类型数值的赋值规则进行转换。例如实参a的值为3.5，而形参x为整型，则将3.5转换成整数3，然后送到形参b。字符型与整型可以互相通用。

5) 实参变量对形参变量的数据传递是“值传递”，即单向传递，只由实参传给形参，而不能由形参传回来给实参。在调用函数时，编译系统临时给形参分配存储单元。

请注意：实参单元与形参单元是不同的单元。图3.3表示将实参a和b的值2和3传递给对应的形参x和y。

调用结束后，形参单元被释放，实参单元仍保留并维持原值。因此，在执行一个被调用函数时，形参的值如果发生改变，并不会改变主调函数中实参的值。例如，若在执行max函数过程中形参x和y的值变为10和15，调用结束后，实参a和b仍为2和3，见图4.4。

函数的返回值

1) 函数的返回值是通过函数中的return语句获得的。return语句将被调用函数中的一个确定值带回主调函数中去。

return语句后面的括号可以要，也可以不要。return后面的值可以是一个表达式。

2) 函数值的类型。既然函数有返回值，这个值当然应属于某一个确定的类型，应当在定义函数时指定函数值的类型。

3) 如果函数值的类型和return语句中表达式的值不一致，则以函数类型为准，即函数类型决定返回值的类型。对数值型数据，可以自动进行类型转换。

C++函数的调用及函数原型

函数调用的一般形式

函数调用的一般形式为：
    函数名([实参表列]);
如果是调用无参函数，则“实参表列”可以没有，但括号不能省略。如果实参表列包含多个实参，则各参数间用逗号隔开。实参与形参的个数应相等，类型应匹配(相同或赋值兼容)。实参与形参按顺序对应，一对一地传递数据。但应说明，如果实参表列包括多个实参，对实参求值的顺序并不是确定的。

函数调用的方式

按函数在语句中的作用来分，可以有以下3种函数调用方式：

1. 函数语句
   把函数调用单独作为一个语句，并不要求函数带回一个值，只是要求函数完成一定的操作。如例3.1中的printstar( );
2. 函数表达式
   函数出现在一个表达式中，这时要求函数带回一个确定的值以参加表达式的运算。如c=2*max(a, b);
3. 函数参数
   函数调用作为一个函数的实参。如：
   m=max(a, max(b, c));  //max(b, c)是函数调用，其值作为外层max函数调用的一个实参

对被调用函数的声明和函数原型

在一个函数中调用另一个函数(即被调用函数)需要具备以下条件：

1. 首先被调用的函数必须是已经存在的函数。
2. 如果使用库函数，一般还应该在本文件开头用#include命令将有关头文件“包含”到本文件中来。
3. 如果使用用户自己定义的函数，而该函数与调用它的函数(即主调函数)在同一个程序单位中，且位置在主调函数之后，则必须在调用此函数之前对被调用的函数作声明。

所谓函数声明(declare)，就是在函数尚在未定义的情况下，事先将该函数的有关信息通知编译系统，以便使编译能正常进行。

【例3.3】对被调用的函数作声明。 

#include <iostream>
using namespace std;
int main( )
{
   float add(float x,float y);  //对add函数作声明
   float a,b,c;
   cout<<"please enter a,b：";
   cin>>a>>b;
   c=add(a,b);
   cout<<"sum="<<c<<endl;
   return 0;
}

float add(float x,float y)//定义add函数
{
   float z;
   z=x+y;
   return (z);
}

#include <iostream>
using namespace std;
inline int max(int, int,  int); //声明函数, 注意左端有inline
int main( )
{
   int i=10, j=20, k=30, m;
   m=max(i, j, k);
   cout<<"max="<<m<<endl;
   return 0;
}

inline int max(int a, int b, int c) //定义max为内置函数
{
   if(b>a) a=b;//求a, b, c中的最大者
   if(c>a)
      a=c;
   return a;
}

C++函数重载

#include <iostream>
using namespace std;
int main( )
{
   int max(int a,int b,int c); //函数声明
   double max(double a,double b,double c); //函数声明
   long max(long a,long b,long c);//函数声明
   int i1,i2,i3,i;
   cin>>i1>>i2>>i3; //输入3个整数
   i=max(i1,i2,i3); //求3个整数中的最大者
   cout<<"i_max="<<i<<endl;
   double d1,d2,d3,d;
   cin>>d1>>d2>>d3; //输入3个双精度数
   d=max(d1,d2,d3); //求3个双精度数中的最大者
   cout<<"d_max="<<d<<endl;
   long g1,g2,g3,g;
   cin>>g1>>g2>>g3; //输入3个长整数
   g=max(g1,g2,g3); //求3个长整数中的最大者
   cout<<"g_max="<<g<<endl;
}

int max(int a,int b,int c) //定义求3个整数中的最大者的函数
{
   if(b>a) a=b;
   if(c>a) a=c;
   return a;
}

double max(double a,double b,double c)//定义求3个双精度数中的最大者的函数
{
   if(b>a) a=b;
   if(c>a) a=c;
   return a;
}

long max(long a,long b,long c)  //定义求3个长整数中的最大者的函数
{
   if(b>a) a=b;
   if(c>a) a=c;
   return a;
}

#include <iostream>
using namespace std;
int main( )
{
   int max(int a,int b,int c);  //函数声明
   int max(int a,int b);  //函数声明
   int a=8,b=-12,c=27;
   cout<<"max(a,b,c)="<<max(a,b,c)<<endl;//输出3个整数中的最大者
   cout<<"max(a,b)="<<max(a,b)<<endl; //输出两个整数中的最大者
}

int max(int a,int b,int c)//此max函数的作用是求3个整数中的最大者
{
   if(b>a) a=b;
   if(c>a) a=c;
   return a;
}

int max(int a,int b)//此max函数的作用是求两个整数中的最大者
{
   if(a>b) return a;
   else return b;
}

C++函数模板

#include <iostream>
using namespace std;
template<typename T>  //模板声明，其中T为类型参数
T max(T a,T b,T c) //定义一个通用函数，用T作虚拟的类型名
{
   if(b>a) a=b;
   if(c>a) a=c;
   return a;
}

int main( )
{
   int i1=185,i2=-76,i3=567,i;
   double d1=56.87,d2=90.23,d3=-3214.78,d;
   long g1=67854,g2=-912456,g3=673456,g;
   i=max(i1,i2,i3); //调用模板函数，此时T被int取代
   d=max(d1,d2,d3); //调用模板函数，此时T被double取代
   g=max(g1,g2,g3); //调用模板函数，此时T被long取代
   cout<<"i_max="<<i<<endl;
   cout<<"f_max="<<f<<endl;
   cout<<"g_max="<<g<<endl;
   return 0;
}

int max(int a, int b, int c)
{
    if(b>a) a=b;
    if(c>a) a=c;
    return a;
}

C++函数的默认参数

#include <iostream>
using namespace std;
int main( )
{
   int max(int a, int b, int c=0);//函数声明,形参c有默认值
   int a,b,c;
   cin>>a>>b>>c;
   cout<<"max(a,b,c)="<<max(a,b,c)<<endl;//输出3个数中的最大者
   cout<<"max(a,b)="<<max(a,b)<<endl; //输出2个数中的最大者
   return 0;
}

int max(int a,int b,int c)  //函数定义
{
   if(b>a) a=b;
   if(c>a) a=c;
   return a;
}

• 如果函数的定义在函数调用之前，则应在函数定义中给出默认值。如果函数的定义在函数调用之后，则在函数调用之前需要有函数声明，此时必须在函数声明中给出默认值，在函数定义时可以不给出默认值(如例3.8)。
• 一个函数不能既作为重载函数，又作为有默认参数的函数。因为当调用函数时如果少写一个参数，系统无法判定是利用重载函数还是利用默认参数的函数，出现二义性，系统无法执行。

C++函数的嵌套调用

图 3.7

#include <iostream>
#include <iomanip>
#include <cmath>
using namespace std;
double f(double);  //函数声明
double xpoint(double, double);  //函数声明
double root(double, double); //函数声明
int main( )
{
   double x1,x2,f1,f2,x;
   do
   {
      cout<<"input x1,x2:";
      cin>>x1>>x2;
      f1=f(x1);
      f2=f(x2);
   } while(f1*f2>=0);
   x=root(x1,x2);
   cout<<setiosflags(ios::fixed)<<setprecision(7);
   //指定输出7位小数
   cout<<"A root of equation is "<<x<<endl;
   return 0;
}

double f(double x)  //定义f函数,以实现f(x)
{
   double y;
   y=x*x*x-5*x*x+16*x-80;
   return y;
}

double xpoint(double x1, double x2) //定义xpoint函数,求出弦与x轴交点
{
   double y;
   y=(x1*f(x2)-x2*f(x1))/(f(x2)-f(x1)); //在xpoint函数中调用f函数
   return y;
}

double root(double x1, double  x2) //定义root函数,求近似根
{
   double x,y,y1;
   y1=f(x1);
   do
   {
      x=xpoint(x1,x2); //在root函数中调用xpoint函数
      y=f(x); //在root函数中调用f函数
      if (y*y1>0)
      {
         y1=y;
         x1=x;
      }
      else
         x2=x;
   }while(fabs(y)>=0.00001);
   return x;
}

C++函数的递归调用

int f(int x)
{
    int y, z;
    z=f(y); //在调用函数f的过程中，又要调用f函数
    return (2*z);
}

图 3.9


图3.10

图 3.11

#include <iostream>
using namespace std;
int age(int);//函数声明
int main( )//主函数
{
cout<<age(5)<<endl;
return 0;
}

int age(int n)//求年龄的递归函数
{
int c; //用c作为存放年龄的变量
if(n==1) c=10;  //当n=1时，年龄为10
else c=age(n-1)+2;  //当n>1时，此人年龄是他前一个人的年龄加2
return c; //将年龄值带回主函数
}

#include <iostream>
using namespace std;
long fac(int);//函数声明
int main( )
{
    int n;//n为需要求阶乘的整数
    long y;  //y为存放n!的变量
    cout<<"please input an integer ：";  //输入的提示
    cin>>n;  //输入n
    y=fac(n);//调用fac函数以求n!
    cout<<n<<"!="<<y<<endl; //输出n!的值
    return 0;
}

long fac(int n)  //递归函数
{
    long f;
    if(n<0)
    {
        cout<<"n<0,data error!"<<endl; //如果输入负数,报错并以-1作为返回值
        f=-1;
    }
    else if (n==0||n==1) f=1;  //0!和1!的值为1
    else f=fac(n-1)*n;//n>1时,进行递归调用
    return f;//将f的值作为函数值返回
}

C++(三):函数