从 C function 返回多个值

Question

Important : Please see this very much related question: Return multiple values in C++ .

I'm after how to do the same thing in ANSI C? Would you use a struct or pass the addresses of the params in the function? I'm after extremely efficient (fast) code (time and space), even at the cost of readability.

EDIT : Thanks for all the answers. Ok, I think I owe some explanation: I'm writing this book about a certain subset of algorithms for a particular domain. I have set myself the quite arbitrary goal of making the most efficient (time and space) implementations for all my algos to put up on the web, at the cost of readability and other stuff. That is in part the nature of my (general) question.

Answer : I hope I get this straight, from (possibly) fastest to more common-sensical (all of this a priori, ie without testing):

1. Store outvalues in global object (I would assume something like outvals[2]?), or
2. Pass outvalues as params in the function (foo(int in, int *out1, int *out2)), or
3. return a struct with both outvals, or
4. (3) only if the values are semantically related.

Does this make sense? If so, I think Jason's response is the closest, even though they all provide some piece of the "puzzle". Robert's is fine, but at this time semantics is not what I'm after (although his advice is duly noted).

Answer 1

Both ways are valid, certianly, but I would would consider the semantics (struct vs parameter reference) to decide which way best communicates you intentions to the programmer.

If the values you are returning are tightly coupled , then it is okay to return them as a structure. But, if you are simply creating artificial mechanism to return values together (as a struct), then you should use a parameter reference (ie pass the address of the variables) to return the values back to the calling function.

Answer 2

As Neil says, you need to judge it for yourself.

To avoid the cost of passing anything, use a global. Next best is a single structure passed by pointer/reference. After that are individual pointer/reference params.

However, if you have to pack data into the structure and then read it back out after the call, you may be better off passing individual parameters.

If you're not sure, just write a bit of quick test code using both approaches, execute each a few hundred thousand times, and time them to see which is best.

Answer 3

You have described the two possible solutions and your perceived performance constraint. Where you go from here is really up to you - we don't have enough information to make an informed judgement.

Answer 4

Easiest to read should be passed addresses in the function, and it should be fast also, pops and pushes are cheap:

void somefunction (int inval1, int inval2, int *outval1, int *outval2) {
   int x = inval1;
   int y = inval2;
// do some processing
   *outval1 = x;
   *outval2 = y;
   return;
}

Answer 5

我能想到的最快的Q＆D方式是在全局对象上传递值，这样就可以跳过堆栈操作，只要记住它不是线程安全的。

Answer 6

I think that when you return a struct pointer, you probably need to manually find some memory for that. Addresses in parameter list are allocated on the stack, which is way faster.

Answer 7

请记住，有时通过值传递参数和返回时更新（或在堆栈上创建本地副本）比通过引用更快...这对于小结构或少量参数和大量访问非常明显。

Answer 8

I would pass the address to a struct. If the information to be returned isn't complex, then just passing in the addresses to the values would work too.

Personally, it really comes down to how messy the interface would be.

void SomeFunction( ReturnStruct* myReturnVals )
{
  // Fill in the values
}   

// Do some stuff    
ReturnStruct returnVals;
SomeFunction( &returnVals);    
// Do more stuff

Answer 9

This depends massively on your architecture, and also if you expect (or can have) the function inlined. I'd first write the code in the simplest way, and then worry about speed if that shows up as an expensive part of your code.

Answer 10

In either case, you're passing references, so performance should be similar. If there is a chance that the function never actually returns a value, you could avoid the cost of the malloc with the "return a struct" option since you'd simply return null.

My personal preference is to return a dynamically allocated (malloc'd) struct. I avoid using function arguments for output because I think it makes code more confusing and less maintainable in the long-term.

Answer 11

Returning a local copy of the structure is bad because if the struct was declared as non-static inside the function, it becomes null and void once you exit the function.

And to all the folks suggesting references, well the OP did say "C," and C doesn't have them (references).

And sweet feathery Jesus, can I wake up tomorrow and not have to see anything about the King of Flop on TV?