c++函数知识总结及例题代码

1.函数的定义：

     返回值类型 函数名（形式参数表）

     {  

           语句序列

}

（1）各个参数类型重复说明（2）不能出现同名参数（3）在一个函数定义内部不能定义另一个函数，但是可以调用或引用说明（4）内部的所有变量都是局部变量

 2.函数的返回值：

      （1） 通过return语句获得，只要遇到一个return语句，立刻返回到主调函数

      （2）函数类型和return不一样时，以函数类型为准

       （3）当函数没有返回值时，必须用void说明，可以没有return语句，如果有return，应该写为return；

3.函数声明

     返回值类型 函数名（形参表）；

   一般把main函数定义放前面，其他函数定义放后面。

4.函数调用

函数名（实参表）

实参与形参一对一传递数据，顺序一致，类型匹配，个数相同。

5.函数的传值调用

      参数值的复制（将实参的值复制了一份给形参）。因此执行被调函数时，只能访问形参对应的空间，不能直接访问实参对应的单元，因此无法改变实参的值

6.默认值参数：

   在编写函数时为形参提供一个默认值

   模拟商场收款计算商品总价的函数。

    double totalcost(double unitprice,int num=1,double discountrate=0.8)

  {

    Return num*unitprice*discountrate

}  

   实参和形参的结合从左到右，在有默认值的形参的右边，不能有无默认值的形参

   不能同时在声明处和定义处同时对参数的默认值进行说明。

7.函数重载（一名多用）

     在同一范围内声明几个功能相似的同名函数，但是形参（个数，类型，顺序至少有一种）必须不同。

     仅仅返回类型不同，不构成函数重载！！！

8.函数模板

     建立一个通用函数，其函数类型和形参不具体指定，用一个虚拟类型代替。仅仅是函数类型和形参不同而函数体相同的重载函数都可以用这个模板代替。

     定义函数模板一般形式

   template<typename T> 或 template<class T>

   只适用于函数的形参个数相同而类型不同

9.函数的嵌套使用

10.递归函数

    直接调用自己或者借助其他函数间接调用自己的函数。  

递归的终止条件

11.作用域

      生存期和作用域是从时间和空间两个不同的角度描述变量的特性

       作用域6种：（1）块作用域（2）函数作用域（3）函数原型作用域 最小（4）文件作用域（5）类作用域（6）命名空间作用域

12.存储类别描述符

  （1）auto自动变量

         局部变量如果不用static声明，编译系统默认它们为自动变量，动态的分配存储空间，可省去auto

         生存期开始于程序块的开始执行时刻，终止于所在程序块的结束时刻。

  （2）extern 声明全局变量

       在函数之外定义，作用域从变量的定义处开始，到本程序文件的末尾。

       在多文件中，一个文件定义，另一个用extern作全局变量说明

（3）register寄存器变量（了解）

  （4）static 静态变量

       采取静态存储，但采取静态存储的不一定是静态变量。

  基本类型的静态局部变量，没赋初值，自动赋予0，自动变量不赋予初值，不确定。

  静态全局变量为源文件独享。

  加不加static修饰的全局变量都采用静态存储，只不过加了static的作用域限制在所在文件。

1. 内部函数，外部函数

根据能否被其他文件中的函数调用，分类。

1. 内部函数（静态函数）

static类型标识符 函数名（形参表）

static int fun（int）

1. 外部函数

extern int fun（int a，int b）

  只要函数不被static修饰，就是外部函数，extern为默认修饰符

1. 预处理指令

#include ，#define，#error，#if，#else，#eilf，#endif，#ifdef，#ifndef，#undef，#line，#pragma

（1）#include<iostream>  到环境变量指定的系统变量中查找

#include“iostream”在源文件所在的当前目录中查找

（2）#define 宏名（参数表） 字符串

#define S（a，b） （a）*（b）//a，b为宏的参数

（3）#if常量表达式

      程序段1

     #else

      程序段2

     #endif

     如果#if指令后的常数表达式为true，编译程序段1到目标文件；否则，编译程序段2到目标文件

（4）#ifdef 宏替换名   =    #if define

   #ifndef  宏替换名   =   #if ！define

