Thread: union for return values

Is this just to save typing?

Except if you assign to more than one member, it would overwrite the previous ones? And how's the receiver supposed to know which of the fields is meant?

Originally Posted by ZeroMemory

The first thing I do after having called a function is to check its return value. So I don't bother if the next function overwrites it.

I know wich filed to use for every function because I know its return type...

You misunderstand. Declaring a union means that all the variables in that union occupy the same space. Thus, if you have:

Code:

union {
    int a;
    int b;
} MyUnion;

MyUnion.a = 1;
MyUnion.b = 2;
printf ("a=%d\n", MyUnion.a);

You'll get 2! You want a struct, methinks, not a union.

QuantumPete

Very bad.

The compiler can realize that if you only use a variable for a few lines in the code, it needn't actually "keep" the variable around for more than that particular bit of time. A union will definitely destroy such a usage, because the compile will (rightly or wrongly) assume that the same value has some meaning later on in the code.

Using global variables is also very bad, because the compiler will often assume that any function that it doesn't see the whole code of (which means ANY function outside of your current source file) will modify the global variable - so the compiler will store and reload the value into the global variable even if it's not necessary for a correctness of the current code. This will lead to inefficient code.

--
Mats

I think he has something like this in mind:

Code:

void foo()
{
    union_of_every_known_type u;
    u.dword = STD_OUTPUT_HANDLE;
    u.handle = GetStdHandle(u.dword);
    u.bool = SetConsoleMode(u.handle, ENABLE_LINE_INPUT);
    if (!u.bool) {
        u.dword = GetLastError();
        /* etc. etc. */
}

In this particular case you could of course just write:

Code:

int foo()
{
     if (!SetConsoleMode(GetStdHandle(STD_OUTPUT_HANDLE), ENABLE_LINE_INPUT)) {
        DWORD error = GetLastError();
        /* etc. */
}

Anyway, it looks unorthodix and not really generally usable strategy: it breaks down as soon you need two variables at the same time. There is also no good name for the union variable if it is used to represent anything, so should you need more than one the code will become quite messy/undescriptive. And how large are your functions on average, that it hurts so much declare a few variables?

Originally Posted by ZeroMemory

So...you say that it's a bad idea?

Actually, re-reading what you wrote (apologies for the confusion) I think it's a great idea to have a union. You only need each return value once before you use it again for another function call return value. I would definitely keep it on the stack though.

QuantumPete

Originally Posted by QuantumPete

Actually, re-reading what you wrote (apologies for the confusion) I think it's a great idea to have a union. You only need each return value once before you use it again for another function call return value. I would definitely keep it on the stack though.

QuantumPete

But unions can lead to more code in the compiler, because:
1. the compiler doesn't realize that the variable has limited scope (because another variant of the same union is used later - and the compiler may not understand ALL consequences of that)
2. the compiler needs to store the result in the union (again, for the above reasons), rather than just using a register.

Also, in cases where the returned value is NOT a BOOL, it is often useful to "keep around", because it is used by some other function later one (particularly HANDLE is usually of use later on to undo whatever the creation of the handle did, e.g. close the file). If you do not need the returned value, you can always write

Code:

if (FAILED(func2())
{
   ... 
}

and never store the return value at all - that's the simplest option.

--
Mats

Returning a union is useless, because the calling function cannot know which type the result will be. Unless you set another flag as to the type, via a pointer parameter of a global variable. But the situation where a the result of an operation is not a always one of a set of compatible types is rare.

You can use a union to minimise the amount of stack space local variables use, but unless it's a recursive function, stack space isn't generally a limmiting resource. Also instead of using a union, you can often use curly bracket blocks to make variables go out of scope early, and therefore optionally be reused.

Originally Posted by King Mir

You can use a union to minimise the amount of stack space local variables use, but unless it's a recursive function, stack space isn't generally a limmiting resource. Also instead of using a union, you can often use curly bracket blocks to make variables go out of scope early, and therefore optionally be reused.

And the compiler can OFTEN do "life-time analyzis" of variables anyways, so it will be able to re-use the space even if you do not limit the scope - as long as you don't make it too complicated for the compiler [these types of analysis are often quite complex, so they use arbitrary limits to prevent the compile time from being "infinite"].

--
Mats