[expr.prim.general] - C++14 → C++17

Files changed (1) hide show

tmp/tmp2v2fpqj7/{from.md → to.md} +0 -175

tmp/tmp2v2fpqj7/{from.md → to.md} RENAMED Viewed

@@ -1,175 +0,0 @@
-### General <a id="expr.prim.general">[[expr.prim.general]]</a>
-``` bnf
-primary-expression:
-    literal
-    'this'
-    '(' expression ')'
-    id-expression
-    lambda-expression
-```
-``` bnf
-id-expression:
-    unqualified-id
-    qualified-id
-```
-``` bnf
-unqualified-id:
-    identifier
-    operator-function-id
-    conversion-function-id
-    literal-operator-id
-    '~' class-name
-    '~' decltype-specifier
-    template-id
-```
-A *literal* is a primary expression. Its type depends on its form (
-[[lex.literal]]). A string literal is an lvalue; all other literals are
-prvalues.
-The keyword `this` names a pointer to the object for which a non-static
-member function ([[class.this]]) is invoked or a non-static data
-member’s initializer ([[class.mem]]) is evaluated.
-If a declaration declares a member function or member function template
-of a class `X`, the expression `this` is a prvalue of type “pointer to
-*cv-qualifier-seq* `X`” between the optional *cv-qualifer-seq* and the
-end of the *function-definition*, *member-declarator*, or *declarator*.
-It shall not appear before the optional *cv-qualifier-seq* and it shall
-not appear within the declaration of a static member function (although
-its type and value category are defined within a static member function
-as they are within a non-static member function). this is because
-declaration matching does not occur until the complete declarator is
-known. Unlike the object expression in other contexts, `*this` is not
-required to be of complete type for purposes of class member access (
-[[expr.ref]]) outside the member function body. only class members
-declared prior to the declaration are visible.
-``` cpp
-struct A {
-  char g();
-  template<class T> auto f(T t) -> decltype(t + g())
-    { return t + g(); }
-};
-template auto A::f(int t) -> decltype(t + g());
-```
-Otherwise, if a *member-declarator* declares a non-static data member (
-[[class.mem]]) of a class `X`, the expression `this` is a prvalue of
-type “pointer to `X`” within the optional *brace-or-equal-initializer*.
-It shall not appear elsewhere in the *member-declarator*.
-The expression `this` shall not appear in any other context.
-``` cpp
-class Outer {
-  int a[sizeof(*this)];               // error: not inside a member function
-  unsigned int sz = sizeof(*this);    // OK: in brace-or-equal-initializer
-  void f() {
-    int b[sizeof(*this)];             // OK
-    struct Inner {
-      int c[sizeof(*this)];           // error: not inside a member function of Inner
-    };
-  }
-};
-```
-A parenthesized expression is a primary expression whose type and value
-are identical to those of the enclosed expression. The presence of
-parentheses does not affect whether the expression is an lvalue. The
-parenthesized expression can be used in exactly the same contexts as
-those where the enclosed expression can be used, and with the same
-meaning, except as otherwise indicated.
-An *id-expression* is a restricted form of a *primary-expression*. an
-*id-expression* can appear after `.` and `->` operators ([[expr.ref]]).
-An *identifier* is an *id-expression* provided it has been suitably
-declared (Clause  [[dcl.dcl]]). for *operator-function-id*s, see
-[[over.oper]]; for *conversion-function-id*s, see  [[class.conv.fct]];
-for *literal-operator-id*s, see  [[over.literal]]; for *template-id*s,
-see  [[temp.names]]. A *class-name* or *decltype-specifier* prefixed by
-`~` denotes a destructor; see  [[class.dtor]]. Within the definition of
-a non-static member function, an *identifier* that names a non-static
-member is transformed to a class member access expression (
-[[class.mfct.non-static]]). The type of the expression is the type of
-the *identifier*. The result is the entity denoted by the identifier.
-The result is an lvalue if the entity is a function, variable, or data
-member and a prvalue otherwise.
-``` bnf
-qualified-id:
-    nested-name-specifier 'template'ₒₚₜ unqualified-id
-```
-``` bnf
-nested-name-specifier:
-    '::'
-    type-name '::'
-    namespace-name '::'
-    decltype-specifier '::'
-    nested-name-specifier identifier '::'
-    nested-name-specifier 'template'ₒₚₜ simple-template-id '::'
-```
-The type denoted by a *decltype-specifier* in a *nested-name-specifier*
-shall be a class or enumeration type.
-A *nested-name-specifier* that denotes a class, optionally followed by
-the keyword `template` ([[temp.names]]), and then followed by the name
-of a member of either that class ([[class.mem]]) or one of its base
-classes (Clause  [[class.derived]]), is a *qualified-id*;
-[[class.qual]] describes name lookup for class members that appear in
-*qualified-ids*. The result is the member. The type of the result is the
-type of the member. The result is an lvalue if the member is a static
-member function or a data member and a prvalue otherwise. a class member
-can be referred to using a *qualified-id* at any point in its potential
-scope ([[basic.scope.class]]). Where *class-name* `::~` *class-name* is
-used, the two *class-name*s shall refer to the same class; this notation
-names the destructor ([[class.dtor]]). The form
-`~` *decltype-specifier* also denotes the destructor, but it shall not
-be used as the *unqualified-id* in a *qualified-id*. a *typedef-name*
-that names a class is a *class-name* ([[class.name]]).
-A `::`, or a *nested-name-specifier* that names a namespace (
-[[basic.namespace]]), in either case followed by the name of a member of
-that namespace (or the name of a member of a namespace made visible by a
-*using-directive*) is a *qualified-id*;  [[namespace.qual]] describes
-name lookup for namespace members that appear in *qualified-ids*. The
-result is the member. The type of the result is the type of the member.
-The result is an lvalue if the member is a function or a variable and a
-prvalue otherwise.
-A *nested-name-specifier* that denotes an enumeration ([[dcl.enum]]),
-followed by the name of an enumerator of that enumeration, is a
-*qualified-id* that refers to the enumerator. The result is the
-enumerator. The type of the result is the type of the enumeration. The
-result is a prvalue.
-In a *qualified-id*, if the *unqualified-id* is a
-*conversion-function-id*, its *conversion-type-id* shall denote the same
-type in both the context in which the entire *qualified-id* occurs and
-in the context of the class denoted by the *nested-name-specifier*.
-An *id-expression* that denotes a non-static data member or non-static
-member function of a class can only be used:
-- as part of a class member access ([[expr.ref]]) in which the object
-  expression refers to the member’s class[^4] or a class derived from
-  that class, or
-- to form a pointer to member ([[expr.unary.op]]), or
-- if that *id-expression* denotes a non-static data member and it
-  appears in an unevaluated operand.
-  ``` cpp
-  struct S {
-    int m;
-  };
-  int i = sizeof(S::m);           // OK
-  int j = sizeof(S::m + 42);      // OK
-  ```

Diff to HTML by rtfpessoa