//调用函数时实参和形参间的数据传递。
#include<iostream>
using namespace std;
int main()
{
    int Max(int x,int y);    //函数声明，x，y为形参
    int a=5,b=9,c;
    c=Max(a,b);              //函数调用，a，b为实参，第7行
    cout<<"maxValue="<<c<<endl;
    return 0;
}
int Max(int x,int y)         //函数定义
{
    return x>y?x:y;
}
//利用interchange函数交换实参的值
#include<iostream>
using namespace std;
void interchange(int,int);
int main()
{
    int m=10,n=20;
    cout<<"调用函数之前（实参）："<<"m="<<m<<",n="<<n<<endl;
    interchange(m,n);
    cout<<"调用之后（实参）："<<"m="<<m<<",n="<<n<<endl;
    return 0;
}
void interchange(int x,int y)
{
    cout<<"交换之前（形参）："<<"x="<<x<<",y="<<y<<endl;
    int temp;
    temp=x;
    x=y;
    y=temp;
     cout<<"交换之后（形参）："<<"x="<<x<<",y="<<y<<endl;
}
//使用函数重载计算不同类型变量（int，double，long）的绝对值。
#include<iostream>
using namespace std;
int main()
{
    int abs(int);
    long abs(long);
    double abs(double);
    int i=-10,iresult;
    double d=-56.87,dresult;
    long g=-6785432,gresult;
    iresult=abs(i);
    dresult=abs(d);
    gresult=abs(g);
    cout<<"abs("<<i<<")="<<iresult<<endl;

    cout<<"abs("<<d<<")="<<dresult<<endl;
     cout<<"abs("<<g<<")="<<gresult<<endl;
    return 0;
}
int abs(int a)
{
    return a>=0?a:-a;
}
long abs(long a)
{
     return a>=0?a:-a;
}
double abs(double a)
{
     return a>=0?a:-a;
}
//使用函数重载计算不同类型变量（int，double，long）的绝对值。
//用函数模板实现
#include<iostream>
using namespace std;
template<typename T>    //模板声明，t为类型参数
T abs(T a) //定义一个通用函数，T为虚拟类型名
{
    if(a>=0) return a;
    else return -a;
}
int main()
{
    int i=-10,iresult;
    double d=-56.87,dresult;
    long g=-6785432,gresult;
    iresult=abs(i);
    dresult=abs(d);
    gresult=abs(g);
    cout<<"abs("<<i<<")="<<iresult<<endl;

    cout<<"abs("<<d<<")="<<dresult<<endl;
     cout<<"abs("<<g<<")="<<gresult<<endl;
    return 0;
}
//用弦截法求下面方程的根
//f（x）=x^3-5x^2+16x-80=0
#include<iostream>
#include<iomanip>
#include<cmath>
using namespace std;
double f(double);      //代表交点横坐标x的函数
double xpoint(double,double);   //求（x1，f（x1）），（x2，f（x2））的连线与x轴的交点（x，0）的坐标
double root(double,double);    //求区间（x1，x2）的那个实根
//执行root要调用xpoint函数，执行xpoint要调用f函数
int main()
{
    double x1,x2,f1,f2,x;
    do{
        cout<<"请输入变量x1，x2的值：";
        cin>>x1>>x2;
        f1=f(x1);
        f2=f(x2);
    }while(f1*f2>=0);      //当x1和x2异号循环结束
    x=root(x1,x2);       //求解方程的根
    cout<<setiosflags(ios::fixed)<<setprecision(7); //指定输出7位小数
    cout<<"方程的根："<<x<<endl;
    return 0;
}
double f(double x)  //计算f（x）
{
    double y;
    y=x*x*x-5*x*x+16*x-80;
    return y;
}
double xpoint(double x1,double x2)
{
    double y;
    y=(x1*f(x2)-x2*f(x1))/(f(x2)-f(x1));   //调用f函数
    return y;
}
double root(double x1,double x2)
{
    double x,y,y1;
    y1=f(x1);
    do{
        x=xpoint(x1,x2);
        y=f(x);
        if(y*y1>0){
            y1=y;
            x1=x;
        }
        else
            x2=x;
    }while(fabs(y)>=0.00001);
    return x;
}

