返回专栏
· 18 分钟阅读

函数的定义与调用(Function Definition & Invocation)


一、什么是函数?

函数(Function)是一段具有独立功能、可以被重复调用的程序代码。

它将一组相关操作封装起来,通过明确的输入和输出接口,为程序提供模块化的执行能力。

例如:

def add(a, b):
    return a + b

result = add(10, 20)
print(result)

这里定义了一个 add 函数,用于计算两个数的和。

函数具有以下几个基本特征:

  • 封装性:将一组操作组织为独立的逻辑单元。
  • 复用性:同一个函数可以在不同位置重复调用。
  • 参数化:通过参数接收不同输入。
  • 返回值:通过返回机制向调用者提供计算结果。
  • 抽象性:调用者不需要了解函数内部的具体实现。

函数不仅是代码复用的工具,也是程序控制流、模块边界和软件架构的重要基础。

二、函数的基本组成

一个典型的函数通常由函数名称、参数列表、函数体和返回值组成。

def calculate_area(width, height):
    area = width * height
    return area

各部分含义:

组成部分 示例 作用
函数定义关键字 def 声明一个函数
函数名称 calculate_area 标识函数
参数列表 width, height 接收调用者传入的数据
函数体 area = width * height 执行具体逻辑
返回语句 return area 将结果返回调用者

不同编程语言的函数定义语法有所区别,但核心结构基本一致。

1. Python 函数定义

def add(a, b):
    return a + b

2. Java 函数定义

在 Java 中,通常将函数称为方法(Method),方法必须定义在类或接口等类型结构中。

public class Calculator {

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

3. JavaScript 函数定义

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

JavaScript 还支持函数表达式和箭头函数:

const add = function(a, b) {
    return a + b;
};

const multiply = (a, b) => a * b;

4. C 语言函数定义

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

C 语言函数需要明确指定返回类型和参数类型。

三、函数定义与函数调用

函数定义和函数调用是两个不同的概念。

