This is a troll, right?
In the real world, other people have to be able to read and understand your code. Since there's at least one standard library function that solves this problem already, namely std::max from < algorithm >, not using it is simply wrong. Wherever there is a standard solution to a problem, using anything else is by definition harder to read and understand, and therefore strictly worse.
Your colleague is right to criticize this code, although the C-style casts are certainly not the only, or even the first reason why.
To answer your specific question, casts mask errors. The C++-style casts are "safer" in the sense that the compiler is able and required to diagnose more erroneous usages of them than it can and does for C-style casts.
void (*fp)(void) = (void(*)(void))(5); // utter nonsense
This rubbish is happily compiled without diagnostics by g++:
janks@phoenix:/tmp$ g++ -Wall -ansi -pedantic nonsense.cc && ./a.out
But most of the C++-style casts are required to be diagnosed by the compiler when using them for a nonsense conversion like this:
void (*fp)(void) = (void(*)(void))(5);
fp = static_cast<void(*)(void)>(5);
fp = dynamic_cast<void(*)(void)>(5);
fp = const_cast<void(*)(void)>(5);
fp = reinterpret_cast<void(*)(void)>(5);
janks@phoenix:/tmp$ g++ -Wall -ansi -pedantic nonsense2.cc
nonsense2.cc: In function 'int main()':
nonsense2.cc:5: error: invalid static_cast from type 'int' to type 'void (*)()'
nonsense2.cc:6: error: cannot dynamic_cast '5' (of type 'int') to type 'void (*)()' (target is not pointer or reference to class)
nonsense2.cc:7: error: invalid use of const_cast with type 'void (*)()', which is a pointer or reference to a function type
Only the reinterpret_cast "works" here, in the sense that it will compile. (Obviously it will core in a hurry when you try to run it.)
So you should prefer C++-style casts wherever possible. Fewer errors are masked by them than by their C-style equivalent. reinterpret_cast<> is the most permissive of the casts, so it elicits the fewest diagnostics. But you shouldn't be using it unless you know what you're doing. For what you were trying to do, you'd use a static_cast<>, and the compiler would stop you if the cast made no sense.