[[]] struct no_init_declarators_template; // expected-error {{an attribute list cannot appear here}} void fn_with_structs() { [[]] struct with_init_declarators {} init_declarator; [[]] struct no_init_declarators; // expected-error {{an attribute list cannot appear here}} } [[]]; struct ctordtor { [[]] ctordtor [[]] () [[]]; ctordtor (C) [[]]; [[]] ~ctordtor [[]] () [[]]; }; [[]] ctordtor::ctordtor [[]] () [[]] {} [[]] ctordtor::ctordtor (C) [[]] try {} catch (...) {} [[]] ctordtor::~ctordtor [[]] () [[]] {} extern "C++" [[]] int extern_attr; template [[]] void template_attr (); [[]] [[]] int [[]] [[]] multi_attr [[]] [[]]; int comma_attr [[,]]; int scope_attr [[foo::]]; // expected-error {{expected identifier}} int (paren_attr) [[]]; // expected-error {{an attribute list cannot appear here}} unsigned [[]] int attr_in_decl_spec; // expected-error {{an attribute list cannot appear here}} unsigned [[]] int [[]] const double_decl_spec = 0; // expected-error 2{{an attribute list cannot appear here}} class foo { void const_after_attr () [[]] const; // expected-error {{expected ';'}} }; extern "C++" [[]] { } // expected-error {{an attribute list cannot appear here}} [[]] extern "C++" { } // expected-error {{an attribute list cannot appear here}} [[]] template void before_template_attr (); // expected-error {{an attribute list cannot appear here}} [[]] namespace ns { int i; } // expected-error {{an attribute list cannot appear here}} expected-note {{declared here}} [[]] static_assert(true, ""); //expected-error {{an attribute list cannot appear here}} [[]] asm(""); // expected-error {{an attribute list cannot appear here}} [[]] using ns::i; [[unknown]] using namespace ns; // expected-warning {{unknown attribute 'unknown' ignored}} [[noreturn]] using namespace ns; // expected-error {{'noreturn' attribute only applies to functions}} namespace [[]] ns2 {} // expected-warning {{attributes on a namespace declaration are a C++17 extension}} using[[]] alignas(4)[[]] ns::i; // expected-error {{an attribute list cannot appear here}} expected-error {{'alignas' attribute only applies to variables, data members and tag types}} expected-warning {{ISO C++}} using [[]] alignas(4) [[]] foobar = int; // expected-error {{an attribute list cannot appear here}} expected-error {{'alignas' attribute only applies to}} void bad_attributes_in_do_while() { do {} while ( [[ns::i); // expected-error {{expected ']'}} \ // expected-note {{to match this '['}} \ // expected-error {{expected expression}} do {} while ( [[a]b ns::i); // expected-error {{expected ']'}} \ // expected-note {{to match this '['}} \ // expected-error {{expected expression}} do {} while ( [[ab]ab] ns::i); // expected-error {{an attribute list cannot appear here}} do {} while ( // expected-note {{to match this '('}} alignas(4 ns::i; // expected-note {{to match this '('}} // expected-error@-1 {{expected ';' after do/while}} } // expected-error 2{{expected ')'}} expected-error {{expected expression}} [[]] using T = int; // expected-error {{an attribute list cannot appear here}} using T [[]] = int; // ok template using U [[]] = T; using ns::i [[]]; using ns::i [[]], ns::i [[]]; // expected-warning {{use of multiple declarators in a single using declaration is a C++17 extension}} struct using_in_struct_base { typedef int i, j, k, l; }; struct using_in_struct : using_in_struct_base { [[]] using using_in_struct_base::i; using using_in_struct_base::j [[]]; [[]] using using_in_struct_base::k [[]], using_in_struct_base::l [[]]; // expected-warning {{use of multiple declarators in a single using declaration is a C++17 extension}} }; using [[]] ns::i; // expected-error {{an attribute list cannot appear here}} using T [[unknown]] = int; // expected-warning {{unknown attribute 'unknown' ignored}} using T [[noreturn]] = int; // expected-error {{'noreturn' attribute only applies to functions}} using V = int; // expected-note {{previous}} using V [[gnu::vector_size(16)]] = int; // expected-error {{redefinition with different types}} auto trailing() -> [[]] const int; // expected-error {{an attribute list cannot appear here}} auto trailing() -> const [[]] int; // expected-error {{an attribute list cannot appear here}} auto trailing() -> const int [[]]; auto trailing_2() -> struct struct_attr [[]]; namespace N { struct S {}; }; template struct Template {}; // FIXME: Improve this diagnostic struct [[]] N::S s; // expected-error {{an attribute list cannot appear here}} struct [[]] Template t; // expected-error {{an attribute list cannot appear here}} struct [[]] ::template Template u; // expected-error {{an attribute list cannot appear here}} template struct [[]] Template; // expected-error {{an attribute list cannot appear here}} template struct __attribute__((pure)) Template; // We still allow GNU-style attributes here template <> struct [[]] Template; enum [[]] E1 {}; enum [[]] E2; // expected-error {{forbids forward references}} enum [[]] E1; enum [[]] E3 : int; enum [[]] { k_123 [[]] = 123 // expected-warning {{attributes on an enumerator declaration are a C++17 extension}} }; enum [[]] E1 e; // expected-error {{an attribute list cannot appear here}} enum [[]] class E4 { }; // expected-error {{an attribute list cannot appear here}} enum struct [[]] E5; struct S { friend int f [[]] (); // expected-FIXME{{an attribute list cannot appear here}} friend int f1 [[noreturn]] (); //expected-error{{an attribute list cannot appear here}} friend int f2 [[]] [[noreturn]] () {} [[]] friend int g(); // expected-error{{an attribute list cannot appear here}} [[]] friend int h() { } [[]] friend int f3(), f4(), f5(); // expected-error{{an attribute list cannot appear here}} friend int f6 [[noreturn]] (), f7 [[noreturn]] (), f8 [[noreturn]] (); // expected-error3 {{an attribute list cannot appear here}} friend class [[]] C; // expected-error{{an attribute list cannot appear here}} [[]] friend class D; // expected-error{{an attribute list cannot appear here}} [[]] friend int; // expected-error{{an attribute list cannot appear here}} }; template void tmpl(T) {} template void tmpl [[]] (int); // expected-FIXME {{an attribute list cannot appear here}} template [[]] void tmpl(char); // expected-error {{an attribute list cannot appear here}} template void [[]] tmpl(short); // Argument tests alignas int aligned_no_params; // expected-error {{expected '('}} alignas(i) int aligned_nonconst; // expected-error {{'aligned' attribute requires integer constant}} expected-note {{read of non-const variable 'i'}} // Statement tests void foo () { [[]] ; [[]] { } [[]] if (0) { } [[]] for (;;); [[]] do { [[]] continue; } while (0); [[]] while (0); [[]] switch (i) { [[]] case 0: [[]] default: [[]] break; } [[]] goto there; [[]] there: [[]] try { } [[]] catch (...) { // expected-error {{an attribute list cannot appear here}} } struct S { int arr[2]; } s; (void)s.arr[ [] { return 0; }() ]; // expected-error {{C++11 only allows consecutive left square brackets when introducing an attribute}} int n = __builtin_offsetof(S, arr[ [] { return 0; }() ]); // expected-error {{C++11 only allows consecutive left square brackets when introducing an attribute}} void bar [[noreturn]] ([[]] int i, [[]] int j); using FuncType = void ([[]] int); void baz([[]]...); // expected-error {{expected parameter declarator}} [[]] return; } template void variadic() { void bar [[noreturn...]] (); // expected-error {{attribute 'noreturn' cannot be used as an attribute pack}} } template void variadic_nttp() { void bar [[noreturn...]] (); // expected-error {{attribute 'noreturn' cannot be used as an attribute pack}} void baz [[clang::no_sanitize(Is...)]] (); // expected-error {{expected string literal as argument of 'no_sanitize' attribute}} void bor [[clang::annotate("A", "V" ...)]] (); // expected-error {{pack expansion does not contain any unexpanded parameter packs}} void bir [[clang::annotate("B", {1, 2, 3, 4})]] (); // expected-error {{'annotate' attribute requires parameter 1 to be a constant expression}} expected-note {{subexpression not valid in a constant expression}} void boo [[unknown::foo(Is...)]] (); // expected-warning {{unknown attribute 'foo' ignored}} void faz [[clang::annotate("C", (Is + ...))]] (); // expected-warning {{pack fold expression is a C++17 extension}} void far [[clang::annotate("D", Is...)]] (); void foz [[clang::annotate("E", 1, 2, 3, Is...)]] (); void fiz [[clang::annotate("F", Is..., 1, 2, 3)]] (); void fir [[clang::annotate("G", 1, Is..., 2, 3)]] (); } // Expression tests void bar () { // FIXME: GCC accepts [[gnu::noreturn]] on a lambda, even though it appertains // to the operator()'s type, and GCC does not otherwise accept attributes // applied to types. Use that to test this. [] () [[gnu::noreturn]] { return; } (); // expected-warning {{attribute 'noreturn' ignored}} FIXME-error {{should not return}} [] () [[gnu::noreturn]] { throw; } (); // expected-warning {{attribute 'noreturn' ignored}} new int[42][[]][5][[]]{}; } // Condition tests void baz () { if ([[unknown]] bool b = true) { // expected-warning {{unknown attribute 'unknown' ignored}} switch ([[unknown]] int n { 42 }) { // expected-warning {{unknown attribute 'unknown' ignored}} default: for ([[unknown]] int n = 0; [[unknown]] char b = n < 5; ++b) { // expected-warning 2{{unknown attribute 'unknown' ignored}} } } } int x; // An attribute can be applied to an expression-statement, such as the first // statement in a for. But it can't be applied to a condition which is an // expression. for ([[]] x = 0; ; ) {} // expected-error {{an attribute list cannot appear here}} for (; [[]] x < 5; ) {} // expected-error {{an attribute list cannot appear here}} while ([[]] bool k { false }) { } while ([[]] true) { // expected-error {{an attribute list cannot appear here}} } do { } while ([[]] false); // expected-error {{an attribute list cannot appear here}} for ([[unknown]] int n : { 1, 2, 3 }) { // expected-warning {{unknown attribute 'unknown' ignored}} } } enum class __attribute__((visibility("hidden"))) SecretKeepers { one, /* rest are deprecated */ two, three }; enum class [[]] EvenMoreSecrets {}; namespace arguments { void f[[gnu::format(printf, 1, 2)]](const char*, ...); void g() [[unknown::foo(ignore arguments for unknown attributes, even with symbols!)]]; // expected-warning {{unknown attribute 'foo' ignored}} [[deprecated("with argument")]] int i; // expected-warning@-1 {{use of the 'deprecated' attribute is a C++14 extension}} } // Forbid attributes on decl specifiers. unsigned [[gnu::used]] static int [[gnu::unused]] v1; // expected-error {{'unused' attribute cannot be applied to types}} \ expected-error {{an attribute list cannot appear here}} typedef [[gnu::used]] unsigned long [[gnu::unused]] v2; // expected-error {{'unused' attribute cannot be applied to types}} \ expected-error {{an attribute list cannot appear here}} int [[carries_dependency]] foo(int [[carries_dependency]] x); // expected-error 2{{'carries_dependency' attribute cannot be applied to types}} // Forbid [[gnu::...]] attributes on declarator chunks. int *[[gnu::unused]] v3; // expected-warning {{attribute 'unused' ignored}} int v4[2][[gnu::unused]]; // expected-warning {{attribute 'unused' ignored}} int v5()[[gnu::unused]]; // expected-warning {{attribute 'unused' ignored}} [[attribute_declaration]]; // expected-warning {{unknown attribute 'attribute_declaration' ignored}} [[noreturn]]; // expected-error {{'noreturn' attribute only applies to functions}} [[carries_dependency]]; // expected-error {{'carries_dependency' attribute only applies to parameters, Objective-C methods, and functions}} class A { A([[gnu::unused]] int a); }; A::A([[gnu::unused]] int a) {} namespace GccConst { // GCC's tokenizer treats const and __const as the same token. [[gnu::const]] int *f1(); [[gnu::__const]] int *f2(); [[gnu::__const__]] int *f3(); void f(const int *); void g() { f(f1()); f(f2()); } void h() { f(f3()); } } namespace GccASan { __attribute__((no_address_safety_analysis)) void f1(); __attribute__((no_sanitize_address)) void f2(); [[gnu::no_address_safety_analysis]] void f3(); [[gnu::no_sanitize_address]] void f4(); } namespace { [[deprecated]] void bar(); // expected-warning@-1 {{use of the 'deprecated' attribute is a C++14 extension}} [[deprecated("hello")]] void baz(); // expected-warning@-1 {{use of the 'deprecated' attribute is a C++14 extension}} [[deprecated()]] void foo(); // expected-error@-1 {{parentheses must be omitted if 'deprecated' attribute's argument list is empty}} [[gnu::deprecated()]] void quux(); } namespace { [[ // expected-error {{expected ']'}} #pragma pack(pop) deprecated ]] void bad(); } int fallthru(int n) { switch (n) { case 0: n += 5; [[fallthrough]]; // expected-warning {{use of the 'fallthrough' attribute is a C++17 extension}} case 1: n *= 2; break; } return n; } template struct TemplateStruct {}; class FriendClassesWithAttributes { // We allow GNU-style attributes here template friend class __attribute__((__type_visibility__("default"))) vector; template friend class __declspec(code_seg("foo,whatever")) vector2; // But not C++11 ones template friend class[[]] vector3; // expected-error {{an attribute list cannot appear here}} template friend class [[clang::__type_visibility__(("default"))]] vector4; // expected-error {{an attribute list cannot appear here}} // Also allowed friend struct __attribute__((__type_visibility__("default"))) TemplateStruct; friend struct __declspec(code_seg("foo,whatever")) TemplateStruct; friend struct[[]] TemplateStruct; // expected-error {{an attribute list cannot appear here}} friend struct [[clang::__type_visibility__("default")]] TemplateStruct; // expected-error {{an attribute list cannot appear here}} }; #define attr_name bitand #define attr_name_2(x) x #define attr_name_3(x, y) x##y [[attr_name, attr_name_2(bitor), attr_name_3(com, pl)]] int macro_attrs; // expected-warning {{unknown attribute 'compl' ignored}} \ expected-warning {{unknown attribute 'bitor' ignored}} \ expected-warning {{unknown attribute 'bitand' ignored}} // Check that we can parse an attribute in our vendor namespace. [[clang::annotate("test")]] void annotate1(); [[_Clang::annotate("test")]] void annotate2(); // Note: __clang__ is a predefined macro, which is why _Clang is the // prefered "protected" vendor namespace. We support __clang__ only for // people expecting it to behave the same as __gnu__. [[__clang__::annotate("test")]] void annotate3(); // expected-warning {{'__clang__' is a predefined macro name, not an attribute scope specifier; did you mean '_Clang' instead?}}">

