Overload Resolution with Two Enums

Question

We have some code that looks roughly like this:

// Two enums that differ entirely.
enum A { a1, a2 };
enum B { b1, b2 };

// Functions to convert in some meaningful way between them
A convert(B);
B convert(A);

Now, our compiler goes and does exactly what we expect it to. convert(a1) will call B convert(A), and so on. However, when we use Lint to look at our code, it complains with error 31. We suspect that this is because the underlying integral type of the enums are the same, and thus Lint might be treating them as such.

The question I have is: is the code standard, or is this an accidental use of a compiler feature?

Answer 1

This code is standard and correct. The bug is in LINT

Answer 2

I'm not sure that it would be considered standard to return an enum rather than a typedef'd enum in this way, but I could be wrong. Also, as a C programmer, I would avoid using the same name for the two functions (as overloading is impossible), but I tend to avoid it in C++ anyway as it is easy to make a mistake.

If I were writing this code, I would have something like:

typedef enum { a1, a2 } A;
typedef enum { b1, b2 } B;
A convertBToA(B BInstance);
B convertAToB(A AInstance);

However, I would expect Lint to be happy (in C++) with:

typedef enum { a1, a2 } A;
typedef enum { b1, b2 } B;
A convert(B BInstance);
B convert(A AInstance);