//用递归的方法求5的阶乘
#include<iostream>
using namespace std;
int main()
{
    long fac(int);
    cout<<"5!="<<fac(5)<<endl;
    return 0;
}
long fac(int n)
{
    long c;
    if(n==1) c=1;    //递归的终止条件
    else c=fac(n-1)*n;
    return c;
}

//变量的作用域和生存期实例
#include<iostream>
using namespace std;
void a(void);
void c(int i);
int x=1;
int main()
{
    int x=5;
    cout<<"进入main函数时局部变量x（复合语句外部）的值："<<x<<endl;
    {
        int x=7;
        cout<<"main函数中局部变量x（复合语句内部）的值："<<x<<endl;
    }
    cout<<"main函数中局部变量下（复合语句外部）的值"<<x<<endl;
    a();
    c(10);
    a();
    c(10);
    cout<<"退出main函数前局部变量x的值："<<x<<endl;
    return 0;
}
void a()
{
    int x=25;
    cout<<"进入a函数后局部变量x的值为："<<x<<endl;
    x++;
    cout<<"退出a函数后局部变量x的值为："<<x<<endl;
}
void c(int i)
{
    cout<<"进入c函数后全局变量x的值："<<x<<endl;
    x*=i;
    cout<<"退出c函数前全局变量x的值："<<x<<endl;
} 

//extern对全局变量作提前引用说明
#include<iostream>
using namespace std;
int Max(int,int);
int main()
{
    extern int a,b;  //不是定义，是提前引用说明
    cout<<Max(a,b)<<endl;
    return 0;
}
int a=15,b=7;
int Max(int x,int y)
{
    return(x>y?x:y);
}

//静态局部变量的值。
#include<iostream>
using namespace std;
int fun(int);
int main()
{
    int a=2;
    for(int i=0;i<3;i++)
        cout<<"第"<<i+1<<"次调用后的值："<<fun(a)<<endl;
    return 0;
}
int fun(int a)
{
    int b=0;
    static int c=3;
    b=b+1;
    c=c+1;
    return a+b+c;
}
 
//编写函数求解300-400范围内的素数
个人解法：
#include<iostream>
#include<cmath>
using namespace std;
void sushu(int,int);
int main()
{
    int a,b;
    cin>>a>>b;
    sushu(a,b);
    return 0;
}
void sushu(int a,int b)
{
    int i,j;
    int n=sqrt(b);
    for(j=a;j<=b;j++)
    {
      for(i=2;i<=n;i++)
       {
        if(j%i==0)break;
       }

    if(i>=n+1) cout<<j<<" ";
    }
}
教材解法
#include<iostream>
#include<cmath>
using namespace std;
int main()
{
    bool isprime(int);
    int x,n=0;
    for(x=301;x<400;x+=2)
    {
        if(isprime(x))
        {
            cout<<x<<" ";
            n++;
            if(n%10==0)
                cout<<endl;
        }
    }
    return 0;
}
bool isprime(int num)
{
    if(num<=1)return false;
    int b=sqrt(double(num));
    int i;
    for(i=2;i<=b;i++)
        if(num%i==0)
                break;
    if(i>=b+1) return true;
    else       return false;
}
//汉诺塔问题。假设有3根针A,B,C，A上有N个盘子，大的在下，小的在上，要将N个盘子从A移到C，每次只能移动一个，可以借助B，
//始终保证大的在下，小的在上。
//递归问题
//disknum还没有移动的盘子数，sourcepole没有移动的盘子原来所在的针
//targetpole是没移动的盘子要去的针，midpole是所要借助的针编号
#include<iostream>
using namespace std;
void movedisks(int,char,char,char);
int main()
{
    movedisks(3,'A','C','B');
    return 0;
}
void movedisks(int disknum,char sourcepole,char targetpole,char midpole)
{
    if(disknum==1)
        cout<<sourcepole<<"->"<<targetpole<<endl;//只有一个盘子时，直接从原针到目标针，递归终止条件
    else{
        movedisks(disknum-1,sourcepole,midpole,targetpole);//把N-1个盘子从A移到到B
         cout<<sourcepole<<"->"<<targetpole<<endl;
          movedisks(disknum-1,midpole,targetpole,sourcepole);
    }
}