第三节 函数

1. 内建函数

函数是一组指令，执行特定的任务，程序是有许多函数构成的代码块

C++官方提供了很多已经完成的函数，帮助开发者完成工作，这种函数就是内建函数，比如cin，cout

内建函数的实际代码都被放在其他源代码文件中，使用时需要将其包含至本项目中，包含的方法就是使用#include <>关键字

//使用cmath内建函数库，完成数学运算
#include <iostream>
#include <cmath>
using namespace std;

int main() {
    //pow函数用来完成幂运算
    //sin函数用来完成正弦运算
    
    //计算弹道范围
    double range
    double angle = 60;
    double velocity = 100;
    double  gravity = 9.8;
    range = sin(2 * angle) * pow(velocity, 2) / gravity 
    
    //计算方程的值
    double y;
    double x = 22;
    y = 2 * pow(x , 2) - 1;

    //计算两点间距离
    double x1 = 1.2;
    double y1 = 3.2;
    double x2 = 1.4;
    double y2 = 5.6;
    double length = pow((pow((x1-x2), 2) + pow((y1-y2),2)), 0.5);
    return 0;
}

 2. 自定义函数

程序在执行时，其实就是在不停的调用各种函数完成任务或解决问题。

函数之间，通过参数和返回值进行数据交换。

参数是函数被调用时，需要传递的一些信息，而返回值是函数执行结束后的结果。

比如使用搜索引擎（funcSearch）时，在搜索栏输入的文字（Keywords），就是搜索函数的参数，而获取到的网页链接（SuperLink）就是函数的返回值。

return_type function_name( parameter list )
{
   body of the function
   return value; or return;
}

string funcSearch(string keyWord_1, string keyWord_2)
{
    //todo 
    return "http://...xxx...";
}

//定义方程f(x) = x^2 - 3 * x - 6
float equation(float x)
{
    return pow(x, 2) + 3 * x - 6;
}

//定义求根公式
float proot(float a, float b, float c)
{
    return (-b + pow((pow(b, 2) - 4 * a * c), 0.5)) / (2 * a)
}

float nroot(float a, float b, float c)
{
    return (-b - pow((pow(b, 2) - 4 * a * c), 0.5)) / (2 * a)
}

//void表示空，如果一个函数没有返回值，就使用void作为return_type
//如果一个函数不需要参数，parameter_list就写空白

//一个既没有返回值，也没有参数的函数
void func()
{
}

 

3. 参数的作用域、全局变量、引用参数

变量是具有作用域的，通常而言变量的作用域只在其所在的{}范围内

void funcA(int a, int b)
{
     int c = a + b;
     //todo
}

void funcB()
{
    funcA(1,2);
    //错误，变量a,b,c的作用域只在funcA中有效
    cout << a << b << c;
}

如果希望一个变量，可以在多个函数中使用，就要在函数体外声明该变量，这种变量称为全局变量

// 声明全局变量，作用域为全体代码
// 全局变量在任何地方被访问
int sum = 0;

void funcA()
{
    sum = sum + 100;
}

void funcB()
{
    funcA();
    cout << sum;
}

由于变量具有作用域，因此函数的参数，只在当前函数内有用。

如果希望参数可以在函数体外被使用，就需要使用引用参数。

引用参数，不仅仅拷贝传入的数值，还传入数据的地址，引用参数发生数据改变时，改变的是地址内的数值。

void funcA()
{
   int a = 10;
   int b = 10;
   int c = 0;
   
   funcB(a, b, c);
   
   // a, b, c作为引用参数，传递的是变量的地址
   // a, b, c地址内存储的数值，都被funcB函数修改
   // 结果为a = 5，b = 5，c=0
   cout << a << b << c;
}

void funcB(int &a, int &b, int &c)
{
    a = 5;
    b = 5;
    c = a + b;
}

// 利用引用参数，可以实现函数返回多个数值

// 该函数接受一个用户姓名，并通过引用参数，将姓名分解
// 这样从函数外部就可以实现模拟多个返回值的效果
void func(string yourName, string &firstName, string &midName, string &familyName)
{
    //todo
}

4. 如何设计一个函数

