c\c++ - Functions with unions as arguments to meet specific requirements

Question

I'm engineering library to provide functionality for one device. This device has some common operations but different algorithms to accomplish these operations. I want one function prototype for one particular operation, not a bunch of them, say instead of:

Alg1_Foo();
Alg2_Foo();
...

I want this:

Foo(alg);

But I don't want to pass alg as separate argument, because functions will have a lot of arguments even without it, they will have arguments for identification and/or authorization of the device, in argument, out argument (at least one of them), so I think it will be annoying to add alg as a separate argument.

So my idea is to provide solution like this one:

Foo(const SomeUnion& some_union);

Where:

union SomeUnion {
  AlgId alg_id;
  alg1::SomeStruct alg1_some_struct;
  alg2::SomeStruct alg2_some_struct;

  SomeUnion(alg1::SomeStruct some_struct) { alg1_some_struct = some_struct; };
  SomeUnion(alg2::SomeStruct some_struct) { alg2_some_struct = some_struct; };
};

And the structures of particular algorithms will be like this:

namespace alg1 {
  struct SomeStruct {
    static const AlgId alg_id = ALG1;
    . . .
  };
}

So if want to perform say alg1, we pass appropriate structure to Foo and it works in C++, say

alg1::SomeStruct a;
Foo(a);

But I want my library to maintain possibilities of pure C. Of course I need to:

1. remove references and replace them with pointers;

2. remove namespaces (we can still emulate them with the help of structures (this thread may be helpful for those interested: Namespaces in C);

3. replace C++-style of defining structs to that from C and define also name in tag namespace (typedef struct tagStruct {...} Struct;);

4. remove functions from inside structures and unions.

But though I can't understand if it's possible to accomplish what I want to do with maintenance of C... Do you see the way? Or is it just simplier to pass alg_id as a separate argument not to bother with unions and structures (but I want to avoid it if possible)?

Answer 1

To me, this seems like a typical case where someone is trying to solve a problem "the wrong way".

If you have "lots of arguments" to a function, then using a struct is fine. But hiding "which function you are actually calling" inside such a struct, and then having several variants ofstruct inside a union, now we're trying to stuff too much into one function. Start to split the function so that it only takes one struct - remove your union as an argument - that's just wrong. [I have worked with code that does similar things to this - the chances of sneaking in some code that does the wrong thing and causes some hard to find error because you passed the wrong type of union arguments into the function makes this really a poor solution]. If you pass the wrong type of structure to a plain functions then the compiler tells you. If you fill in the wrong part of a union, the code using the "right" part of the structure will get "weird" data [quite possibly undefined behaviour] - this type of bug can be darn difficult to find.

So yes, split your functions, remove the union!

Edit: One suggestion that comes to mind if you wish to have a simple and consistent interface is that you have a factory function, which you pass alg_id to, which returns a function pointer to the relevant function. Unfortunately, if the interface to each function is as I suggest, a different structure, then you still have a potential for getting the data structures and functions mixed up, but it does cut down on the number of "published functions" - in fact, those functions don't need to be visible at all outside of the module [library or even object file] that provides them.