在C11中输出参数还是返回struct？

Question

I know C++11 has move semantics, which mean you can directly return a struct from a function and not worry about it being copied (assuming a simple struct), as opposed to writing the struct through an output parameter.

Does C11 have anything like this? Or do returned structs still get copied every time? Are output parameters still the "best practice" here?

Answer 1

I think there is some confusion here which should be clarified. The semantics and the implementation of C++ are different.

• "Move" versus "copy" in C++ is just a question of which constructor (or operator= ) you are invoking.

• The question of whether the representation of the structure's members is copied is an entirely separate question. In other words, "does the processor have to move these bytes around?" is not part of the language semantics.

Semantics

MyClass func() {
    MyClass x;
    x.method(...);
    ...
    return x;
}

This returns using move semantics if available, but even prior to C++11, return value optimization was available.

The reason why we prefer to use move semantics is because moving an object doesn't cause a deep copy, eg, if you move a std::vector<T> you don't have to copy all of the T . However, you are still copying data! So, std::move(x) is semantically speaking a move operation (think of it as using linear rather than classical logic) but it is still implemented by copying data in memory.

Unless your ABI lets you avoid the copy. Which brings us to...

Implementation

When you call a function that returns a large structure (the term "large" is relative, it might only be a few words), most ABIs will call for that structure to be passed by reference to the function. So when you write something like this:

MyClass func() { ... }

Once you look at it in assembly, it might look something more like this:

void func(MyClass *ptr) { ... }

Of course, this is a simplification! The pointer is usually implicit. But the important point is that we are already avoiding a copy, sometimes .

Case study

Here is a simple example:

struct big {
    int x[100];
};

struct big func1(void);

int func2() {
    struct big x = func1();
    struct big y = func1();
    return x.x[0] + y.x[0];
}

When I compile this with gcc -O2 on x64, I get the following assembly output:

    subq    $808, %rsp
    movq    %rsp, %rdi
    call    func1
    leaq    400(%rsp), %rdi
    call    func1
    movl    400(%rsp), %eax
    addl    (%rsp), %eax
    addq    $808, %rsp
    ret

You can see that nowhere is struct big copied. The result from func2() simply gets placed on the stack for func1() , and then the stack gets moved so the next result gets placed elsewhere.

However

• In common ABIs, large function results won't get threaded through multiple function stacks. Returning x or y from func2() above will result in the structure being copied.

• But remember! This has nothing to do with move semantics versus copy semantics , because the structure data getting copied is just an implementation detail rather than language semantics. In C++, using std::move() may still result in the structure getting copied, it just won't invoke the copy constructor.

The conclusion: returning a large structure from either C or C++ may result in copying the structure, depending on the particulars of the ABI, how the function is optimized, and the code in question. However, I wouldn't worry about it if the structure is only a few words long.