C++——函数

1、函数的声明与调用

函数在面向对象的程序设计中是对功能的抽象。其语法形式：

类型标识符函数名（含类型说明的形式参数表）{语句序列}，函数的返回值用return给出，其中类型标识符在没有返回值的情况下写成void，则不谢return，形式参数被初始化的内部变量，寿命和可见性仅限于函数内部。

函数的调用前先声明函数原型，调用形式：函数名（实参列表）。可以嵌套调用，但是不能嵌套定义。

例如：

#include <iostream>
using namespace std;
double power (double x, int n);//函数声明，也可以出现在main函数中调用该函数之前。
int main()
{
 cout <<  "5 to the power 2 is " << power(5,2) << endl;
 //函数调用作为一个表达式出现在输出语句中。
}
double power (double x, int n)
{
 double val = 1.0;
 while (n--)
 val *= x;
 return(val);
}//结果：5 to the power 2 is 25

　　

      
                                                            
函数的调用执行过程                                      嵌套调用

#include <iostream>
using namespace std;
int main()
{ int a,b;
 int fun1(int x,int y);
 cin>>a>>b;
 cout<<"a、b的平方和："<<fun1(a,b)<<endl;}

int fun1(int x,int y)
{ int fun2(int m);
 return (fun2(x)+fun2(y));}

int fun2(int m)
{ return (m*m);} //运行结果：3，4 a、b的品方和：25.

　　

递归调用

函数直接或者间接的调用自身称为递归调用。包括递推和回归。

#include <iostream>
using namespace std;
long fac(int n)//函数定义
{
 long f;
 if (n<0) cout<<"n<0,data error!"<<endl;
 else if (n==0) f=1;
 else f=fac(n-1)*n;
 return(f);
}

int main()
{
 long fac(int n);//函数声明
 int n;
 long y;
 cout<<"Enter a positive integer:";
 cin>>n;
 y=fac(n);
 cout<<n<<"!="<<y<<endl;
} //运行结果：Enter a position interger:8  8!=40320

　　

函数的传递机制

函数形参不占任何内存空间，只有在被调用时才分配形参的存储单元；实参可以是常量、变量或者表达式；实参类型必须和形参相符合；传递时是传递参数值，即单向传递。

#include<iostream>
using namespace std;
void Swap(int a, int b); //改成void Swap(int &a, int &b);即可，a和b即将成为某个变量的别名。

int main()
{
 int x(5), y(10);
 cout<<"x="<<x<<"    y="<<y<<endl;
 Swap(x,y);
 cout<<"x="<<x<<"    y="<<y<<endl;

return 0；
}

void Swap(int a, int b)//交换a,b 改成void Swap(int &a, int &b);即可
{
 int t;
 t=a;
 a=b;
 b=t;
}//这个程序没有完成希望的交换功能，因为函数传递仅仅是数值，在形式结合之后，形参和实参的关系就切断了，

　　

为了实现成功的交换，可以采用引用做形参，引用就是标识符的别名，例如int i,j; int &ri=i; ri=j;就相当于i=j。声明一个引用时，必须同时对它进行初始化，使他指向一个已经存在的对象，一旦引用被初始化后，就不能改为指向其他对象。

内联函数声明和使用

内联函数兼顾了程序的结构和运行开销两个方面，编译时在调用处用函数体进行替换，节省了参数传递和控制转移等开销。内敛函数体内不能有循环和switch语句，而且声明必须出现在内联函数第一次被调用之前，不能进行异常接口的声明。声明时使用inline关键字。例如：

#include<iostream>
using namespace std;
inline double CalArea(double radius)  //内联函数，计算圆的面积
{ return 3.14*radius*radius;}

int main()
{ double r(3.0);  //r是圆的半径
 double area;
 area=CalArea(r); 
 //调用内联函数求圆的面积，编译时此处被替换为CalArea函数体语句，不用去该函数的函数体计算再回调结果
 cout<<area<<endl;}

　　