  • 函数定义:声明函数的名称、参数、返回类型及具体实现。
  • 函数调用:通过函数名称或函数引用,触发函数体执行。

1. 函数定义

def greet(name):
    print("Hello,", name)

执行函数定义语句时,Python 会创建相应的函数对象,并将其绑定到名称 greet。

此时,函数体中的代码通常还没有执行。

2. 函数调用

greet("Alice")

调用函数后,程序才会执行函数体。

3. 定义与调用的执行关系

flowchart TB
    A["编写函数定义"] --> B["创建函数或声明函数"]
    B --> C["程序执行到调用位置"]
    C --> D["准备实参"]
    D --> E["进入函数执行"]
    E --> F["执行函数体"]
    F --> G["返回结果或结束执行"]
    G --> H["调用者继续执行"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style G fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style H fill:#E8EDF2,stroke:#B8C3CE,color:#334155

    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

需要注意,函数定义的执行时机与语言有关。

例如:

  • Python 在执行 def 语句时创建函数对象。
  • JavaScript 会根据声明类型和执行上下文处理函数声明与函数表达式。
  • C 和 Java 通常在编译阶段完成函数或方法的相关处理,运行时执行调用指令。

因此,不能将所有语言的函数定义都理解为运行时才创建函数。

四、参数与实参

参数是函数接收外部数据的接口。

在函数定义和调用过程中,需要区分形式参数(Parameter)与实际参数(Argument)。

1. 形式参数(Parameter)

形式参数是在函数定义中声明的变量。

def add(a, b):
    return a + b

这里的 a 和 b 就是形式参数。

它们用于描述函数需要接收哪些数据。

2. 实际参数(Argument)

实际参数是在调用函数时传入的具体值或表达式。

result = add(10, 20)

这里的 10 和 20 就是实际参数。

3. 形式参数与实际参数的区别

对比维度 形式参数 实际参数
英文 Parameter Argument
出现位置 函数定义 函数调用
本质 参数变量 传入的数据或表达式
作用 描述函数输入接口 提供具体输入

4. 参数传递过程

flowchart TB
    A["调用者准备实际参数"] --> B["执行函数调用"]
    B --> C["按照语言规则进行参数绑定或传递"]
    C --> D["函数获得对应参数"]
    D --> E["使用参数执行函数体"]
    E --> F["产生计算结果"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style F fill:#E8EDF2,stroke:#B8C3CE,color:#334155

    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

参数绑定和底层参数传递并不是同一个层次的概念。

参数绑定属于语言语义,决定实参如何对应到形式参数;底层参数传递则由编译器、运行时和 ABI 决定,可能使用寄存器、栈或其他机制。

五、函数参数的常见形式

不同语言提供了多种参数形式,以满足不同的函数调用需求。

1. 位置参数(Positional Arguments)

根据参数在定义中的位置进行匹配。

def introduce(name, age):
    print(name, age)

introduce("Alice", 25)

对应关系:

  • "Alice" 对应 name。
  • 25 对应 age。

位置参数要求调用顺序与参数定义顺序保持一致。

2. 关键字参数(Keyword Arguments)

通过参数名称指定传入值。

def introduce(name, age):
    print(name, age)

introduce(age=25, name="Alice")

关键字参数不依赖位置顺序,但必须符合语言规定的参数绑定规则。

Python 中,位置参数和关键字参数可以组合使用:

introduce("Alice", age=25)

3. 默认参数(Default Arguments)

在函数定义时为参数指定默认值。

def greet(name, message="Hello"):
    print(message, name)

greet("Alice")
greet("Bob", "Welcome")

输出:

Hello Alice
Welcome Bob

当调用者没有提供 message 时,函数使用默认值。

Python 默认参数的易错点:

默认参数表达式通常在函数定义时求值,而不是每次调用时重新求值。

例如:

def append_item(item, items=[]):
    items.append(item)
    return items

print(append_item(1))
print(append_item(2))

结果:

[1]
[1, 2]

原因是默认列表对象被多次调用共享。

更安全的写法:

def append_item(item, items=None):
    if items is None:
        items = []

    items.append(item)
    return items

4. 可变数量参数(Variadic Arguments)

当函数需要接收数量不固定的参数时,可以使用可变参数。

Python:

def add_all(*numbers):
    return sum(numbers)

print(add_all(1, 2, 3))
print(add_all(1, 2, 3, 4, 5))

*numbers 会将位置参数收集为元组。

Python 还支持 **kwargs,用于收集关键字参数:

def show_info(**kwargs):
    for key, value in kwargs.items():
        print(key, value)

show_info(name="Alice", age=25)

kwargs 会收集为字典。

5. 参数形式对比

参数类型 作用 Python 示例
位置参数 按位置匹配 func(10, 20)
关键字参数 按名称匹配 func(a=10)
默认参数 提供默认值 def func(a=10)
可变位置参数 接收多个位置参数 *args
可变关键字参数 接收多个关键字参数 **kwargs

不同语言的参数机制并不完全相同。例如,Java 使用重载和可变参数,C 使用固定参数列表或特定的可变参数机制。

六、值传递与引用传递

参数传递方式是函数设计中非常容易混淆的概念。

常见说法包括:

  • 值传递(Pass by Value)。
  • 引用传递(Pass by Reference)。

理解这两个概念,需要关注函数调用时,调用者与被调用者之间究竟共享什么。

1. 值传递(Pass by Value)

值传递是指函数接收实参值的副本。

函数内部修改参数变量,不会直接改变调用者的原始变量。

C 语言示例:

#include <stdio.h>

void change(int x) {
    x = 100;
}

int main() {
    int a = 10;

    change(a);

    printf("%d\n", a);
    return 0;
}

输出:

10

原因:

  • a 的值为 10。
  • 调用 change(a) 时,将值复制给参数 x。
  • 修改 x 不会影响 a。

2. 引用传递(Pass by Reference)

引用传递意味着函数参数直接引用调用者提供的变量。

在支持引用参数的语言中,函数可以通过参数修改调用者的变量。

C++ 示例:

#include <iostream>
using namespace std;

void change(int& x) {
    x = 100;
}

int main() {
    int a = 10;

    change(a);

    cout << a << endl;
}

输出:

100

这里的 int& x 是引用参数,x 与调用者的变量 a 指向同一个对象。

3. 指针传递与引用传递的区别

C 语言没有原生的引用参数语法,但可以通过指针实现对调用者数据的间接修改。

void change(int *x) {
    *x = 100;
}

int main() {
    int a = 10;

    change(&a);
}

这里仍然是值传递:传递的是指针值的副本。

但指针副本与原指针指向同一块内存,因此可以通过解引用修改原始变量。

这说明:

值传递不代表一定无法修改调用者的数据,关键在于传递的值是否包含对共享对象的访问能力。

4. Python 的参数传递机制

Python 通常被描述为对象引用传递(Call by Sharing),也称为对象共享传递。

调用函数时,参数名称绑定到传入的对象。

def change(items):
    items.append(100)

data = [1, 2, 3]

change(data)

print(data)

输出:

[1, 2, 3, 100]

函数通过参数访问同一个列表对象,因此列表内容发生变化。

但如果重新绑定参数:

def change(items):
    items = [100, 200]

data = [1, 2, 3]

change(data)

print(data)

输出仍然是:

[1, 2, 3]

原因是函数内部只是让局部名称 items 指向另一个列表,并没有改变调用者名称 data 的绑定关系。

5. 不同语言的参数传递机制

语言 常见参数传递机制
C 值传递,包括指针值
C++ 值传递、引用参数
Java 值传递,包括对象引用值
Python 对象共享传递
JavaScript 值传递,包括对象引用值
Go 值传递,包括指针值
Rust 值传递、借用与可变借用

尤其需要注意:

Java 并不支持传统意义上的引用传递。对象参数传递的是对象引用值的副本,因此可以修改对象内容,但不能通过重新赋值参数改变调用者的引用变量。

七、函数返回值(Return Value)

返回值是函数向调用者输出计算结果的机制。

通过 return 等语言结构,可以结束当前函数执行,并将结果交还给调用者。

1. 返回单个值

def multiply(a, b):
    return a * b

result = multiply(3, 4)
print(result)

返回结果:

12

2. 无返回值函数

部分函数只负责执行操作,不需要返回有意义的结果。

Python:

def log_message(message):
    print(message)

Java:

public void logMessage(String message) {
    System.out.println(message);
}

C:

void log_message(const char *message) {
    printf("%s\n", message);
}

不同语言对无返回值函数的表达方式不同。

Python 函数如果没有显式执行 return,会隐式返回 None。

3. 返回多个值

Python 支持通过元组返回多个结果:

def calculate(a, b):
    return a + b, a - b

sum_value, diff_value = calculate(10, 5)

本质上,函数返回的是一个元组,再通过解包获得其中的值。

其他语言可以使用结构体、对象、元组或多个输出参数实现类似功能。

4. return 的执行特点

return 通常具有两个作用:

  1. 结束当前函数的执行。
  2. 将返回结果交还给调用者。

例如:

def check_number(n):
    if n < 0:
        return "negative"

    return "non-negative"

当条件成立并执行第一个 return 后,当前函数不会继续执行后面的语句。

5. 函数返回过程

flowchart TB
    A["调用者执行函数调用"] --> B["进入函数体"]
    B --> C["执行计算逻辑"]
    C --> D{"是否执行返回语句"}
    D -->|"是"| E["准备返回值"]
    D -->|"否"| F["执行剩余函数逻辑"]
    F --> D
    E --> G["结束当前函数"]
    G --> H["返回调用者"]
    H --> I["接收或处理返回值"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style H fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style I fill:#E8EDF2,stroke:#B8C3CE,color:#334155

    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

八、函数调用的底层执行机制

函数调用不仅是源码层面的语法操作,最终还需要通过编译器、运行时和 CPU 完成实际执行。

一次典型的函数调用涉及:

  • 参数准备。
  • 参数传递。
  • 返回地址保存。
  • 栈帧建立。
  • 函数体执行。
  • 返回值准备。
  • 栈帧恢复。
  • 控制流返回。

1. 函数调用与调用栈

调用栈(Call Stack)是程序运行时用于管理函数调用关系的重要数据结构。

当函数调用另一个函数时,通常需要保存当前函数的执行状态,并为被调用函数建立相应的执行环境。

例如:

def first():
    second()

def second():
    third()

def third():
    print("Hello")

first()

函数调用关系:

flowchart TB
    A["first()"] --> B["second()"]
    B --> C["third()"]
    C --> D["print()"]
    D --> E["返回 third()"]
    E --> F["返回 second()"]
    F --> G["返回 first()"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style G fill:#E8EDF2,stroke:#B8C3CE,color:#334155

    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

调用栈遵循后进先出(LIFO)原则。

函数调用时建立新的调用上下文,函数返回时销毁或退出当前调用上下文。

2. 栈帧(Stack Frame)

每次函数调用通常会关联一个栈帧。

栈帧用于保存函数执行所需的部分状态信息。

常见内容包括:

  • 返回地址。
  • 局部变量。
  • 参数或参数相关信息。
  • 保存的寄存器。
  • 临时计算数据。
  • 栈对齐填充空间。

典型栈帧可以抽象表示为:

高地址
┌────────────────────────┐
│ 调用者栈帧             │
├────────────────────────┤
│ 返回地址               │
├────────────────────────┤
│ 保存的寄存器           │
├────────────────────────┤
│ 局部变量               │
├────────────────────────┤
│ 临时计算空间           │
└────────────────────────┘
低地址

这只是概念性布局。

实际布局取决于 CPU 架构、ABI、编译器优化和运行时实现。

例如:

  • 参数可能通过寄存器传递。
  • 局部变量可能直接分配在寄存器中。
  • 编译器可能省略帧指针。
  • 内联优化可能消除实际函数调用。

3. 函数调用的机器级过程

以 x86-64 为例,普通函数调用通常涉及 call 和 ret 指令。

  • call:保存返回地址,并转移控制流到目标函数。
  • ret:从栈中恢复返回地址,并转移回调用者。

概念过程:

flowchart TB
    A["执行调用指令 call"] --> B["保存返回地址"]
    B --> C["跳转到目标函数"]
    C --> D["执行函数逻辑"]
    D --> E["准备返回值"]
    E --> F["执行返回指令 ret"]
    F --> G["恢复返回地址"]
    G --> H["继续执行调用者代码"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style F fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style H fill:#E8EDF2,stroke:#B8C3CE,color:#334155

    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

需要注意,call 和 ret 是 x86 指令集中的具体机制,并不是所有 CPU 架构都采用相同的函数调用指令。