// 函数是为了解决一个问题，而设计的一组具有逻辑关系的代码
// 在进行数学考试时，题目就是人接收到的条件，人脑就是利用这些条件给出解的函数，最后人将答案写在纸上，也就是反馈

// 问题：如何计算n是不是偶数
// 输入条件：n
// 问题：判断n是不是偶数
// 输出内容：是/否
bool /* 输出内容 */ isEven /* 解决的问题 */ (int n /* 输入条件 */)
{
    // 问题解决的逻辑
    return (n % 2 == 0) ? true : false;
}

// 问题：输入两个数字，输出两个数字的组合，如输入1234,2345，输出12342345
// 输入条件：数字a，数字b
// 问题：拼接a和b，并进行输出
// 输出内容：拼接后的数字
int contactNumber (int a, int b)
{
    // 计算a的位数k
    int k = 0;
    int temp = a;
    while(temp / 10 != 0) {
        k++;
        temp = temp / 10;
        // 位移a 
        a = a * 10;
    }
    // 拼接
    return a + b;
}

 

5. 练习（IDE调试）

// 假设城市中每8秒出生1人，每13秒死亡1人，每40秒迁入一名移民，每60秒迁出一名移民，当前人口为200万人，设计一个函数，可以计算n年后当前城市人口数量。

#include <iostream>
using namespace std;

long int CountPeople(long int initPeopleCount, long int afterYears)
{

    long int totalSec = afterYears * 365 * 24 * 60 * 60;

    long int totalBirth = totalSec / 8;

    long int totalDeath = totalSec / 13;

    long int totalEmigration = totalSec / 40;

    long int totalOutmigration = totalSec / 60;

    return initPeopleCount + totalBirth - totalDeath + totalEmigration - totalOutmigration;
}

int main()
{
    cout << CountPeople(20000000000, 4);
    return 0;
}

// 一个函数被自身重复调用的行为，称为递归
// 使用递归函数实现pow方法

double pow(double b, double e)
{
    if(e == 0)
        return 1;
    else if (e == 1)
        return b;
    else
        return b * pow(b, e - 1);
}

// 使用递归函数实现九九乘法表的输出

void MultiplyTable(int a, int b)
{
    if (b != 0)
    {
        cout << a << " * " << b << " = " << a * b << " ";
        MultiplyTable(a, b - 1);
    }
    else if (b == 0 && a != 0)
    {
        cout << endl;
        MultiplyTable(a - 1, a - 1);
        return;
    }
    else if (a == 0)
    {
        return;
    }
}

// 使用<string>库，分别输出用户输入的每一个字符，并把它们变为大写，同时找出ASCII码最大的字符
// 对于字符串中第i个字符的访问方式是使用中括号string[i]的方式进行访问

void MaxLetter(string userInput)
{
    char MaxLetter = -1;
    for (int i = 0; i < userInput.length(); i++)
        if (userInput[i] > MaxLetter)
            MaxLetter = userInput[i];
    cout << MaxLetter;
}

//使用<string>库，完成回文判断函数
bool isPalindrome(string s)
{
    for (int i = 0; i < s.length() / 2; i++)
        if(s[i] != s[s.length() - 1 - i])
            return false;
    return true;
}

// 完成atoi函数（string as to int）

// 为何要注释上using namespace
// 如何避免数据溢出
#include <iostream>
#include <string>
#include <cmath>
//using namespace std;

int atoi(std::string s)
{
    int snum = 0;
    for (int i = s.length(); i > 0; i--)
    {
        snum = snum + (s[i - 1] - 48) * pow(10, (s.length() - i));
    }
    return snum;
}

int main()
{
    std::string s = "56754";
    std::cout << atoi(s);
    
    return 0;
}

 

5. 作业

作业1：创建一个函数，实现pow方法

作业2：创建一个无返回值的函数，在屏幕中输出“Hello”

作业3：创建函数Max_Two，函数具有两个参数a，b。输出最大的那个。

作业4：创建函数Sum，函数具有一个整型参数，计算从1开始到该参数为止的所有数字的和，并在主函数（main）中输出结果。使用全局变量和引用参数分别实现。