I am porting some C++ code to GCC, and apperantly it isn't happy with C++ style casting when sapces are involved, as in unsigned int(-1), long long(ShortVar) etc... It gives an error: expected primary-expression before 'long'.
Is there any way to make peace with GCC without going over each one of those and rewrite in c-style?
GCC is correctly crying -- unsigned int(-1) is a notation that is not conformant with the C++03 standard (5.4.2):
An explicit type conversion can be expressed using functional notation (5.2.3), a type conversion operator (dynamic_cast, static_cast, reinterpret_cast, const_cast), or the cast notation:
cast-expression:
unary-expression
( type-id ) cast-expression
Ergo, you can either correct the cast with the parenthesis, follow the excellent suggestions proposed by GMan :) -- and I'd truly recommend the latter.
Edit: the functional notation requires a simple-type-specifier:
5.2.3 - A simple-type-specifier (7.1.5) followed by a parenthesized expression-list constructs a value of the specified type given the expression list.
Simple type specifiers do not include the composite ones (the ones with spaces).
You want static_cast<unsigned int>(-1) and kin. Those tend to be viewed as the more C++-style casts, and don't have the same problem.
For what it's worth, you'd have to do:
template <typename T>
struct identity
{
typedef T type;
};
And then:
identity<unsigned int>::type(-1);
Or in C++0x:
template <typename T>
using id = T;
id<unsigned int>(-1);
The probability is high that you type static_cast<unsigned int>(-1), but really want std::numeric_limits<unsigned int>::max() or, if not applicable, UINT_MAX.
The difference is primarily in that the latter two express what you want. Casting -1 to unsigned int is less expressive, if at all, therefore not the preferred solution.
In general, prefer to write expressive code. You'll thank yourself later, and your fellow programmers and the HR department will not frown upon you.