Compiler Explorer - C++ (x86-64 clang (trunk)) (original) (raw)

Site theme

Colourise lines to show how the source maps to the output

Make all colour schemes available regardless of theme

Line highlighting colour scheme

Default language

Keep page status per tab

Allow my source code to be temporarily stored for diagnostic purposes in the event of an error

Use last selected language when opening new Editors

Show community events

Vim editor mode

MakeCtrl+S include and save the file to a Tree if that's added to the UI

Pop up a dialog box whenCtrl+S is set to create a short link.

Desired Font Family in editors

Default font scale

Enable font ligatures

Automatically insert matching brackets and parentheses

Automatically insert matching quotes

Automatically surround selected text when typing brackets or quotes

Automatically indent code (reload page after changing)

Highlight linked code lines on hover

Highlight linked code indefinitely

Show asm description on hover

Show quick suggestions

Use custom context menu

Show editor minimap

Keep editor source on language change

Use spaces for indentation

Tab width

Format based on

Enable Word Wrapping

Enable CodeLens features (requires refresh to take effect)

Colourise matching bracket pairs

Compile automatically when source changes

Use automatic delay before compiling

Delay before compiling:

0.25s 3s

Enable formatting on compilation (for supported languages)

Compile executor automatically when arguments change

Shake the status icon on argument warnings