C++结构体与函数返回值传递技巧

直接按值返回结构体通常高效，因编译器通过RVO/NRVO消除拷贝；对于大型结构体或无法优化场景，移动语义避免深拷贝；输出参数可避免开销但改变接口语义；C++17结构体绑定提升多值返回的使用便利性。

C++中，结构体作为函数返回值传递，核心在于理解编译器优化（如RVO/NRVO）和现代C++的移动语义。简单来说，对于小型结构体，直接按值返回通常是最自然且高效的方式，因为编译器会进行优化。而对于大型结构体，或者那些无法被编译器优化的情况，利用移动语义（

std::move

解决方案

在C++中，返回结构体时，我们主要有几种策略，每种都有其适用场景和性能考量。

最直接的方式是按值返回。这看起来可能效率不高，因为它似乎涉及一个结构体的完整拷贝。但得益于C++编译器强大的优化能力，尤其是返回值优化（RVO）和具名返回值优化（NRVO），在很多情况下，这个拷贝操作会被完全消除。编译器会直接在调用者的栈帧上为返回值预留空间，并将函数内部构造的结构体直接“原地”构造到这个预留空间，避免了临时对象的创建和拷贝。这让按值返回成为最简洁、最符合直觉且通常性能良好的选择。

然而，当RVO/NRVO无法生效时（比如函数有多个返回路径，返回不同的具名局部变量），或者结构体内部包含大量动态分配资源（如

std::vector

std::string

std::move

立即学习“C++免费学习笔记（深入）”；

最后，虽然不常用作“返回值”，但作为一种替代方案，我们可以通过输出参数（引用或指针）来“传递”结构体。这种方法是让调用者提供一个已经存在的结构体对象（或指向其的指针），函数内部只是填充或修改这个对象。这种方式完全避免了拷贝和移动的开销，因为对象在函数调用之前就已经存在了。然而，它改变了函数接口的语义，使其更像一个副作用操作，而不是一个纯粹的“生成并返回”值的函数。

为什么直接按值返回结构体在C++中通常不是性能瓶颈？

说实话，我刚开始学习C++的时候，总是被教导说“避免按值传递大对象，尤其是作为返回值”。这在某种程度上是对的，但现代C++和现代编译器已经让这个观念变得有些过时了，至少在很多情况下是这样。核心原因在于返回值优化（Return Value Optimization, RVO）和它的一个特定形式具名返回值优化（Named Return Value Optimization, NRVO）。

简单来说，当一个函数返回一个局部创建的对象时，编译器常常能够识别出这个模式。它不是先在函数内部创建一个临时对象，然后将其拷贝到返回值，再销毁临时对象。相反，它会直接在调用函数的地方（也就是接收返回值的那个变量的内存位置）构造这个对象。这样一来，中间的拷贝步骤就被完全“优化”掉了。

举个例子，假设你有一个函数

createMyStruct()

MyStruct

struct MyStruct {
    int a;
    double b;
    // 假设这里还有一些其他成员，但没有动态分配的资源
    MyStruct() : a(0), b(0.0) { /* std::cout << "MyStruct default ctor\n"; */ }
    MyStruct(const MyStruct& other) : a(other.a), b(other.b) { /* std::cout << "MyStruct copy ctor\n"; */ }
    // 为了观察，我暂时注释掉了输出，实际项目中可能不会有这些
};

MyStruct createMyStruct() {
    MyStruct s; // 局部变量
    // ... 对 s 进行一些操作 ...
    return s; // 返回具名局部变量
}

int main() {
    MyStruct result = createMyStruct();
    return 0;
}

在上述代码中，

createMyStruct()

s

s

result

s

main

result

如果函数返回的是一个匿名临时对象，比如

return MyStruct();

这种优化是标准允许的，并且在实践中非常普遍。它使得按值返回成为一种既安全又高效的默认策略，尤其对于那些没有动态资源管理的结构体来说。所以，我们通常不需要过于担心按值返回小型或中型结构体带来的性能开销。

科大讯飞-AI虚拟主播

科大讯飞推出的移动互联网智能交互平台，为开发者免费提供：涵盖语音能力增强型SDK，一站式人机智能语音交互解决方案，专业全面的移动应用分析；

下载

面对大型结构体或无法RVO的场景，如何优化返回值传递？

尽管RVO和NRVO非常强大，但它们并非万能。总有些情况，比如编译器因为某些复杂性无法应用优化，或者我们返回的是一个需要深拷贝的大型结构体（例如，内部包含

std::vector

std::string

移动语义的核心思想是：当一个对象即将被销毁（例如一个局部变量作为返回值），而它的资源（比如堆上的内存）又可以被另一个新对象“窃取”时，我们就不需要进行昂贵的深拷贝，只需要把资源的所有权从旧对象转移到新对象。这通常涉及到指针的重新赋值，并将旧对象的指针置空，以防止双重释放。

假设我们有一个结构体，它内部管理着一块动态内存：

#include 
#include 
#include  // for std::move

struct LargeStruct {
    std::vector data;
    std::string name;

    LargeStruct() {
        std::cout << "LargeStruct default ctor\n";
    }

    // 拷贝构造函数：执行深拷贝
    LargeStruct(const LargeStruct& other) : data(other.data), name(other.name) {
        std::cout << "LargeStruct copy ctor\n";
    }

