C++青少年简明教程：C++函数

C++青少年简明教程：C++函数

C++函数是一段可重复使用的代码，用于执行特定的任务，可以提高代码的可读性和可维护性。函数可以接受参数（输入）并返回一个值（输出），也可以没有参数和返回值。

按函数是否由系统定义：分为库函数（系统函数）和自定义函数。

C++ 标准库提供了大量的程序可以调用的内置函数。例如，函数 strcat() 用来连接两个字符串，函数 memcpy() 用来复制内存到另一个位置。

本文重点介绍自定义函数。

函数定义（Function Definition）格式

<返回类型> <函数名>(<参数列表>)

{

     函数体，执行具体的操作

}

函数定义包括函数的返回类型、名称、参数列表和函数体。

参数列表包括函数接受的参数的类型和名称。可以有零个或多个参数，每个参数由类型和名称组成，并用逗号分隔。

对于C++，main 函数（是程序的入口点）的类型必须是 int。对于自定义函数，函数类型可以是任何类型，包括 void（表示没有返回值）和其他基本数据类型（如 int、float 等等）。如果函数有返回值，则必须在函数体中使用 return 语句返回相应类型的值。在函数体中使用 return 语句时会将程序的执行控制权返回到调用该函数的地方，接着执行调用该函数的语句后面的代码。对于void类型的自定义函数，可以省略 return 语句或者使用“ return;”语句显式地表示函数的结束。

在C++中，函数声明（函数原型声明）是指在使用函数之前提供函数原型的过程。它包括函数的名称、参数列表和返回类型的描述，用于告诉编译器如何调用该函数。当函数的实现位于调用它的代码之后时，你需要提前声明这个函数，告诉编译器这个函数存在。C++函数头文件通常包含函数声明，以便在其他文件中引用和使用这些函数。

函数声明的一般形式为：

返回类型 函数名(参数列表);

例如：

int add(int a, int b); // 声明一个名为 add 的函数，它接受两个 int 类型的参数并返回一个 int 类型的值

【在C++中，用关键字extern可以进行函数声明，但这不是必须的，例如，“extern int add(int a, int b);”。在C++中，如果没有函数体的函数声明，通常都被认为是extern的。

对于函数声明，可以省略参数名，只保留参数类型。所以int js(int n);和int js(int);是等价的。】

函数声明和函数的定义在形式上的区别函数声明没有函数体。函数定义：

int add(int a, int b) {

    return a + b; // 实现 add 函数，返回两个参数的和

}

函数声明是指提供函数原型的过程，用于告诉编译器有一个函数的存在和基本信息；而函数定义是给出函数具体实现的过程，包括函数头和函数体，用于描述函数的行为和实现。

函数调用（Function Call）:

当你想在程序中使用函数时，你会"调用"它。调用函数时，你需要提供必要的参数（如果有的话）——实参。例如：

add(5, 3);

函数的形参和实参

函数的形参（形式参数）是在函数定义中声明的参数，它们用来接受函数调用时传递的实参值。形参在函数执行时起到的是占位符的作用，它们的值在函数调用时由相应的实参传递进来。

函数的实参（实际参数）是在函数调用中传递给函数的值或变量。实参可以是常量、变量、表达式、函数返回值等。当函数被调用时，实参的值被传递给形参，函数将使用这些值进行运算或处理，并可能返回一个结果。

例子：

#include <iostream>
using namespace std;

// 函数声明
int add(int a, int b); 

int main() {
    int x = 5;
    int y = 10;
    int sum = add(x, y); //函数调用 ,x 和 y 是实参，它们的值被传递给 add 函数的形参 a 和 b
    cout << "和: " << sum << endl;
    
    return 0;
}

// 函数定义
int add(int a, int b) {
    return a + b;
}

运行效果：

函数声明（Function Declaration）和函数定义（Function Definition）是两个不同的概念。

