E xercise 15.8

Write a standards-conforming C++ program containing a sequence of at least ten different consecutive keywords not separated by identifiers, operators, punctutation characters, etc. O ne way of interpreting this question is to say that alternative tokens such as bit_or are keywords. If we could in addition repeat such tokens, you would quickly come up with arbitrarily long sequences of keywords: int main() {

bool result = true and true and true

and true and not false;

} M any may consider this cheating either on the grounds that a keyword is being repeated or that it is in fact not a keyword but an "alternative token" (the distinction is thin however, and you will note that Bjarne treats such tokens as keywords in par. A.2.) Another, perhaps more obscure, repeatable keyword (not an alternative token this time!) is sizeof : int main() {

return sizeof sizeof sizeof sizeof

sizeof sizeof sizeof sizeof true;

} C oming up with an uninterrupted sequence of distinct, honest-to-goodness keywords is a little harder. A good way to start is to stare at the table of all keywords (see e.g. par. A.2 in Bjarne's book). The most interesting candidate keywords are those that are not required to be surrounded by punctuation: const (par. 5.4), inline (par. 7.1.1) and new (par 6.2.6) could potentially be useful. On the other hand static_cast (par. 6.2.7) or private (par. 15.3) are less flexible because they are always followed by a non-keyword token (' < ' and ' : ' respectively.)

Declarations can have a fair number of keywords. Here is a good starting point: signed long int const volatile a; Maybe I hear you say "You can add extern to that" (par. 9.2) or perhaps "Make it the return-type of a function and add qualifiers"? Good idea: extern inline signed long int const volatile f(); Ah, and we could explicitly instantiate a template (par. C.13.10)... and it could be an operator (chap. 11): template

extern inline signed long int const volatile operator*(X&); Nine keywords... very close...

In fact, if you allow "alternative tokens", you can have ten! template

extern inline signed long int const volatile

operator and(X&, Y&); S o, mission accomplished as far as the spirit of the exercise goes, but for brainteasing's sake, let's look for a solution not involving alternative tokens. Some expressions can contain little pieces of declaration-like items (types). The typeid (par. 15.4.4) and sizeof (par. 4.6) operators are like that, but they require parentheses. The new operator (par. 6.2.6) does not have that restriction, so that is useful. Remember also that the sizeof operator doesn't require parentheses either if its argument is an expression instead of a type. Combining the two, we get: sizeof new signed long int const volatile(); Seven only, but the expression can be grown with the throw operator (par. 8.3.1), so we are eight!

After that it may not be possible to grow the expression anymore, but some statements (par. 6.3) have keywords that are followed by expressions without intervening punctuation. If you look closely at the table in par. 6.3 of The C++ Programming Language, you will find that the do and else keywords are like that. So our final answer is: int main() {

if (false) {

} else do

throw sizeof new signed long int const volatile();

while (false);

} C learly, this is not very useful code and indeed it is fair to say that useful code will never need to have ten consecutive distinct keywords in C++. However, this is a great bit of trivia to impress your friends and/or colleagues, and coming up with the solution got me to explore the C++ grammar in some more detail.

Ah yes, and you cannot do this in C ;-) F inally, we should mention the following clever trick sent in by “Prince Vijay Daniel”: #define keywords this unsigned class struct \

enum template if for namespace else do return \

throw sizeof new signed long We could list all the C++ keywords this way. However, we should also note that identifiers only become keywords after preprocessing, and therefore this latter solution does not quite fit the spirit of the exercise. M any Thanks to Bjarne Stroustrup, Andrew Koenig and “Gargantua Blargg” for their suggestions and corrections. T he eleven distinct wholesome keywords challenge has been solved. “Gargantua Blargg” not only came up with that answer, but also shows how you can have twenty (yes, 20) different "extended" keywords placed in a valid C++ sequence ("extended" meaning that alternative tokens are included.) And Anatoli Tubman upped that to 24 keywords...

So now the new challenge is for twelve classic keywords or 25 extended keywords .

E-mail me if you know!