C++学习笔记整理-函数

前面几章大体上和C差不多，就从函数开始吧。

第三章 函数

1 .函数的定义与使用

函数定义的语法形式：

类型标识符  函数名（形式参数表）
{  
   语句序列
}

• 若无返回值，类型标识符写void
• 形式参数表：是被初始化的内部变量，寿命和可见性仅限于函数内部

函数的调用

调用前先声明函数：

• 若函数定义在调用点之前，则无需另外声明；
• 若函数定义在调用点之后，则需要在调用函数前按如下形式声明函数原型：

类型标识符 被调用函数名（含类型说明的形参表）;

调用形式：

函数名（实参列表）

• 嵌套调用： 在一个函数的函数体中，可以调用另一函数，称为嵌套调用。
• 递归调用： 函数直接或间接调用自身。

//1.编写一个求x的n次方的函数

#include 
using namespace std;

//计算x的n次方
double power(double x,int n)
{
    double val=1.0;
    while(n--)
        val*=x;
    return val;
}

int main()
{
    cout << "5 to the power 2 is :"<< power(5, 2) << endl;
    return 0;
}

//2.数制转换
//输入一个8位二进制数，将其转换为十进制数输出。
//例如：11012=1(23)+1(22)+0(21)+1(20)=1310 
//所以，如果输入1101，则应输出13

#include 
using namespace std;

double power (double x,int n); //计算x的n次方