    // 移动构造函数：执行资源转移
    LargeStruct(LargeStruct&& other) noexcept
        : data(std::move(other.data)), name(std::move(other.name)) {
        std::cout << "LargeStruct move ctor\n";
    }

    // 析构函数
    ~LargeStruct() {
        std::cout << "LargeStruct dtor\n";
    }
};

LargeStruct createLargeStruct_by_value() {
    LargeStruct s;
    s.data.resize(100000); // 假设这里填充了大量数据
    s.name = "MyBigObject";
    // 如果编译器能优化，这里直接构造到返回位置
    return s;
}

LargeStruct createLargeStruct_with_move() {
    LargeStruct s;
    s.data.resize(100000);
    s.name = "AnotherBigObject";
    // 显式使用std::move，确保调用移动构造函数
    // 即使RVO/NRVO不生效，也能避免深拷贝
    return std::move(s);
}

int main() {
    std::cout << "--- Calling createLargeStruct_by_value ---\n";
    LargeStruct obj1 = createLargeStruct_by_value(); // 可能会触发NRVO，也可能触发移动构造
    std::cout << "--- Calling createLargeStruct_with_move ---\n";
    LargeStruct obj2 = createLargeStruct_with_move(); // 确保触发移动构造
    std::cout << "--- End of main ---\n";
    return 0;
}

在

createLargeStruct_by_value

s

obj1

s

obj1

std::move

而在

createLargeStruct_with_move

std::move(s)

s

LargeStruct

s

data

name

std::vector

s

100000

int

输出参数（Output Parameters）作为另一种策略，通常适用于以下场景：

1. 你不想让函数创建新对象，而是想修改一个已存在的对象。
2. 返回的对象非常巨大，即使移动语义也可能带来一些管理开销，或者你希望调用者完全控制对象的生命周期。
3. 函数可能需要返回多个“结果”，而不仅仅是一个结构体。

void fillLargeStruct(LargeStruct& s) {
    s.data.resize(200000);
    s.name = "FilledObject";
    // 不需要返回，直接修改传入的引用
}

// 或者使用指针
void fillLargeStruct_ptr(LargeStruct* s_ptr) {
    if (s_ptr) {
        s_ptr->data.resize(200000);
        s_ptr->name = "FilledObjectViaPtr";
    }
}

int main() {
    LargeStruct my_obj; // 调用者负责创建和销毁
    fillLargeStruct(my_obj);
    // my_obj 现在包含了填充的数据
    // ...
    return 0;
}

这种方式的好处是完全没有拷贝或移动的开销，因为对象在函数外部就已经分配好了。但缺点是，它改变了函数接口的语义，使其不再是纯粹的“生成值”函数，而是带有副作用的“修改值”函数。而且，调用者必须确保传入的引用或指针是有效的。我个人觉得，除非有非常明确的理由（比如性能瓶颈非常突出，或者函数设计上确实是修改一个现有对象），否则优先考虑按值返回配合移动语义，这样代码更简洁，意图也更清晰。

C++17结构体绑定与返回值传递有何关联？

C++17引入的结构体绑定（Structured Bindings），在我看来，是一项非常实用的语法糖，它极大地提升了我们处理复合类型（比如结构体、数组、

std::tuple

std::pair

想象一下，一个函数需要返回多个相关的值，比如一个点的坐标

x, y, z

.

#include 
#include 
#include  // C++17结构体绑定也支持std::tuple

// 定义一个简单的结构体来封装返回结果
struct OperationResult {
    int code;
    std::string message;
    double value;
};

// 函数返回一个OperationResult结构体
OperationResult performOperation(int input) {
    if (input > 0) {
        return {0, "Success", static_cast(input) * 2.5};
    } else {
        return {-1, "Invalid input", 0.0};
    }
}

// 也可以返回一个std::tuple
std::tuple performOperationTuple(int input) {
    if (input > 0) {
        return {0, "Tuple Success", static_cast(input) * 3.0};
    } else {
        return {-1, "Tuple Invalid input", 0.0};
    }
}

int main() {
    // 使用结构体绑定接收performOperation的返回值
    auto [status_code, status_msg, result_val] = performOperation(10);
    std::cout << "Operation Result: Code=" << status_code
              << ", Message='" << status_msg
              << "', Value=" << result_val << std::endl;

    auto [err_code, err_msg, _] = performOperation(-5); // 可以用_忽略不关心的成员
    std::cout << "Error Result: Code=" << err_code
              << ", Message='" << err_msg << "'" << std::endl;

    // 结构体绑定也适用于std::tuple
    auto [tuple_code, tuple_msg, tuple_val] = performOperationTuple(7);
    std::cout << "Tuple Operation Result: Code=" << tuple_code
              << ", Message='" << tuple_msg
              << "', Value=" << tuple_val << std::endl;

    return 0;
}

在上面的例子中，

auto [status_code, status_msg, result_val] = performOperation(10);

performOperation

OperationResult

status_code

status_msg

result_val

OperationResult result = performOperation(10); int code = result.code;

所以，结构体绑定并没有改变返回值传递的底层机制（RVO、移动语义等仍然适用），但它极大地优化了返回值的使用体验。它鼓励我们更多地使用结构体或

std::tuple