函数声明告诉编译器函数的名称、返回类型以及它接受哪些参数。但它不包含函数的实际代码。函数声明通常出现在函数被调用之前，以便编译器知道函数的存在和它的签名（即它的参数和返回类型）。

函数定义提供了函数的实际代码，即函数体。它包含了函数如何执行其任务的详细信息。函数定义也可以被视为函数的完整签名加上函数体。

函数定义中的函数名、返回类型以及参数列表必须与相应的函数声明完全匹配（除了某些特殊情况，如内联函数或模板函数）

在大型程序中，通常将函数声明放在头文件中，而函数定义放在源文件中。这样，其他源文件可以通过包含相应的头文件来使用该函数。

函数调用（Function Call）是执行已定义函数的方式。函数调用时，程序将控制权交给函数，并在函数执行完毕后返回。函数调用作为语句、表达式和参数的使用示例：

#include <iostream>
using namespace std;

int add(int a, int b) {
    return a + b;
}

void printMessage() {
    cout << "Hello, World!" << endl;
}

void displayResult(int result) {
    cout << "Result: " << result << endl;
}

int main() {
    printMessage();  // 作为语句

    int sum = add(5, 3);  // 作为表达式的一部分
    displayResult(sum);   // 作为参数传递

    displayResult(add(2, 2));  // 嵌套使用：作为参数传递时作为表达式的一部分

    return 0;
}

输出结果：

Hello, World!
Result: 8
Result: 4

C++函数参数的传递方式

函数参数传递是指在函数调用时，将实际参数（也称为实参）的值或引用传递给函数的形式参数（也称为形参）的过程。在C++中，当调用一个函数时，你需要提供与函数声明中指定的形参类型和数量相匹配的实参。这些实参可以是变量、常量、表达式或字面值等。

当调用函数时，传递参数的方式有：

1. 值传递（Pass by Value）/传值

将实参的值复制一份传给形参，在函数内对形参进行操作，不会影响到实参。在这种情况下，修改函数内的形式参数对实际参数没有影响。

#include <iostream>
using namespace std; 

void add(int a, int b) {
    cout << "a + b = " << a + b << endl;  
}

int main() {
    int x = 5, y = 10;
    add(x, y); // 值传递方式调用函数
    return 0;
}

2. 引用传递（Pass by Reference）/传地址

将实参的地址传递给形参，在函数内对形参进行操作，就是直接对实参操作。这意味着，修改形式参数会影响实际参数。

#include <iostream>
using namespace std; 

void increment(int &num) {
    num++; // 修改 num 的值
}

int main() {
    int a = 5;
    increment(a); // 引用传递方式调用函数
    cout << "a = " << a << endl; // 输出 a 的值
    return 0;
}

需要注意的是，在使用引用传递方式时，要确保传递的实参是一个变量而非常量或表达式的值。例如，以下代码是无效的：

increment(2 + 3); // 无法编译通过，因为2 + 3不是一个变量

3. 指针传递（Pass by Pointer）/传指针

指针传递（Pass by Pointer）通过传递指向实参的指针，让函数能够访问和修改实参的值。这意味着，修改形式参数会影响实际参数。关于指针以后介绍。

#include <iostream>
using namespace std; 

void increment(int* ptr) {
    (*ptr)++; // 修改 *ptr 所指向的变量的值
}

int main() {
    int a = 5;
    int* ptr = &a;
    increment(ptr); // 通过指针传递实参
    cout << "a = " << a << endl; // 输出 a 的值
    return 0;
}

在 increment 函数中，通过解引用运算符 (*ptr) 访问了实参 a 的值，并对其进行了修改。在 main 函数中，定义了整型变量 a 和指向 a 的指针 ptr，将 ptr 作为参数通过指针传递给了 increment 函数。最后输出了 a 的值，结果为 6。