int main()
{
    int  value=0;
    cout <<"Enter an 8 bit binary number ";
    for (int i=7;i>=0;i--) 
    {
      char ch;
      cin>>ch;
      if (ch =='1')
            value+=static_cast(power(2, i));
    }
    cout<<"Decimal value is "<

/*3.编写程序求π的值
π=16arctan(1/5)-4arctan(1/239)
其中arctan用如下形式的级数计算：
arctanx=x-x^3/3+x^/5-x^7/7+...
直到级数某项绝对值不大于10-15为止；π和x均为double型。*/

#include 
using namespace std;

double arctan(double x)
{
    double sqr = x * x;
    double e = x;
    double r = 0;
    int i = 1;
    while (e / i > 1e-15) {
        double f = e / i;
        r = (i % 4 == 1) ? r + f : r - f;
        e = e * sqr;
        i += 2;
    }
    return r;
}

int main() 
{
    double a = 16.0 * arctan(1 / 5.0); 
    double b = 4.0 * arctan(1 / 239.0); 
    /* 注意：因为整数相除结果取整，如果参数写1/5，1/239，结果就都是0 */

    cout << "PI = " << a - b << endl;
    return 0;
}

/*4.寻找并输出11~999之间的数m，它满足m、m2和m3均为回文数。
回文：各位数字左右对称的整数。
例如：11满足上述条件 
112=121，113=1331。
分析：
10取余的方法，从最低位开始，依次取出该数的各位数字。按反序重新构成新的数，比较与原数是否相等，若相等，则原数为回文。*/

#include 
using namespace std;
//判断n是否为回文数
bool symm(unsigned n)
{
  unsigned i = n;
    unsigned m = 0;
    while (i > 0) {
      m = m*10+i%10;
      i/=10;
  }
  return m==n;
}

int main()
{
    for(unsigned m = 11; m < 1000; m++)
      if (symm(m) && symm(m * m) &&
          symm(m * m * m)) {
        cout << "m = " << m;
        cout << "  m * m = " << m * m;
        cout << "  m * m * m = "
             << m * m * m << endl;
      }
    return 0;
}

/5.计算如下公式，并输出结果：
$$
k = \begin{cases} \sqrt{sin^2r+sin^2s} & \text{}\ 当r^2\leqslant s^2\ \frac{1}{2}sin(rs) & \text{}\ 当r^2> s^2& \end{cases}
$$
其中r、s的值由键盘输入

sin x的近似值按如下公式计算，计算精度为10-10：

$$ sinx=\frac{x}{1!}+\frac{x^3}{3!}+\frac{x^5}{5!}+\frac{x^7}{7!}+…=\displaystyle \sum_{n=1}^∞(-1)^{n-1}\frac{x^{2n-1}}{(2n-1)!} $$

#include 
#include   /*对C++标准库中数学函数的说明*/
using namespace std;

const double TINY_VALUE = 1e-10;

double tsin(double x) 
{
    double g = 0;
    double t = x;
    int n = 1;
    do {
        g += t;
        n++;
        t = -t * x * x / (2 * n - 1) / (2 * n - 2);
    } while (fabs(t) >= TINY_VALUE); 
    return g;
} 

int main() 
{
    double k, r, s;
    cout << "r = ";
    cin >> r;
    cout << "s = ";
    cin >> s;
    if (r * r <= s * s)
      k=sqrt(tsin(r)*tsin(r)+tsin(s)*tsin(s));
    else
      k = tsin(r * s) / 2;
    cout << k << endl;
    return 0;
}



//运行结果：
r=5
s=8
1.37781

/*6.投骰子的随机游戏

每个骰子有六面，点数分别为1、2、3、4、5、6。游戏者在程序开始时输入一个无符号整数，作为产生随机数的种子。
每轮投两次骰子，第一轮如果和数为7或11则为胜，游戏结束；和数为2、3或12则为负，游戏结束；和数为其它值则将此值作为自己的点数，继续第二轮、第三轮...直到某轮的和数等于点数则取胜，若在此前出现和数为7则为负。
由rolldice函数负责模拟投骰子、计算和数并输出和数。

rand
函数原型：int rand(void);
所需头文件：
功能和返回值：求出并返回一个伪随机数

srand
函数原型：void srand(unsigned int seed);
参数：seed产生随机数的种子。
所需头文件：
功能：为使rand()产生一序列伪随机整数而设置起始点。使用1作为seed参数，可以重新初化rand()。*/

#include 
#include 
using namespace std;

//投骰子、计算和数、输出和数
int rollDice() {
    int die1 = 1 + rand() % 6;
    int die2 = 1 + rand() % 6;
    int sum = die1 + die2;
    cout << "player rolled " << die1 << " + " << die2 << " = " << sum << endl;
    return sum;
}

enum GameStatus { WIN, LOSE, PLAYING };

int main() {
    int sum, myPoint;
    GameStatus status;

    unsigned seed; 
    cout<<"Please enter an unsigned integer: ";
    cin >> seed;//输入随机数种子
    srand(seed);//将种子传递给rand()

    sum = rollDice(); //第一轮投骰子、计算和数

switch (sum) {
    case 7:   //如果和数为7或11则为胜,状态为WIN
    case 11:
      status = WIN;
      break;
    case 2:   //和数为2、3或12则为负,状态为LOSE
    case 3: 
    case 12:
      status = LOSE;
      break;
    default: /*其它情况,游戏尚无结果,状态为
            PLAYING,记下点数,为下一轮做准备 */
      status = PLAYING;
      myPoint = sum;
      cout << "point is " << myPoint << endl;
      break;
    }

while (status == PLAYING) { //只要状态仍为PLAYING,就继续进 行下一轮
      sum = rollDice();
      if (sum == myPoint)    //某轮的和数等于点数则取胜
        status = WIN;
      else if (sum == 7)    //出现和数为7则为负
        status = LOSE;
    }

    //当状态不为PLAYING时上面的循环结束,以下程序段输出游戏结果
    if (status == WIN)
      cout << "player wins" << endl;
    else
      cout << "player loses" << endl;

    return 0;
}
//运行结果：
Please enter an unsigned integer:23
player rolled 6 + 3 = 9
point is 9
player rolled 5 + 4 = 9
player wins

嵌套调用

//1.输入两个整数，求平方和

#include 
using namespace std;

int fun2(int m) 
{
    return m * m;
}

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

int main() 
{
    int a, b;
    cout<<"Please enter two integers (a and b): ";
    cin >> a >> b;
    cout << "The sum of square of a and  b: " << fun1(a, b) << endl;
    return 0;
}


//运行结果：
Please enter two integers(a and b): 3 4
The sum of square of a and b: 25

递归调用

//1.求n!
$$
n!= \begin{cases} 1 & \text{}\ (n=0) \ n(n-1)! & \text{}\ (n> 0) \ \end{cases}
$$

#include 
using namespace std;

unsigned fac(int n)
{
    unsigned f;
    if (n == 0)
      f = 1;
  else
      f = fac(n - 1) * n;
  return f;
}

int main() 
{
    unsigned n;
    cout << "Enter a positive integer:";
    cin >> n;
    unsigned y = fac(n);
    cout << n << "! = " << y << endl;
    return 0;
}

//运行结果：
Enter a positive integer:8
8! = 40320

/*2.用递归法计算从n个人中选择k个人组成一个委员会的不同组合数。

分析：
   由n个人里选k个人的组合数 = 由n-1个人里选k个人的组合数+由n-1个人里选k-1个人的组合数
当n = k或k = 0时，组合数为1*/

#include 
using namespace std;

int comm(int n, int k) {
    if (k > n)
      return 0;
    else if (n == k || k == 0)
      return 1;
    else
      return comm(n - 1, k) + comm(n - 1, k - 1);
}

int main() {
    int n, k;
    cout << "Please enter two integers n and k: ";
    cin >> n >> k;
    cout << "C(n, k) = " << comm(n, k) << endl;
    return 0;
}

3.汉诺塔问题

有三根针A、B、C。A针上有N个盘子，大的在下，小的在上，要求把这N个盘子从A针移到C针，在移动过程中可以借助B针，每次只允许移动一个盘，且在移动过程中在三根针上都保持大盘在下，小盘在上。

分析：

• 将n 个盘子从A针移到C针可以分解为下面三个步骤：
• ①将A 上n-1个盘子移到 B针上（借助C针）;
• ②把A针上剩下的一个盘子移到C针上;
• ③将n-1个盘子从B针移到C针上（借助A针）;
• 事实上，上面三个步骤包含两种操作：
• ①将多个盘子从一个针移到另一个针上，这是一个递归的过程。 hanoi函数实现。
• ②将1个盘子从一个针上移到另一针上。 用move函数实现

//3.汉诺塔问题

#include 
using namespace std;

//把src针的最上面一个盘子移动到dest针上
void move(char src, char dest) { 
    cout << src << " --> " << dest << endl;
}

//把n个盘子从src针移动到dest针，以medium针作为中介
void hanoi(int n, char src, char medium, char dest) {
    if (n == 1)
      move(src, dest);
    else {
      hanoi(n - 1, src, dest, medium);
      move(src, dest);
      hanoi(n - 1, medium, src, dest);
    }
}

int main() {
    int m;
    cout << "Enter the number of diskes: ";
    cin >> m;
    cout << "the steps to moving " << m << " diskes:" << endl;
    hanoi(m,'A','B','C');
    return 0;
}

//运行结果：
Enter the number of diskes:3
the steps to moving 3 diskes:
A --> C
A --> B
C --> B
A --> C
B --> A
B --> C
A --> C

函数的参数传递

• 在函数被调用时才分配形参的存储单元。
• 实参可以是常量、变量或表达式。
• 实参类型必须与形参相符。
• 值传递是传递参数值，即单向传递。
• 引用传递可以实现双向传递
• 常引用作参数可以保障实参数据的安全

引用传递

引用(&)是标识符的别名,例如:

int i,j;
int &ri=i;//建立一个int型的引用ri,并将其初始化为变量i的一个别名
j=10;
ri=j;//相当于 i = j;

声明一个引用时，必须同时对它进行初始化，使它指向一个已存在的对象。 一旦一个引用被初始化后，就不能改为指向其它对象。 引用可以作为形参:

void swap(int &a, int &b) {...}
//1.输入两个整数交换后输出

#include
using namespace std;
void swap(int& a, int& b) {
    int t = a;
    a = b;
    b = t;
}
int main() {
    int x = 5, y = 10;
    cout << "x = " << x << "  y = " << y << endl;
    swap(x, y);
    cout << "x = " << x << "  y = " << y << endl;
    return 0;
}

//运行结果:
x = 5   y = 10
x = 10  y = 5

//2.值传递与引用传递的比较

#include 
#include 
using namespace std;
void fiddle(int in1, int &in2) 
{
    in1 = in1 + 100;
    in2 = in2 + 100;
    cout<<"The values are ";
    cout << setw(5) << in1;
    cout << setw(5) << in2 << endl;
}

int main() { 
  int v1=7,v2=12;
  cout << "The values are ";
  cout << setw(5) << v1;
  cout << setw(5) << v2 << endl;
  fiddle(v1, v2);
  cout << "The values are ";
  cout << setw(5) << v1;
  cout << setw(5) << v2 << endl;
  return 0;
}

2.内联函数

• 声明时使用关键字 inline。
• 编译时在调用处用函数体进行替换,节省了参数传递、控制转移等开销。
• 内联函数体内不能有循环语句和switch语句。
• 内联函数的声明必须出现在内联函数第一次被调用之前。
• 对内联函数不能进行异常接口声明。

//example:

#include 
using namespace std;

const double PI = 3.14159265358979;
inline double calArea(double radius) {
    return PI * radius * radius;
}

int main() {
    double r = 3.0;
    double area = calArea(r);
    cout << area << endl;
    return 0;
}

3.带默认参数值的函数

函数在声明时可以预先给出默认的形参值，调用时如给出实参，则采用实参值，否则采用预先给出的默认参数值。

例如：

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 = 1, int y = 5, int z);//错误
int add(int x = 1, int y, int z = 6);//错误

