函数

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

  {

         语句序列

  }

                                     

                 无参函数：无参数传递，一般无需带回函数值，说明为void

分类：      有参函数 ：有参数传递，一般需要待会函数值

                 空函数：只有一对花括号

注意事项：

1.函数体中由return语句返回的值的类型。没有返回值其类型为void

2.函数不允许嵌套定义，但可嵌套使用

3.函数为一个复合语句，类型与语句可有可无

4.一般形式为：  类型 参数1  ，类型 参数2 ，… ，类型  参数n

5.不再执行后续语句，程序控制返回调用点，一个函数体内可以有多个return语句

6.表达式 返回值的类型与函数类型不相同时，自动强制转换成函数的类型

1. 传值调用

   这种调用方式实际只是将原本的实参值拷贝一个副本放入被调用函数的栈区中，而在被调用的函数中，形参值可以随意改变，不影响主函数中的实参值。

例如：

#include<bits/stdc++.h>

using namespace std;

viod swap（inta,int b)

{

     int t=a;a=b;b=t;

}

int main()

{

     int c=1,d=2;

     swap(c,d)

     cout<<c<<""<<d<<endl;

     return 0;

}                //最终输出为1  2

这个例子中只是在swap函数中交换了a,b的值，而在main 中却没有交换。

在主函数中，swap函数只是交换了c,d两个变量副本的值，实参却没有交换，并没有达到目的。

 

2. 传址调用

利用将实参的地址值传递给形参，从而直接让形参指向实参，达到交换的目的

例如：

#include<bits/stdc++.h>

using namespace std;

viod swap（int &a,int &b) //形参是传址调用，&a,&b代表将地址值传递给形参

{

     int t=a;a=b;b=t;

}

int main()

{

     int c=1,d=2;

     swap(c,d)

     cout<<c<<""<<d<<endl;

     return 0;

}                //最终输出为2  1

注：也可用指针变量来解决

1. 指针变量定义及赋值

              说明                                                             样例

   类型说明符    *指针变量名；                     int a=10;        int *p;

      取地址运算符   ：&                                p=&a; 

      间接运算符 ：   *                                    *p=20;

  指针变量直接存取的是内存地址                  cout<<p;     结果不是数值

  间接存取才是储存类型的值                        cout<<*p;     结果不是数值

其中不允许将数值赋予指针变量，如：int *p;  p=10;  是错误的

而且被赋值的指针变量前不能再加“*”说明符，如  *p=&a;  是错误的

在说明int时前加*代表定义指针

int *p

int &x=y

p=&x

y=*p

   

*(a+i)等同于a[I]

*(p+i)等同于p[I]

 

指针用法举例：

#include <bits/stdc++.h>

using namespace std;

void swap(int *,int *);

int main()

{

     int a=3,b=4;

     cout<<"a="<<a<<"b="<<b<<endl;

     swap(&a,&b);

    cout<<"a="<<a<<"b="<<b<<endl;            //此时a,b的值交换

     return 0;

}

void swap(int *x, int *y)

{

     int t=*x;

     *x=*y;

     *y=t;

}                                 //此时x,y所代表的位置交换

 

举例：函数冒泡排序

 #include<iostream>
  #include<algorithm>

 using namespace std;

 int main()

 {

    int a[10]={9,6,3,8,5,2,7,4,1,0};

    for(int i=0;i<10;i++)

    cout<<a[i]<<endl;

   sort(a,a+10);

    for(int i=0;i<10;i++)

    cout<<a[i]<<endl;

    return 0;

 }

 

#include<bits/stdc++.h>

using namespace std; 

viod mao(int [],int);                //相当于 viod  mao(int a[],int n); 

int main（）

{    

      int b[10]={1,2,3,4,5,6,7,8,9,10};         //大数据组应开为全局变量

      cout<<"排序前“；

      for(int i=0;  i<10; i++)

          cout<<b[i]<<',';

      cout<<endl;

      mao(b,10);

      cout<<"排序后";

      for(int i=0;  i<10; i++)

           cout<<b[i]<<',';

      cout<<endl;

      return 0;

}

viod mao(int a[],int n)

{    

      for(int i=1;  i<n; i++)

          {

               for(int j=0;  j<n-i;  j++)

                  if(a[j]>a[j+1])                                //判断并交换变量

                    {

                         int t=a[j];  a[j]=a[j+1]; a[j+1]=t;

                    }

           }

}

举例：哥德巴赫猜想，编程6~100所有偶数标识成两个素数之和

#include<cstdio>

#include<cmath>

int n,x;

bool  ss(int i)     //判读素数

{

int x=2;

while(x<=floor(sqrt(i))&&i%x!=x) x++;

if(x>floor(sqrt(I)) return true;

else return flase;

}

int main()

{

for(int x=6;x<=100;x+=2)    //枚举6~100

 for(int i=2;i<=x/2;++i)       //将x分解为I和x-i两个数

if(ss(i)&&ss(x-i))

{

 printf("%d=%d+=%d\n",x,i,x-i);   //若被分解两数皆为素数的输出

 break;                                           //退出当前循环，继续枚举其他偶数

}

}

举例：绝对自然数

#include<iostream>

#include<cstring>

int sh(int i);

using namespace std;

int main()

{

 int i;

 for(I=10;i<=99;i++)   //枚举所有两位数

 if((sh(i)==true)&&(sh((i%10)*10+(i/10))==true)

  cout<<I<<endl;   //分别判断i是否是素数以及i变换后的数是否为素数，如果都是就输出

 return 0;

}

int sh(int i)    //判断素数

{

 bool f=false; int x=2;

 while(x<=floor(sqrt(i))&&(i%x!=0))

  x++;

 if(x>florr(sqrt(I))) f=true;   //若是素数就返回true

 return f;

}