深入解析：如何在 C 或 C++ 中从函数返回多个值（含最佳实践）

2026-02-15 20:43:15 0条评论 4次阅读 0人点赞

在 C 和 C++ 的编程旅程中，你一定遇到过这样的困境：我们需要从一个函数中获取多个结果，但这些语言的语法特性似乎并不直接支持“返回多个值”。当你尝试写出类似 return a, b; 的代码时，编译器往往会给你一个意外的结果（通常只返回了最后一个值）。

别担心，虽然 C 和 C++ 没有像 Python 或 Go 那样原生的多返回值语法，但作为底层的强语言，它们赋予了了我们更强大的内存控制权。在这篇文章中，我们将深入探讨几种最常用、最专业的处理方法。我们将从基础的指针操作讲到面向对象的结构体应用，并探讨 C++11 引入的现代解决方案。

为什么这很重要？

在编写实际代码时，函数之间的通信是程序的核心。如果一个函数只能输出一个值，我们往往不得不使用全局变量（这通常是不好的做法）或者把相关的逻辑拆分到多个函数中，这不仅降低了代码的效率，也增加了维护的难度。通过掌握下面的技巧，你将能够编写出更模块化、更高效的代码。

让我们通过一个经典的场景来展开讨论：比较两个整数并找出其中的最大值和最小值。 我们的目标是编写一个函数，能够一次性将这两个结果传递回调用者。

方法一：使用指针（“传引用”调用）

这是 C 语言中最传统、也是最基础的方法。它的核心思想是：不通过返回值传递数据，而是通过内存地址直接修改外部变量。

原理解析

当我们把一个变量的地址（使用 INLINECODE0e892aa1 运算符）传递给函数时，函数内部可以通过指针（解引用 INLINECODE339a0e67）直接访问和修改该地址对应的内存数据。这意味着，我们在函数内部做的任何修改都会直接反映到 main 函数（或调用者）的变量中。

这种方法通常被称为“模拟传引用调用”。

代码示例与详解

下面是一个完整的 C++ 和 C 代码示例。请注意我们如何传递 INLINECODEd48843c8 和 INLINECODEe0814db6 的地址。

#### C++ 实现

#include 
using namespace std;

// 函数定义
// 我们使用 int* 指针来接收变量的地址
void compare(int a, int b, int* ptr_great, int* ptr_small)
{
    if (a > b) {
        // 如果 a 更大，将 a 存入 ptr_great 指向的地址
        *ptr_great = a;
        *ptr_small = b;
    }
    else {
        // 否则，将 b 存入 ptr_great 指向的地址
        *ptr_great = b;
        *ptr_small = a;
    }
}

int main()
{
    int great, small, x, y;

    cout <> x >> y;

    // 关键点：使用 & 运算符传递变量的内存地址
    compare(x, y, &great, &small);

    cout << "
较大的数字是: " << great 
         << " 较小的数字是: " << small << endl;

    return 0;
}

#### C 语言实现

#include 

void compare(int a, int b, int* ptr_great, int* ptr_small)
{
    if (a > b) {
        *ptr_great = a;
        *ptr_small = b;
    }
    else {
        *ptr_great = b;
        *ptr_small = a;
    }
}

