Re: __FILE__[...] as an integral constant
Am 24.03.2015 um 20:32 schrieb lorenzo.caminiti@googlemail.com:
Can __FILE__[...] be evaluated as an integral constant expression in C++
and/or C++11? What do the official C++ and C++11 standard say?
There is no explicit guarantee for this being valid, but we have the
guarantee that the macro __FILE__ is a character string literal (and
this guarantee has already been provided in C++98).
For example, say I want to use __FILE__'s first 2 characters to
instantiate a class template:
#include <iostream>
template< char f0, char f1 >
struct x {
static void f ( ) { std::cout << f0 << f1 << std::endl; }
};
int main ( ) {
x<
0 < sizeof(__FILE__) ? __FILE__[0] : 0,
0 < sizeof(__FILE__) ? __FILE__[1] : 0
>::f();
return 0;
}
This compiles on CLang 3.4.2 and GCC 4.8.3 but only if I specify the
`-std=c++11` compiler option. Without the `-std=c++11` option, Clang
and GCC give an error like this:
error: non-type template argument of type 'int' is not an integral
constant expression
0 < sizeof(__FILE__) ? __FILE__[0] : 0,
Note that sizeof(__FILE__) seems to correctly work also without the
`-std=c++11` option which seems to indicate that __FILE__ is actually
a static char array. But then __FILE__[...] does not work without
the `-std=c++11` which seems strange to me...
The reason for that difference can be attributed to the fact that for
C++03 and earlier, the set of valid constant expressions was very
limited. In particular, the access to the individual elements of an
array to integral type was not considered as an integral
constant-expression. The next best match (in C++03) would have been a
so-called address constant expression that could be formed e.g. from a
string literal ([expr.const] p5 in ISO/IEC 14882:1998)
"An address constant expression is a pointer to an lvalue designating an
object of static storage duration, a string literal (2.13.4), [..]"
Even the usage of operator[] was valid,
"The subscripting operator [] and the class member access . and >
operators, the & and * unary operators, and pointer casts (except
dynamic_casts, 5.2.7) can be used in the creation of an address constant
expression,"
but it was not valid to access the (referenced) value:
"but the value of an object shall not be accessed by the use of these
operators"
That made sense in C++03/98, because such an address constant expression
was relevant to express constant expressions referring to address values
but not to more general expressions of the dereferenced values [Note
that the expression x[y] is equivalent to *(x + y)].
HTH & Greetings from Bremen,
Daniel Kr?gler
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]