Avoid implicit cast from enum to double

[Flo]

I have the problem, that the following Code produces neither warning
nor error at compile time, at least not with the Microsoft Visual C++
6.0 compiler (warning level 4)

enum E { eOne, eTwo };
struct S {
void fooDouble( double ) {};
void fooEnum( E ) {};
};
int main() {
S s;
s.fooDouble( eOne ); // neither warning nor error
return 0;
}

As you can see, accidentally an enum is passed to the method expecting
an double. In my real program, this leads to an error at run-time,
since fooDouble only accepts quit small values, i.e. values smaller
than 1.0. Has anybody an idea what I can do, maybe changes in the
methodnames/parameterlist, to provoke a warning at compile time so one
can not accidentally pass an enum to the method expecting a double?

Flo

Flo

 

[Victor Bazarov]

I have the problem, that the following Code produces neither warning
nor error at compile time, at least not with the Microsoft Visual C++
6.0 compiler (warning level 4)

enum E { eOne, eTwo };
struct S {
void fooDouble( double ) {};
void fooEnum( E ) {};

Please drop the habit of appending a semicolon after a function body.
It just looks sloppy.

};
int main() {
S s;
s.fooDouble( eOne ); // neither warning nor error
return 0;
}

As you can see, accidentally an enum is passed to the method expecting
an double. In my real program, this leads to an error at run-time,
since fooDouble only accepts quit small values, i.e. values smaller
than 1.0. Has anybody an idea what I can do, maybe changes in the
methodnames/parameterlist, to provoke a warning at compile time so one
can not accidentally pass an enum to the method expecting a double?

Wrap your enum in a struct and pass the struct. Inside just access the
wrapped value.

Check the value (or assert if you can debug all cases of using your
function) inside your 'fooDouble' function.

Be careful and just don't write code that passes the enum to 'fooDouble'.

V

 

[Rolf Magnus]

I have the problem, that the following Code produces neither warning
nor error at compile time, at least not with the Microsoft Visual C++
6.0 compiler (warning level 4)

enum E { eOne, eTwo };
struct S {
void fooDouble( double ) {};
void fooEnum( E ) {};
};
int main() {
S s;
s.fooDouble( eOne ); // neither warning nor error
return 0;
}

Well, it can be converted implicitly.

As you can see, accidentally an enum is passed to the method expecting
an double. In my real program, this leads to an error at run-time,
since fooDouble only accepts quit small values, i.e. values smaller
than 1.0. Has anybody an idea what I can do, maybe changes in the
methodnames/parameterlist, to provoke a warning at compile time so one
can not accidentally pass an enum to the method expecting a double?

Remove the type prefix from the function name and call your functions both
just foo. Then the compiler will automatically choose the right function.