Wie viele Schlüsselwörter könnt ihr in aneinanderreihen

floorball

Mir war grad langweilig, und da hab ich mich gefragt wie viele Schlüssewörter ich in C++ nur durch ein Leerzeichen getrennt hintereinander schreiben kann.
Ich schaffe zurzeit 7. Wie viele schafft ihr? Schlüsselwörter ist alles was hier aufgelistet ist: http://en.cppreference.com/w/cpp/keyword
Und natürlich zählen Schlüsselwörter in Kommentaren nicht dazu. Es muss in einer "regulären Codezeile" sein.

Zusatz: Wenn nicht nur Leerzeichen sondern auch noch durch -> und * getrennt werden darf schaffe ich 10.

Viel Spaß beim ausprobieren.

Meine Lösung: http://ideone.com/z9vDak

camper

final und override sind keine Schlüsselwörter.

compl compl compl compl compl compl /* usw. */ 0;

hustbaer

const int*const*const*const*const*const*const*const*const*const*const*const*const*const*const*const*const*const foo = 0;

Columbo

if(true); else do extern constexpr const volatile unsigned long long int n(); while(false);

camper schrieb:

final und override sind keine Schlüsselwörter.
compl compl compl compl compl compl /* usw. */ 0;

Ich musste erstmal schauen was compl sein soll... Für mich ist das gar kein "echtes" Keyword. Ich würde compl durch sizeof tauschen.

TyRoXx

struct test
{
  test & operator*(test &)
  {
    return *this**this**this**this**this**this**this**this**this**this**this**this;
  }
};

Zählt das auch?

static_cast<int>(static_cast<int>(static_cast<int>(static_cast<int>(true))));

Th69

Sinn macht dieser Thread wohl nur, wenn man sich auf möglichst viele verschiedene Schlüssewörter beschränkt.

camper

Th69 schrieb:

Sinn macht dieser Thread wohl nur, wenn man sich auf möglichst viele verschiedene Schlüssewörter beschränkt.

template <typename T> struct foo;
template <typename T> struct bar
{
    explicit inline virtual constexpr operator const volatile unsigned long int() const volatile noexcept try
    {
        if(true);
        else do return throw this xor nullptr and sizeof true or false bitand compl not new volatile signed long int bitor typename decltype
        (foo<T>::bar)::bar(); while(false);
    }
    catch (...)
    {
    }
};

Die Illuminati sind schuld.

volkard

Bitte ein ausführbares Programm also mit der main()
und als Wettbewerb die meisten verschiedenen Schlüsselwörter in Folge
und

//start

davor und

//end

danach.

Erst dann kann man sinnvoll vergleichen.

Außerdem zwei Klassen:

Klasse A: In der heftigen Zeile sind Sonderzeichen, Klammern, Operatorzeichen und eben alles so erlaubt. Auch wiederholte keywords, die werden dann aber nur einmal gezählt.

Klasse B: In der heftigen Zeile sind NUR Schlüsselwörter durch je ein Leerzeichen getrennt erlaubt, keine Doppelnennungen.

Für die B-Klasse melöde ich mal mich und Arcoth an.

Columbo

@camper: Teste deinen Code mal. Eine constexpr Funktion darf nicht als virtual definiert werden ([dcl.constexpr]/(3.1)). Im Übrigen sind xor usw. keine keywords.

hustbaer

@volkard
Dürfen Keywords wiederholt werden (und werden dann bloss nicht mehrfach gezählt), oder darf jedes Keyword in der bewerteten Zeile max. 1x vorkommen?

Speziell für Klasse A könnte das nen Unterschied machen.

#define int(int) int
#define short main
#define long x
#define double y
//start
int(int(int(int(int(int(int(int(int(int(int)))))))))) 
short(int(int(int(int(int(int(int(int(int(int(int))))))))))long,
     int(int(int(int(int(int(int(int(int(int(int))))))))))double){};
//end

camper

Arcoth schrieb:

@camper: Teste deinen Code mal. Eine constexpr Funktion darf nicht als virtual definiert werden ([dcl.constexpr]/(3.1)).

ok, hab nur mit gcc getestet. Dann eben bloss eine Deklaration

struct baz
{
    explicit inline virtual constexpr operator const volatile unsigned long int() const volatile noexcept = 0;
};

Arcoth schrieb:

Im Übrigen sind xor usw. keine keywords.

Zitat?

Sie werden in lex.key aufgezählt und genügen wohl auch der (rekursiven) Definition im ersten Paragrafen (unconditionally treated as keywords).

Interessanterweise definiert Anhang A diese Kategorie nicht (sie wird allerdings wohl auch nirgendwo gebraucht).

Im Übrigen habe ich mich an die Definition des ersten Posts gehalten (enthaltehn in verlinkter Liste).

volkard

hustbaer schrieb:

@volkard
Dürfen Keywords wiederholt werden (und werden dann bloss nicht mehrfach gezählt), oder darf jedes Keyword in der bewerteten Zeile max. 1x vorkommen?

Speziell für Klasse A könnte das nen Unterschied machen.

Bei A ja, Wiederholungen erlaubt (und nur einmal gezählt), dort isses ist eh recht formfrei.

Bei B nein, Wiederholungen nicht erlaubt, das würde zu viel der Eleganz rauben.