默认参数值与函数的调用位置

如果一个函数有原型声明，且原型声明在定义之前，则默认参数值必须在函数原型声明中给出；而如果只有函数的定义，或函数定义在前，则默认参数值需在函数定义中给出。 例：

int add(int x = 5,int y = 6);        int add(int x = 5,int y = 6) {
//原型声明在前                         //只有定义，没有原型声明
int main() {                         return  x + y;
  add();                             }
}                                    int main() {
int add(int x,int y) {               add();
//此处不能再指定默认值                   }
  return x + y;
}

4.函数重载

C++允许功能相近的函数在相同的作用域内以相同函数名声明，从而形成重载。方便使用，便于记忆。

例：

//形参类型不同
int add(int x, int y);
float add(float x, float y);

//形参个数不同
int add(int x, int y);
int add(int x, int y, int z);

/*1.计算长方体的体积

子函数getVolume是计算体积的函数，有三个形参：length（长）、width（宽）、height（高），其中width和height带有默认值。
主函数中以不同形式调用getVolume函数，分析程序的运行结果。*/

#include 
#include 
using namespace std;

int getVolume(int length, int width = 2, int height = 3);

int main() {
    const int X = 10, Y = 12, Z = 15;
    cout << "Some box data is " ;
    cout << getVolume(X, Y, Z) << endl;
    cout << "Some box data is " ;
    cout << getVolume(X, Y) << endl;
    cout << "Some box data is " ;
    cout << getVolume(X) << endl;
    return 0;
}

int getVolume(int length, int width/* = 2 */, int height/* = 3 */) {
    cout << setw(5) << length << setw(5) << width << setw(5) << height << '\t';
    return length * width * height;
}

注意事项

• 重载函数的形参必须不同:个数不同或类型不同。
• 编译程序将根据实参和形参的类型及个数的最佳匹配来选择调用哪一个函数。

int add(int x,int y);                     int add(int x,int y);
int add(int a,int b);                     void add(int x,int y);
//编译器不以形参名来区分                        //编译器不以返回值来区分

• 不要将不同功能的函数声明为重载函数，以免出现调用结果的误解、混淆。这样不好：

int add(int x, int y)               float add(float x,float y)
{  return x + y;  }                 {  return x - y;  }
//编写两个名为sumOfSquare的重载函数，分别求两整数的平方和及两实数的平方和。



#include 
using namespace std;

int sumOfSquare(int a, int b) {
    return a * a + b * b;
}
double sumOfSquare(double a, double b) {
    return a * a + b * b;
}
int main() {
    int m, n;
    cout << "Enter two integer: ";
    cin >> m >> n;
    cout << "Their sum of square: " << sumOfSquare(m, n) << endl;

    double x, y;
    cout << "Enter two real number: ";
    cin >> x >> y;
    cout << "Their sum of square: " << sumOfSquare(x, y) << endl;

    return 0;
}


//运行结果：
Enter two integer: 3 5
Their sum of square: 34
Enter two real number: 2.3 5.8
Their sum of square: 38.93

5.使用C++系统函数

C++的系统库中提供了几百个函数可供程序员使用。 例如：求平方根函数（sprt）、求绝对值函数（abs）等。

使用系统函数时要包含相应的头文件。 例如：cmath 或 math.h

/*1.从键盘输入一个角度值，求出该角度的正弦值、余弦值和正切值。

分析：
系统函数中提供了求正弦值、余弦值和正切值的函数：sin()、cos()、tan()，函数的说明在头文件cmath中。*/


#include 
#include 
using namespace std;

const double PI = 3.14159265358979;

int main() {
    double angle;
    cout << "Please enter an angle: ";
    cin >> angle;   //输入角度值

    double radian = angle * PI / 180;   //转化为弧度值
    cout << "sin(" << angle << ") = " << sin(radian) <