c++函数

一，函数基础
1.函数一般用一个名字表示，即函数名。

返回类型，函数名，参数列表，和函数体构成了函数定义。

函数定义的语法形式

类型说明符   函数名（含类型说明的形式参数表）

{

 函数体

}

例一个求阶乘的函数：

int fact(int n)
{
    int sum=1;
    for(int j=2;j<=n;j++)
        sum*=j;
    return sum;
}
1.
2.
3.
4.
5.
6.
7.
函数的声明：让计算机知道，我们自定义了一个函数，这就是函数的声明（Declare）。

声明表示该函数存在，而定义表示该函数怎么去运行，在调用函数之前，必须先声明函数

2.递归函数

直接或者间接调用自己的函数称为递归函数。

例如计算阶乘的函数也可这样写

int fact(int n)
{
    if(n>1)
        return n*fact(n-1)
    return 1;
}
1.
2.
3.
4.
5.
6.
使用递归函数必须有一个终止条件，否则会陷入无限递归调用。

通常的调用方法是把递归放到if语句中。

二，参数传递
也就是调用方式

类型

说明

​ ​传值调用​​

该方法把参数的实际值复制给函数的形式参数。在这种情况下，修改函数内的形式参数对实际参数没有影响。

​ ​指针调用​​

该方法把参数的地址复制给形式参数。在函数内，该地址用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。

​ ​引用调用​​

该方法把参数的引用复制给形式参数。在函数内，该引用用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。

1.传值调用

#include<iostream>
using namespace std;
int Leo(int x,int y);//自定义函数求x,y乘积
int main()
{
    int a,b;
    cin>>a>>b;
    cout<<Leo(a,b);//输出a*b
    return 0;
}
int Leo(int x,int y)
{
return x*y;
}
 2.指针调用

#include<iostream>
using namespace std;
void Leo(int *x,int *y);//自定义函数交换x,y
int main()
{
    int a,b;
    cin>>a>>b;
    Leo(&a,&b);//交换a,b
    cout<<a<<endl<<b;//输出交换后的a,b
    return 0;
}
void Leo(int *x,int *y)
{
    int temp=*x;
    *x=*y;
    *y=temp;
}

 

3.引用调用

引用调用就像是给已声明的变量起一个“绰号”—引用名

变量数据类型 &引用名=已声明的变量名;

#include<iostream>
using namespace std;
void swap(int &x,int &y);//自定义交换函数
Int main()
{
  int a=2,b=3;
  swap(a,b);
  cout<<a<<endl;//交换后 输出3
  cout<<b<<endl;//交换后 输出2
  return 0；
}
void swap(int &x,int &y)//对x,y操作，就是对 a,b 操作 x,y是 a,b 的 “绰号”
{
    int temp;
    temp=x;
    x=y;
    y=temp;
}

三，函数重载
函数重载的本质就是多个函数共用同一个函数名

#include<iostream>
using namespace std;
int myabs(int a);//自定义求绝对值函数
float myabs(float a);
double myabs(double a);
int main()
{
    int a=-1,b=2;
    float c=-2.2f,d=3.9f;
    double e=-3e-9,f=3e6;
    cout<<"a="<<myabs(a)<<endl;
    cout<<"b="<<myabs(b)<<endl;
    cout<<"c="<<myabs(c)<<endl;
    cout<<"d="<<myabs(d)<<endl;
    cout<<"e="<<myabs(e)<<endl;
    cout<<"f="<<myabs(f)<<endl;
    return 0;
}
int myabs(int a){
    cout<<"int abs"<<endl;
    return (a>=0?a:-a);//如果a>=0 则返回a 否则返回-a
}
float myabs(float a){
    cout<<"float abs"<<endl;
    return (a>=0?a:-a);//如果a>=0 则返回a 否则返回-a
}
double myabs(double a){
    cout<<"double abs"<<endl;
    return (a>=0?a:-a);//如果a>=0 则返回a 否则返回-a
}

输出结果

int abs
a=1
int abs
b=2
float abs
c=2.2
float abs
d=3.9
double abs
e=3e-009
double abs
f=3e+006

重载函数就来解决 名字相同，功能类似，参数不一样的函数，系统会自动识别，这一点不需要我们来考虑。