Na dann, auf gehts!
Hier ist meins:

void shit()
{
    return throw decltype(sizeof(const volatile unsigned long int) xor alignof(signed()) and float() or double() || wchar_t() && bool() && char())();
}

int main()
{
    shit();
}

Summe: 16 Schlüsselwörter.
Wer kriegt mehr hin?

Edit: alignof hinzugefügt, sowie wchar_t. 18 Stück.
Edit 2: bool hinzugefügt. 19.

23

wenn wir c++0x verwenden, dann koennen wir nen lamdba ausdruck reinnehmen und dann haben wir wieder massig neue keywords die wir nutzen konnen. Wobei wir dann definieren muessen was alles als EIN ausdruck gilt. Weil eine lambda Definition ist ja eigentlich ein ausdruck, besteht aber aus N statements...

Kontrollstruktur- und Klassenschlüsselwörter dürften hingegen recht schwierig in einen Ausdruck einzubauen sein. Man kann zwar class X vor einen Klassentypen X schreiben, nur muss dieser zuvor schon einmal deklariert worden sein, was bereits class erfordert (nein, struct ist nicht erlaubt).

29, wenn ich mich nicht verzählt habe.

Ich war vielleicht zu ungenau, ich meine genau 1 Statement. Lambdas zählen also nicht.

Nein. Oben hast Du einen Ausdruck verlangt. Ein Statement kann auch for und do und switch und verschachtelst alles haben.
Nur ein Statement zu verlangen wäre zwar viel cooler, was die Anzahl der Schlüssenwörter angeht, aber ich fürchte, das wird zu einfach. Sozusagen, daß ein jeder fast alle unterbringt und es dann am Ende nur noch an eunem Trick hängt, wie dem sonderbaren return throw. Mir scheint, daß der Ausdruck als Herausforderung stärker den Profifricker vom Hobbyfrickler trennt.

ausserhalb eines Templates ist kein gültiges C++ :p

44, wenn ich mich nicht verzählt habe.

44, wenn ich mich nicht verzählt habe.

new doppelt und dafür typename vergessen.

#include <typeinfo>
#include <vector>
#include <ctime>
#include <iostream>
#include <limits>

int shit()
{
    using namespace std;
    auto nullptr=(void*)0;//nur weil gcc den noch nicht kennt
    auto a=0,b=0,c=0,d=0;
    return
    (reinterpret_cast<unsigned long>((new class vector<volatile tm* //6
    >())->operator[](0)) or (signed short int) sizeof(typeid(delete //8
    (enum float_denorm_style*)nullptr)))+(float)static_cast<double> //5
    (wchar_t ( d and_eq c not_eq not(a or_eq b xor_eq 1 xor 2 )))+( //7
    true bitor (char32_t() bitand alignof(char16_t) and (char(compl //9
    (bool(false)))))) + vector<decltype(throw const_cast<tm*>(      //5
    dynamic_cast<const struct tm*>(new tm)))*>().size();            //4
                                                                    //=44
}

int main()
{
    shit();
}

44, wenn ich mich nicht verzählt habe.

Wenn du da noch´n switch-case-default-break drumrumbaust biste schon bei 48.

Edit:
Und in einem switch-case noch eine while-do Schleife mit continue, dann sind´s schon 51.

44, wenn ich mich nicht verzählt habe.

Nicht schlecht! Dass man Standardklassen verwenden könnte, um class etc. einzusetzen, ist mir später auch noch eingefallen. Die Idee mit operator ist gut! Hast du return nicht mitgezählt?

volkard schrieb:

Nexus ist der Meinung, die alternativen Operatorschlüsselwörter seien doof.

Ich finde nur doof, dass sie ohne guten Grund Schlüsselwörter sind, zumal sie genauso gut Makros sein könnten, ohne dabei sinnvolle Bezeichner zu verunmöglichen.

Hast du return nicht mitgezählt?

Nein.
return ausdruck; wäre ja eine Anweisung.