提示：引用传递和指针传递都是将实参的地址传递给形参。不同的是，引用传递使用了引用类型，而指针传递使用了指针类型。在函数内部，引用和指针都可以用于访问和修改实参的值。具体一点说，通过引用传递，函数形参会成为实参的别名，即形参与实参指向同一块内存空间，在函数内部对形参的修改会直接反映在实参上。通过指针传递，实际参数的地址被复制到指针形参中，通过解引用指针可以访问和修改实参的值。

在大多数情况下，引用传递比值传递需要更少的内存，并更有效。传递指针也是一种传递地址的方式，但是引用更容易使用，并且更不容易出错。

函数参数的默认值

在C++编程中，在定义函数时，可以为函数参数设置默认值。如果在调用函数时未传递参数，则使用默认值。例如：

#include <iostream>
using namespace std;

int sum(int a, int b = 6 ){
    return ( a + b );
}

int main (){
    // 局部变量声明

    int a = 10;
    int b = 20;
    int result;

    // 调用函数计算和

    result = sum(a, b);
    cout << "sum = " << result << endl; //sum = 30 

    // 再次调用函数
    result = sum(a);
    cout << "sum = " << result << endl; //sum = 16

    return 0;
}

C++变量的作用域

C++中变量的作用域是指变量在程序中能够被访问到的范围。按变量的作用域可以将变量分为：

局部变量：变量在某个函数内部定义，只能在该函数内部访问，称为局部变量。

下面是使用了局部变量的例子：

#include <iostream>
using namespace std;
 int main (){
  // 局部变量声明
  int a, b;
  int c;
 
  // 实际初始化
  a = 10;
  b = 20;
  c = a + b;
 
  cout << c;
 
  return 0;
}

全局变量：在所有函数外部定义的变量（通常是在程序的头部），称为全局变量。全局变量一旦声明，在整个程序中都是可用的。

下面是使用了全局变量的例子：

#include <iostream>
using namespace std;

//全局变量
int x = 20;

void func(){
    int x = 10;  //函数内部的局部变量

    cout << "局部变量 x 的值为 : " << x << endl;  //输出 10
    cout << "全局变量 x 的值为 : " << ::x << endl;  //输出 20
}

int main(){
    cout << "初始全局变量 x 的值为 : " << x << endl;  //输出 20
    func();  //调用函数
    cout << "调用函数后的全局变量 x 的值为 : " << x << endl;  //输出 20
    
return 0;
}

示例中，定义了一个全局变量 x，它的值为 20。然后，在 func() 函数内定义了一个名称相同的局部变量 x，它的值为 10。当 func() 函数被调用时，它将输出局部变量 x 和全局变量 x 的值。从输出可以看出，程序优先使用函数内部的局部变量 x，而不是全局变量 x。如果需要使用或修改全局变量的值，则需要在函数中使用作用域解析运算符 :: 来引用全局变量。

在主函数中，我们首先输出全局变量 x 的值，然后调用函数 func()。在调用函数之后，我们再次输出全局变量 x 的值，以此证明函数内部对全局变量的修改并不会影响它的值。从输出可以看出，函数 func() 对全局变量 x 的修改并没有影响它的值，它的值仍然是 20。

练习、判断一个年份是否为闰年是一个常见的编程问题。闰年的规则是：

如果年份能被4整除但不能被100整除，则为闰年。

如果年份能被400整除，也是闰年。

以前（“If选择语句”一节中）提到过这个例子，现在采用自定义函数的方式实现，判断用户输入的年份是否为闰年：

#include <iostream>  
using namespace std;
  
bool isLeapYear(int year) {  
    if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) {  
        return true;  
    } else {  
        return false;  
    }  
}  
  
int main() {  
    int year;  
    cout << "请输入一个年份: ";  
    cin >> year;  
  
    if (isLeapYear(year)) {  
        cout << year << " 是闰年." << endl;  
    } else {  
        cout << year << " 不是闰年." << endl;  
    }  
  
    return 0;  
}

这个程序中，isLeapYear 函数接受一个整数年份作为参数，并返回一个布尔值，表示该年份是否为闰年。main 函数则负责获取用户输入的年份，并调用 isLeapYear 函数进行判断，然后输出相应的结果。

