函数学习总结

一.知识点

1.语法形式

数据类型函数名（形式参数表）

{

函数体

}

注：（1）数据类型指返回值类型（void无返回值）

（2）形参表可空，但（）不可省

2.函数调用三种方式

（1）传数值

实参赋值给形参，在被调用函数中形参值可以改变，但不影响主调函数的实参值，主函数的值仍为调用前的值，例如用swap函数交换ab两数的值，但主函数实参值不改变，没有达到交换的目的。

（2）传引用

return每次只能返回一个值，当返回两个及以上变量值时可以用传引用，即给变量起别名，引用传递方式是在函数形参前面加上“&”。

例：void swap（int &a,int &b）

{ int temp=a;a=b;b=temp;}

int main()

{ int c=1,d=2;

swap(c,d);

cout<<c<<‘’<<d<<endl;

return 0;}

输出结果为2 1

（3）传地址

指针：存地址即存储位置的变量

定义形式：类型标识符 *变量名此处类型标识符为目标变量的类型例：int *i_point

重要代码: int*p； int &x=y; p=&x; y=*p;

使用示例：{int i;

int *i_point =&i;//说明语句

*i_point=3;//正常语句}

注：<1>指针变量只能指向 同一类型 的变量，即整型指针变量只能指向整型数据的地址，而不能放其它类型数据的地址。

例：int i; int *i_point =&i；

<2> 说明变量时，加*指定义指针变量，加&指引用变量即起别名

正常语句中，&代表求地址，指针变量前加*代表取指针变量代表的目标变量

示例：{ int i;

int *i_point =&i;//说明语句定义i_point为指针变量存变量i的地址

*i_point=3;//正常语句将3赋值给指针i_point指向的变量i }

<3>绝对不能对未赋值的指针变量作“取内容”运算。

3.指针与数组

数组名是数组的起始地址，数组的指针是数组的起始地址，数组元素的指针是数组元素的地址。

说明：<1>数组名a做形参时表数组第一个变量的地址， a是常量，指向数组的开始元素，a+i指向数组的第i个元素的指针

指针变量pa是变量，可以变，但数组a不可变，只能当做常量指针使用，例：p=p+2合法但a=a+2不合法 p+i或a+i 均表示a[i]的地址&a[i]

<2>p+1指向数组的下一个元素，而不是下一个字节.

例

int  a[10];
int  *p=a;     
*p=1;   
a[0]=1;   
*(p+1)=2;
a[1]=2;

<3> 形参与实参都用数组名，用数组名作形参，因为接收的是地址，所以可以不指定具体的元素个数。

int main( )
{  int  array[10];
    ......
    f(array, 10);
    .....
}
f(int  arr[ ], int n)
 {
        ......
}

<4> 实参用数组名，形参用指针变量

int main( )
{  int  a [10];
    ......
    f(a, 10);
    .....
}
f(int *x, int n )
{
        ......
}

<5> 形参实参都用指针变量

int main( )
{  int  a [10]，*p;
    p=a;
    ......
    f(p, 10);
    .....
}
f(int *x, int n )
 {
        ......
}

4.递归调用

直接或间接调用自身的函数称为递归函数递归的实质就是自己调用自己，用调用自己的方法去处理问题，使问题变得简洁

递归的关键：找出大问题与小问题的关系，调用次数有限，找出停止条件

递归的基本思想：将问题分解，把一个不能或不好解决的大问题转化为一个或几个小问题，再把这些小问题进一步分解为更小问题最小问题可以直接解决。

例：欧几里得算法

{ if (n==0) return( );

else return gcd（n，m%n）；

}

N!=N*(N-1)! (N>0)

N!=1 (N=0)

int f(int n)
{return n==0?1:n*f(n-1);
}

二.重点题型

1.计算C(m,n)的值

c(m,n)=m!/((m-n)!n!)

int main()
{cin>>m>>m;
cout<<fac(m)/(fac(m-n)*fac(n));}
int fac(int x)
{int s=1;
for(int i=1;i<=x;i++)
s*=i;
return  s;}

2.定义函数check（n,d）,返回布尔值，若数字d在正整数n某位出现则返回true，否则返回false

int main（）
{int a,b;
cin>>a>>b;
if (check(a,b)==true)cout<<"true"<<endl;
else cout<<"false"<<endl;
return 0;}
bool check (int n,int d)
[while (n)
{int e=n%10;
n/=10;
if (e==d) return true;}
return false;}

3.冒泡法对数组元素从小到大排序

int main（）
{int array[10]={11,4.,55,6,77,8,9,0,7,1}
for (int i=0;i<10;i++)
cout<<array[i]<<','<<endl;
bubble (array,10);
for (int i=0;i<10;++i)
cout<<array[i]<<','<<endl;
return 0;}
void bubble (int a[],int n)
{for (int i=1;i<n-i;++i)
{for (int j=0;j<n-i;++j)
if (a[j]>a[j+1]
{int temp=a[j];a[j]=a[j+1];a[j+1]=temp;}
}}

4.最小公倍数

int main()
{cin>>x>>y;
cout<<lcm()<<endl;
return 0;}
int lcm()
{return x*y/gcd(x,y);}
int gcd(int x,int y)
{int r=x%y;
while (r)
{x=y;y=r;r=x%y;}
return y;}

5.判断素数

分析：整数i，从2开始到sqrt（i），找i的第一个约数，若找到i的第一个约数，则必定不是素数

int main()
{int n;cin>>n;
if (p(n))
cout<<"yes";
else cout<<"no";
return 0;}
int p(int x)
{int j; 
if (x==2) return 1;
j=2;
while(j<=sqrt(x)&&x%j!=0) j++;
if (x%j==0）return 0；
else return1；}

6.放苹果

把M个同样的苹果放在N个同样的盘子里，允许有的盘子空着不放，问共有多少种不同的分法？（用K表示）5，1，1和1，5，1 是同一种分法。

输入第一行是测试数据的数目t（0 <= t <= 20）。以下每行均包含二个整数M和N，以空格分开。1<=M，N<=10。

输出对输入的每组数据M和N，用一行输出相应的K

int f(int m, int n){  
    if (m == 1 || n == 1)
        return 1;  
    else if (m < n)  
        return f(m, m);
    else if (m>n) 
        return f(m, n - 1) + f(m - n, n);
    else  
        return 1 + f(m, n - 1);  
}  
  
int main()
{  
    int t, m, n;  
    cin >>t;
for (int i=1;i<=t;i++) 
{cin>>m>>n;
    cout <<f(m, n) <<endl;  }
    
}

三.心得体会

学c++已经大半年了，刚开始接触的时候就感觉挺难的，开始学的c部分就学了点皮毛，现在开始学函数部分了，写法部分有一点不大适应，尤其是递归方面的题目。递归的关键是有解题的思路，最难的部分也是思路，只有想出思路才有用递归解题的可能，找到大问题与小问题的内在关系，其次找到递归结束的条件，否则函数就会陷入死循环。指针变量对我来说也是一大难点，使用方式千变万化，使用起来比较方便，但是学习起来比较难理解，指针与数组结合起来函数简洁明了，平时可以尝试使用练习，增加熟练度，加强对指针的理解，为今后写出更加简单的代码做一下准备。

做有智慧的懒人这句话并不是那么容易就能做到的，懒人人人想做，人人也都能做，但是重点就在于智慧二字上，如何才称为有智慧，又如何成为有智慧的人，我想这肯定与平时勤奋的积累离不开的，知其然，知其所以然，只有平时多积累，多做准备，各种知识了然于胸，才能在今后做到胸有成竹，高效率，高品质，低消耗，高水平的完成工作，表面上的懒并不是真的懒，而在于平时的勤奋给自己了懒的实力，有了懒的资本。