【C++基础】函数介绍

本文收录于 《C++编程入门》专栏，从零基础开始，分享C++编程入门相关的内容，欢迎关注，谢谢！

一、前言

函数是C++程序的核心组成部分，用于封装可重复使用的代码逻辑。本文将系统介绍C++函数的定义、调用、参数传递、重载机制及高级特性等等，通过实际代码示例展示其应用场景。

众所周知，C++ 是一种‌通用、高性能的编程语言‌，支持‌多范式编程‌（面向对象、泛型、过程化），由本贾尼·斯特劳斯特卢普（ ‌Bjarne Stroustrup‌ ）于 1985 年基于 C 语言扩展而来。

官网地址：https://cplusplus.com/doc/

参考手册：https://cppreference.cn/w/

话不多说，我们一起进入正题吧。

二、函数介绍

1. 函数基础

• 定义与声明
  函数由函数头（返回类型、名称、参数列表）和函数体组成。例如：

// 函数声明（头文件或类外提前声明）
int addNumbers(int a, int b);

// 函数定义（函数体实现）
int addNumbers(int a, int b) {
    return a + b;
}

int main() {
    int sum = addNumbers(2, 3); // 调用函数，sum = 5
}

• 调用与返回值
  函数通过名称和参数列表调用，返回值由return语句指定。例如：

int divide(int a, int b) {
    if (b == 0) {
        throw std::invalid_argument("Division by zero!");
    }
    return a / b;
}

int main() {
    try {
        int result = divide(10, 2); // result = 5
        std::cout << "Result: " << result << std::endl;
    } catch (const std::exception& e) {
        std::cerr << e.what() << std::endl;
    }
}

---

2. 参数传递方式

C++支持三种参数传递方式，影响函数对实参的修改效果：

• 传值调用（默认）
  传递参数副本，函数内修改不影响实参。例如：

void modifyValue(int x) {
    x = 100; // 修改副本，不影响外部变量
}

int main() {
    int num = 42;
    modifyValue(num);
    std::cout << num; // 输出仍为 42
}

• 指针调用
  传递参数地址，允许函数修改实参。例如：

void modifyValuePtr(int* x) {
    *x = 100; // 通过指针修改外部变量
}

int main() {
    int num = 42;
    modifyValuePtr(&num);
    std::cout << num; // 输出变为 100
}

• 引用调用
  传递参数引用（别名），效率高于指针且更安全。例如：

void modifyValueRef(int& x) {
    x = 100; // 直接修改外部变量
}

int main() {
    int num = 42;
    modifyValueRef(num);
    std::cout << num; // 输出变为 100
}

---

3. 函数重载（Function Overloading）

允许在同一作用域定义同名函数，但参数列表必须不同（类型、数量或顺序）。例如：

void print(int x) {
    std::cout << "int: " << x << std::endl;
}

void print(const char* s) {
    std::cout << "string: " << s << std::endl;
}

void print(double d) {
    std::cout << "double: " << d << std::endl;
}

int main() {
    print(42);      // 调用 int 版本
    print("Hello"); // 调用 char* 版本
    print(3.14);    // 调用 double 版本
}

---

4. 内联函数（Inline Function）

使用inline关键字定义的函数，编译器会在调用处展开代码，减少函数调用开销。例如：

inline int square(int x) { return x * x; }

int main() {
    int result = square(5); // 编译器直接替换为 5 * 5
    std::cout << result << std::endl;
}

注意：内联函数适用于短小频繁调用的函数，过多内联可能导致代码膨胀。编译器也可能忽略inline建议（如递归函数）。

---

5. 递归函数（Recursion）

函数直接或间接调用自身，需明确终止条件避免栈溢出。例如阶乘函数：

int factorial(int n) {
    if (n == 0) return 1;  // 终止条件
    else return n * factorial(n - 1);
}

int main() {
    int f5 = factorial(5);  // 计算 5! = 120
    std::cout << f5 << std::endl;
}

---

6. Lambda表达式（Lambda Expressions）