递归函数

在编程中，一个函数直接或间接地调用自身，函数称为递归函数，这种技术被称为递归。

递归函数通常包含两个部分：

基本情况（Base Case）：这是递归的终止条件，即当函数达到某个条件时，它将不再调用自身，而是直接返回结果。没有基本情况，递归函数将会无限地调用自身，导致栈溢出错误。

递归步骤（Recursive Step）：这是函数的主体部分，其中包含了将问题分解为更小子问题的逻辑，并调用自身（称为Recursive call：递归调用）来处理这些子问题。

简单地说，递归是一种函数调用自身的过程。递归函数或算法必须调用自身来解决规模更小的子问题。

我们可以使用一个例子来说明。比如，我们要计算从1到某个数n的总和。

1.我们可以创建一个自定义函数sum，它接受一个参数n，代表要计算总和的范围。

2.在函数内部，我们需要添加一些基本条件来结束递归。在这种情况下，如果n等于1，我们直接返回1。

3.如果n大于1，我们将函数自己调用，并传入n-1作为参数，并将结果与n相加。

4.这个过程会一直进行下去，直到n等于1，然后每个递归函数的返回值都会被加起来。

最后，我们只需调用这个函数并打印出结果即可。

#include <iostream>
using namespace std;

int sum(int n) {
    if (n == 1) {
        return 1;
    }
    else {
        return n + sum(n - 1);
    }
}

int main() {
    int num = 5;  // 假设我们要计算1到5的总和
    int result = sum(num);
    cout << "从1到" << num << "的总和为：" << result << endl;

    return 0;
}

计算阶乘

阶乘（Factorial）是指将一个正整数 n 及小于等于 n 的所有正整数相乘的结果。符号通常用符号 "!" 表示。例如，4的阶乘（写作4!）是4*3*2*1=24。

C++函数来计算阶乘的函数：

int factorial(int n) {
    if (n == 0) {
        return 1;
    } else {
        return n * factorial(n - 1);
    }
}

这个函数的工作方式是这样的：

首先，它检查数字n是否为0。如果是，它返回1。这是因为0的阶乘被定义为1。

如果n不是0，那么函数会返回n乘以n-1的阶乘。这就是递归的部分：函数调用了自己，但是每次调用时，n都会减少1。

例如，如果我们调用factorial(4)，函数会这样工作：

factorial(4)返回4 * factorial(3)

factorial(3)返回3 * factorial(2)

factorial(2)返回2 * factorial(1)

factorial(1)返回1 * factorial(0)

factorial(0)返回1

所以，factorial(3)的结果是4*3 * 2 * 1 * 1 = 24。

图示如下：

下面给出求一个数的阶乘完整代码

使用递归的完整代码：

#include <iostream>
using namespace std;

int factorial(int n) {
    if (n == 0) {
        return 1;
    } else {
        return n * factorial(n - 1);
    }
}

int main() {
    int n;
    cout << "请输入一个正整数: ";
    cin >> n;
    cout << "该数的阶乘为: " << factorial(n) << endl;
    return 0;
}

这个递归示例中，函数名为 factorial，表示计算一个数的阶乘。当输入的参数 n 等于 0 时，是递归的基本情况，递归将结束并返回 1。当 n 不是 0 时，函数将调用自身并传入 n-1 作为参数，直到 n 等于 0。然后递归将回溯，并将每个递归调用返回的值合并，并返回给原始调用者。

作为对比，下面给出非递归实现的代码：

#include <iostream>
using namespace std;

int factorial(int n) {
    int result = 1;
    for (int i = 1; i <= n; i++) {
        result *= i;
    }
    return result;
}

int main() {
    int n;
    cout << "请输入一个正整数: ";
    cin >> n;
    cout << "该数的阶乘为: " << factorial(n) << endl;
    return 0;
}

ＯＫ！

附、C++函数https://blog.csdn.net/cnds123/article/details/108917528