camper

volkard schrieb:

hustbaer schrieb:

@volkard
Dürfen Keywords wiederholt werden (und werden dann bloss nicht mehrfach gezählt), oder darf jedes Keyword in der bewerteten Zeile max. 1x vorkommen?

Speziell für Klasse A könnte das nen Unterschied machen.

Bei A ja, Wiederholungen erlaubt (und nur einmal gezählt), dort isses ist eh recht formfrei.

Bei B nein, Wiederholungen nicht erlaubt, das würde zu viel der Eleganz rauben.

Klasse A ist zu frei. Ein ganzes Programm passt in eine Zeile und kann sicher jedes Schlüsselwort verwenden. Zumindest Semikolons sollten wohl ausgeschlossen werden. Und mit Wiederholen kann beliebig rekursiv deklariert werden

#define x template<
#define y >class
//start
x x x x x x x x x x x x x x x x x x x x int y y y y y y y y y y y y y y y y y y y y
//end
foo;
int main();

hustbaer

Und #define sollte vermutlich ausgeschlossen werden. Bzw. am besten gleich der ganze PP.
Sonst schreibe ich

//start
#define blub int short long double float char signed unsigned template class struct typename for while if switch case do return const mutable volatile ...
//end

oder halt

#define NIX(x)
NIX(
//start
int short long double float char signed unsigned template class struct typename for while if switch case do return const mutable volatile ...
//end
)

Columbo

camper schrieb:

Arcoth schrieb:

@camper: Teste deinen Code mal. Eine constexpr Funktion darf nicht als virtual definiert werden ([dcl.constexpr]/(3.1)).

ok, hab nur mit gcc getestet. Dann eben bloss eine Deklaration
struct baz
{
    explicit inline virtual constexpr operator const volatile unsigned long int() const volatile noexcept = 0;
};

Das ist nach wie vor Quatsch, und die Tatsache, dass es nicht vom zitierten Paragraphen behandelt wird, ein Defekt.

Arcoth schrieb:

Im Übrigen sind xor usw. keine keywords.

Zitat?

Sie sind punctuators. Siehe auch [lex.operators].

camper

Arcoth schrieb:

camper schrieb:
Arcoth schrieb:

@camper: Teste deinen Code mal. Eine constexpr Funktion darf nicht als virtual definiert werden ([dcl.constexpr]/(3.1)).

ok, hab nur mit gcc getestet. Dann eben bloss eine Deklaration
struct baz
{
    explicit inline virtual constexpr operator const volatile unsigned long int() const volatile noexcept = 0;
};
Das ist nach wie vor Quatsch, und die Tatsache, dass es nicht vom zitierten Paragraphen behandelt wird, ein Defekt.

Natürlich ist es Quatsch. Aber wieso sollte das eine Rolle spielen?

Arcoth schrieb:

Arcoth schrieb:

Im Übrigen sind xor usw. keine keywords.

Zitat?

Sie sind punctuators. Siehe auch [lex.operators].

Ja und? Schließt sich das gegenseitig aus? new und delete sind bei dir auch keine Schlüsselwörter?

Columbo

camper schrieb:

Arcoth schrieb:
camper schrieb:
Arcoth schrieb:

@camper: Teste deinen Code mal. Eine constexpr Funktion darf nicht als virtual definiert werden ([dcl.constexpr]/(3.1)).

ok, hab nur mit gcc getestet. Dann eben bloss eine Deklaration
struct baz
{
    explicit inline virtual constexpr operator const volatile unsigned long int() const volatile noexcept = 0;
};
Das ist nach wie vor Quatsch, und die Tatsache, dass es nicht vom zitierten Paragraphen behandelt wird, ein Defekt.
Natürlich ist es Quatsch.

Edit²: Dein Code ist ill-formed, NDR:

[dcl.constexpr]/5 schrieb:

For a constexpr function or constexpr constructor that is neither defaulted nor a template, if no argument values exist such that an invocation of the function or constructor could be an evaluated subexpression of a core constant expression (5.20), or, for a constructor, a constant initializer for some object (3.6.2), the program is ill-formed; no diagnostic required.

Damit führe ich gerade mit 10.

Ja und? Schließt sich das gegenseitig aus?

Ja, anscheinend. Du musst sonst die folgende Notiz erklären:

[ Note: Some white space is required to separate otherwise adjacent identifiers, keywords, numeric literals, and alternative tokens containing alphabetic characters. — end note ]

Du musst auch erklären, was es mit der folgenden Diskrepanz auf sich hat:

After all replacements due to macro expansion and evaluations of defined-macro-expressions and has-include-expressions have been performed, **all remaining identifiers and keywords¹⁴⁷, except for true and false , are replaced with the pp-number 0 **, and then each preprocessing token is converted into a token.

An alternative token (2.5) is not an identifier, even when its spelling consists entirely of letters and underscores. Therefore it is not subject to this replacement.

... oder du hast dich einfach auf die umgangssprachliche Bedeutung von keyword bezogen, nämlich ein intrinsisch reservierter Bezeichner?

Columbo

Und hier sind 10 unterschiedliche von mir:

int main() {if (0); else do extern constexpr const volatile unsigned long int operator+(struct A); while (0);}