C++11引入的匿名函数，Lambda 表达式，可捕获上下文变量，常用于算法回调或临时逻辑。

Lambda 表达式本质上与函数声明非常类似。Lambda 表达式具体形式如下:

[capture](parameters)->return-type{body}

例如：

#include <vector>
#include <algorithm>

int main() {
    // 定义加法 lambda
    auto addLambda = [](int a, int b) { return a + b; };
    int result = addLambda(1, 2);  // 调用，result = 3
   
}

---

7. 函数指针（Function Pointer）

指向函数的指针，可用于动态调用或作为参数传递。例如：

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

int main() {
    // 定义函数指针
    int (*mathOp)(int, int) = add;
    int result = mathOp(2, 3); // result = 5

    // 动态切换函数
    mathOp = subtract;
    result = mathOp(5, 2); // result = 3

    // 作为参数传递函数指针
    void applyOp(int(*func)(int, int), int a, int b) {
        int r = func(a, b);
        std::cout << r << std::endl;
    }
    applyOp(add, 4, 1); // 输出 5
}

---

8. 构造函数（Constructors）

特殊函数，用于初始化类对象，名称与类相同且无返回值。例如：

class Person {
public:
    // 默认构造函数
    Person() {
        std::cout << "Default Constructor" << std::endl;
    }

    // 带参数构造函数
    Person(const std::string& name, int age)
        : mName(name), mAge(age) {
        std::cout << "Constructor with name and age" << std::endl;
    }

private:
    std::string mName;
    int mAge;
};

int main() {
    Person p1; // 调用默认构造函数
    Person p2("Alice", 30); // 调用带参数构造函数
}

---

9. 其他高级特性

• 默认参数
  函数声明中为参数指定默认值，调用时可省略部分参数。例如：

void logMessage(const std::string& msg, bool printTime = true) {
    if (printTime) {
        std::cout << "[Time]: ";
    }
    std::cout << msg << std::endl;
}

int main() {
    logMessage("Hello");        // 输出带时间戳
    logMessage("World", false); // 仅输出消息
}

• constexpr函数
  返回值可在编译期计算的函数，常用于常量表达式。例如：

constexpr int fibonacci(int n) {
    return (n <= 1)? n : fibonacci(n - 1) + fibonacci(n - 2);
}

int main() {
    constexpr int fib5 = fibonacci(5); // fib5 在编译期计算为 5
    std::cout << fib5 << std::endl;
}

• 函数模板（Function Templates）
  参数化函数，支持泛型编程。例如：

template <typename T>
T maxOfThree(T a, T b, T c) {
    return std::max(std::max(a, b), c);
}

int main() {
    int maxInt = maxOfThree(1, 2, 3);      // 自动推导为 int
    double maxDouble = maxOfThree(2.5, 1.2, 3.7); // double
}

---

10. 标准库函数

C++标准库提供大量实用函数，如：
● cout/cin：控制台输入输出
● std::max/min：求最大值/最小值
● std::sqrt：计算平方根
● std::abs：取绝对值

例如：

#include <iostream>  // 必须包含头文件
#include <algorithm> // 使用max函数需包含algorithm
#include <cmath>     // 使用sqrt需包含cmath

int main() {
    int a = 10, b = 20;
    int maxVal = std::max(a, b);  // 使用库函数求最大值
    double area = std::sqrt(25); // 计算平方根
    std::cout << "Max: " << maxVal << ", Sqrt: " << area << std::endl;
    return 0;
}

---

三、总结

C++函数通过灵活的参数传递、重载机制及高级特性（如lambda、函数指针、模板），实现了代码复用与抽象。实际编程中，需根据场景选择合适的函数特性，兼顾效率与可读性。希望对大家有帮助，谢谢。

如果您对文章中内容有疑问，欢迎在评论区进行留言，我会尽量抽时间给您回复。如果文章对您有帮助，欢迎点赞、收藏。您的点赞，是对我最大的支持和鼓励，谢谢 :-）