默认形参值的作用

有默认形参值的函数在调用时若给出实参就采用实参的值，否则就用形参的值。

int add(int x=5,int y=6)

{ return x+y; }
int main()
{   add(10,20);//10+20
    add(10);  //10+6
    add();  //5+6 }

　　

默认形参值必须从右向左的顺序声明，并且在默认形参值的右面不能有非默认形参值的参数，因为实参取代形参是从左到右的。

int add(int x,int y=5,int z=6);//正确
int add(int x=6,int y=5,int z);//错误
int add(int x=5,int y,int z=6);//错误

 

当调用出现在函数体实现之前时，默认形参值必须出现在函数原型中；而当调用出现在函数体实现之后时，默认形参需在函数实现时给出。例如：

 int add(int a=6,int b=6);//函数原型        int add(int a=6,int b=6){return a+b;}//函数体实现
int main(){                                 int main(){add();//调用在实现之后}
add();//函数调用}
int add(int a,int b){return a+b;}//函数体实现

　　

默认形参值的作用域

在相同的作用域中默认形参必须保持一致，但是在不同作用域内，默认形参可以不一样。

int add(int x=1,int y=2);
int main()
{ int add(int x=3,int y=4);
  add();//使用局部默认形参值（实现3+4）
}
void fun()
{   ...
  add();//使用全局默认形参值（实现1+2）
}

　　

函数重载的声明

同一个函数名称对应相近（同）的功能，出现在相同作用域内，形成重载。重载函数形参必须不同：参数类型不同或者参数个数不同。返回值类型不作为区分函数的标识，不要将不同功能的函数声明为重载函数。

#include<iostream>
using namespace std;
struct complex
{
 double real;
 double imaginary;
};
int main()
{
 int m, n;
 double x, y;
 complex c1, c2, c3;
 int add(int m, int n);
 double add(double x, double y);
 complex add(complex c1, complex c2);
 cout<<"Enter two integer: ";
 cin>>m>>n;
 cout<<"integer "<<m<<'+'<<n<<"="<<add(m,n)<<endl;
 cout<<"Enter two real number: ";
 cin>>x>>y;
 cout<<"real number "<<x<<'+'<<y<<"= "<<add(x,y)<<endl;
 cout<<"Enter the first complex number: ";
 cin>>c1.real>>c1.imaginary;
 cout<<"Enter the second complex number: ";
 cin>>c2.real>>c2.imaginary;
 c3=add(c1,c2);
 cout<<"complex number ("<<c1.real<<','<<c1.imaginary<<")+("
  <<c2.real<<','<<c2.imaginary<<")= ("<<c3.real<<','<<c3.imaginary<<")
";
}
int add(int m, int n)
{  return m+n; }
double add(double x, double y)
{  return x+y; }
complex add(complex c1, complex c2)
{
    complex c;
 c.real=c1.real+c2.real;
 c.imaginary=c1.imaginary+c2.imaginary;
 return c;
}

　　

C++系统函数

使用系统函数需要包含相应的头文件，cmath。例如：

#include<iostream>
#include<cmath>
using namespace std;
const double pi(3.14159265);
int main()
{
    double a,b;
    cin>>a;
    b=a*pi/180;
    cout<<"sin("<<a<<")="<<sin(b)<<endl;
    cout<<"cos("<<a<<")="<<cos(b)<<endl;
    cout<<"tan("<<a<<")="<<tan(b)<<endl;
}

　　

//运行结果：
30
sin(30)=0.5
cos(30)=0.866025
tan(30)=0.57735
查联机帮助——VC++6.0联机帮助的使用方法：
help/Contents
->(“活动子集”栏)Visual C++
Documentation
  ->Visual C++ Documentation
  ->Using Visual C++
  -> Visual C++ Programmer's Guide
  -> Run-Time Library Reference
  ->Run Time Routines by Category
  -> Run Time Routines by Category