int main()
{
    int great, small, x, y;

    printf("请输入两个数字: ");
    scanf("%d %d", &x, &y);

    compare(x, y, &great, &small);

    printf("
较大的数字是: %d 较小的数字是: %d", great, small);

    return 0;
}

输出结果：

请输入两个数字: 15 8
较大的数字是: 15 较小的数字是: 8

优缺点分析

  • 优点：这是 C 语言的原生写法，极其高效，没有额外的内存开销，非常适合性能敏感的底层代码。
  • 缺点：语法稍显繁琐（到处是 INLINECODEd386806d 和 INLINECODE821414c6），对于初学者来说容易混淆值和地址的概念。而且，函数的参数列表会变长，可读性下降。

方法二：使用结构体（封装数据的最佳实践）

如果你想让代码更具可读性和组织性，结构体是最佳选择。这种方法的核心思想是：将相关的数据打包成一个自定义的“对象”或“包”，然后整体返回。

原理解析

结构体允许我们将不同类型的数据组合在一起。我们可以定义一个包含 INLINECODEd08bd93a 和 INLINECODEafd02e98 两个成员的结构体。函数在计算完结果后，将这个结构体实例作为返回值返回。这比传递多个零散的指针要优雅得多。

代码示例与详解

这种方法在 C 和 C++ 中都适用，它体现了“高内聚”的编程思想。

#include 

// 定义一个结构体来存储我们的结果
struct PairResult {
    int greater;
    int smaller;
};

// 为了方便书写，使用 typedef 定义别名
typedef struct PairResult PairResult;

// 函数返回类型变为 PairResult
PairResult findGreaterSmaller(int a, int b)
{
    PairResult result; // 创建一个临时的结构体变量
    
    if (a > b) {
        result.greater = a;
        result.smaller = b;
    }
    else {
        result.greater = b;
        result.smaller = a;
    }

    // 关键：直接返回整个结构体
    return result;
}

int main()
{
    int x, y;
    printf("请输入两个数字: ");
    scanf("%d %d", &x, &y);

    // 接收返回的结构体
    PairResult ans = findGreaterSmaller(x, y);

    printf("
较大的数字是: %d 较小的数字是: %d", 
           ans.greater, ans.smaller);

    return 0;
}

输出结果：

请输入两个数字: 50 100
较大的数字是: 100 较小的数字是: 50

深入见解与优化

在现代 C++ 中，我们通常倾向于使用 INLINECODEfcc64aba 或 INLINECODE258f80e9 配合构造函数，这样代码会更加简洁。

// 现代C++风格示例
#include 

struct PairResult {
    int greater;
    int smaller;
    // 添加构造函数，初始化更方便
    PairResult(int g, int s) : greater(g), smaller(s) {}
};

PairResult compare(int a, int b) {
    if (a > b) return PairResult(a, b);
    else return PairResult(b, a);
}

int main() {
    auto res = compare(10, 20);
    std::cout << "Max: " << res.greater << ", Min: " << res.smaller << std::endl;
    return 0;
}

这种方法大大提升了代码的可维护性，尤其是当需要返回的变量很多（比如 5 个以上）时，结构体是首选方案。

方法三：使用数组（适用于相同类型的多个值）

当你需要返回的值类型相同（例如两个整数，或者三个浮点数），并且它们的逻辑地位平等时，数组是一个非常直观的选择。

原理解析

在 C/C++ 中，数组名在传递给函数时会退化为指向数组首元素的指针。这意味着，即使我们在函数内部修改了数组的内容，调用者也能看到修改后的结果。我们通常约定数组的某个索引存放特定含义的值（例如 INLINECODE0a0e6141 存大数，INLINECODE810f00a2 存小数）。

代码示例与详解

#include 
using namespace std;

/*
 * 函数接收一个整型数组作为参数
 * 我们不需要显式返回数组，因为直接修改的是原数组内存
 */
void findGreaterSmaller(int a, int b, int result[])
{
    // 约定：result[0] 存放较大的数，result[1] 存放较小的数
    if (a > b) {
        result[0] = a;
        result[1] = b;
    }
    else {
        result[0] = b;
        result[1] = a;
    }
}

int main()
{
    int x, y;
    // 定义一个大小为 2 的数组用于接收结果
    int ans[2];

    cout <> x >> y;

    findGreaterSmaller(x, y, ans);

    cout << "
较大的数字是: " << ans[0] 
         << " 较小的数字是: " << ans[1];

    return 0;
}

输出结果：

请输入两个数字: 9 13
较大的数字是: 13 较小的数字是: 9

实战建议

这种方法在处理“状态列表”或“数据集合”时非常有用。但它的缺点是可读性较差。在函数外部，阅读代码的人可能不知道 ans[0] 到底代表什么意思。除非你配合详细的注释或枚举类型使用，否则对于业务逻辑复杂的代码，结构体通常是更好的替代方案。

进阶探讨：现代 C++ 的解决方案

虽然上述三种方法是通用的 C/C++ 解决方案，但如果你在编写现代 C++ 代码（C++11 及以上），还有更优雅的武器。

1. 使用 std::pair (C++)

如果你只需要返回两个值，标准库提供了 std::pair。它本质上是一个特化的结构体，专门用于存储一对值。

#include 
#include  // 包含 std::pair

std::pair findMinMax(int a, int b) {
    if (a > b) {
        return std::make_pair(a, b); // 返回 pair
    } else {
        return std::make_pair(b, a);
    }
}

int main() {
    auto result = findMinMax(10, 5);
    // 使用 .first 和 .second 访问成员
    std::cout << "Max: " << result.first << ", Min: " << result.second << std::endl;
    return 0;
}

2. 使用 std::tuple (C++11)

当需要返回三个或更多值时，std::tuple 是救星。它可以打包任意数量、任意类型的值。

#include 
#include 

// 返回最大值、最小值和它们的和
std::tuple analyzeNumbers(int a, int b) {
    if (a > b) {
        return std::make_tuple(a, b, a + b);
    } else {
        return std::make_tuple(b, a, a + b);
    }
}

int main() {
    int maxVal, minVal, sumVal;
    
    // 使用 std::tie 进行结构化解包
    std::tie(maxVal, minVal, sumVal) = analyzeNumbers(20, 10);

    std::cout << "Max: " << maxVal << ", Min: " << minVal << ", Sum: " << sumVal << std::endl;
    
    // C++17 结构化绑定（更推荐）
    auto [mx, mn, sm] = analyzeNumbers(5, 15);
    return 0;
}

3. 使用引用传参 (C++)

这是 C++ 中对“指针法”的升级版。使用引用（&）语法比指针更简洁，因为它不需要解引用操作，看起来就像直接操作变量一样。

void compare(int a, int b, int &great, int &small) {
    if (a > b) {
        great = a; // 直接赋值，不需要 *great = a
        small = b;
    } else {
        great = b;
        small = a;
    }
}

常见陷阱与最佳实践

在处理多返回值时，我们积累了一些经验，希望能帮助你避开坑点：

  • 不要返回指向局部变量的指针！ 这是一个经典的 C++ 错误。如果你在函数内部创建了一个数组或结构体，然后返回它的地址，函数结束后该内存会被释放，导致调用者访问到悬空指针。要么返回结构体本身（按值返回），要么让调用者提供内存缓冲区（指针/引用参数）。
  • 优先考虑结构体。 如果你发现自己经常传递超过 3 个参数给函数，请停下来考虑创建一个结构体。这会让你的函数签名更清晰，也便于后续扩展。
  • 命名的清晰度。 对于数组法，不要使用魔术数字如 INLINECODEa5a8b268，建议定义常量或枚举，例如 INLINECODE04438a85，这样代码才是可维护的。
  • 性能考量。 返回大型结构体可能会涉及内存拷贝。虽然在 C++17 中有了 RVO（返回值优化）和拷贝省略，但在极端性能敏感的场景下，传递指针或引用依然是零开销的保证。

结语

C 和 C++ 赋予了我们直接操作内存的能力，虽然没有内置的 INLINECODEe3e2af7d，但通过指针我们可以精确控制数据流向，通过结构体我们可以实现优雅的数据封装，而利用现代 C++ 的 INLINECODE65cf0afe 或引用，我们可以写出堪比脚本语言般简洁的代码。

希望这篇文章不仅帮你解决了“如何返回多个值”的问题，更让你理解了这些方法背后的内存管理哲学。根据你的项目需求——是追求极致的 C 语言性能，还是倾向于 C++ 的现代抽象——选择最适合你的那一种方案吧。

声明：本站所有文章，如无特殊说明或标注，均为本站原创发布。任何个人或组织，在未征得本站同意时，禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益，可联系我们进行处理。如需转载，请注明文章出处豆丁博客和来源网址。https://shluqu.cn/51782.html
点赞
0.00 平均评分 (0% 分数) - 0 票

相关文章美国1G带宽/1T流量高速vps $17.99/年