[std] Use \keyword for 'struct', 'class', 'union', 'enum'.

Author: jensmaurer

source/classes.tex

@@ -255,11 +255,11 @@
 
 \pnum
 A \defnadj{standard-layout}{struct} is a standard-layout class
-defined with the \grammarterm{class-key} \tcode{struct} or the
-\grammarterm{class-key} \tcode{class}.
+defined with the \grammarterm{class-key} \keyword{struct} or the
+\grammarterm{class-key} \keyword{class}.
 A \defnadj{standard-layout}{union} is a standard-layout class
 defined with the
-\grammarterm{class-key} \tcode{union}.
+\grammarterm{class-key} \keyword{union}.
 
 \pnum
 \begin{note}
@@ -360,7 +360,7 @@
 int stat(struct stat*);         // \tcode{stat} now also names a function
 
 void f() {
-  struct stat* ps;              // \tcode{struct} prefix needed to name \tcode{struct stat}
+  struct stat* ps;              // \keyword{struct} prefix needed to name \tcode{struct stat}
   stat(ps);                     // call \tcode{stat} function
 }
 \end{codeblock}
@@ -432,7 +432,7 @@
 \end{codeblock}
 first specifies \tcode{A} to be the name of a class and then redefines
 it as the name of a pointer to an object of that class. This means that
-the elaborated form \tcode{class} \tcode{A} must be used to refer to the
+the elaborated form \keyword{class} \tcode{A} must be used to refer to the
 class. Such artistry with names can be confusing and is best avoided.
 \end{note}
 
@@ -2942,7 +2942,7 @@
 
 \pnum
 A \defn{union} is a class defined with the \grammarterm{class-key}
-\tcode{union}.
+\keyword{union}.
 
 \pnum
 In a union,
@@ -3091,7 +3091,7 @@
 the use of a placement \grammarterm{new-expression}.
 \end{note}
 \begin{example}
-Consider an object \tcode{u} of a \tcode{union} type \tcode{U} having non-static data members
+Consider an object \tcode{u} of a \keyword{union} type \tcode{U} having non-static data members
 \tcode{m} of type \tcode{M} and \tcode{n} of type \tcode{N}. If \tcode{M} has a non-trivial
 destructor and \tcode{N} has a non-trivial constructor (for instance, if they declare or inherit
 virtual functions), the active member of \tcode{u} can be safely switched from \tcode{m} to
@@ -4110,12 +4110,12 @@
 \indextext{default access control|see{access control, default}}%
 \indextext{access control!default}%
 Members of a class defined with the keyword
-\tcode{class}
+\keyword{class}
 are
 \tcode{private}
 by default.
 Members of a class defined with the keywords
-\tcode{struct} or \tcode{union}
+\keyword{struct} or \keyword{union}
 are public by default.
 \begin{example}
 \begin{codeblock}
@@ -4278,7 +4278,7 @@
 \begin{example}
 \begin{codeblock}
 class X {
-  int a;            // \tcode{X::a} is private by default: \tcode{class} used
+  int a;            // \tcode{X::a} is private by default: \keyword{class} used
 public:
   int b;            // \tcode{X::b} is public
   int c;            // \tcode{X::c} is public
@@ -4291,7 +4291,7 @@
 \begin{example}
 \begin{codeblock}
 struct S {
-  int a;            // \tcode{S::a} is public by default: \tcode{struct} used
+  int a;            // \tcode{S::a} is public by default: \keyword{struct} used
 protected:
   int b;            // \tcode{S::b} is protected
 private:
@@ -4383,12 +4383,12 @@
 \tcode{public}
 is assumed when the derived class is
 defined with the \grammarterm{class-key}
-\tcode{struct}
+\keyword{struct}
 and
 \tcode{private}
 is assumed when the class is
 defined with the \grammarterm{class-key}
-\tcode{class}.
+\keyword{class}.
 \begin{example}
 \begin{codeblock}
 class B { @\commentellip@ };

source/compatibility.tex

@@ -1910,7 +1910,7 @@
 
 \diffref{basic.scope}
 \change
-A \tcode{struct} is a scope in \Cpp{}, not in C.
+A \keyword{struct} is a scope in \Cpp{}, not in C.
 For example,
 \begin{codeblock}
 struct X {
@@ -1926,9 +1926,9 @@
 \difficulty
 Semantic transformation.
 \howwide
-C programs use \tcode{struct} extremely frequently, but the
-change is only noticeable when \tcode{struct}, enumeration, or enumerator
-names are referred to outside the \tcode{struct}.
+C programs use \keyword{struct} extremely frequently, but the
+change is only noticeable when \keyword{struct}, enumeration, or enumerator
+names are referred to outside the \keyword{struct}.
 The latter is probably rare.
 
 \diffref{basic.link} [also \ref{dcl.type}]
@@ -1965,7 +1965,7 @@
 \change
 C allows ``compatible types'' in several places, \Cpp{} does not.\\
 For example,
-otherwise-identical \tcode{struct} types with different tag names
+otherwise-identical \keyword{struct} types with different tag names
 are ``compatible'' in C but are distinctly different types
 in \Cpp{}.
 \rationale
@@ -2200,7 +2200,7 @@
 
 \rationale
 For ease of use, \Cpp{} doesn't require that a type name be prefixed
-with the keywords \tcode{class}, \tcode{struct} or \tcode{union} when used in object
+with the keywords \keyword{class}, \keyword{struct} or \keyword{union} when used in object
 declarations or type casts.
 
 Example:
@@ -2487,7 +2487,7 @@
 can be attributed to the new \Cpp{} name space definition where a
 name can be declared as a type and as a non-type in a single scope
 causing the non-type name to hide the type name and requiring that
-the keywords \tcode{class}, \tcode{struct}, \tcode{union} or \tcode{enum} be used to refer to the type name.
+the keywords \keyword{class}, \keyword{struct}, \keyword{union} or \keyword{enum} be used to refer to the type name.
 This new name space definition provides important notational
 conveniences to \Cpp{} programmers and helps making the use of the
 user-defined types as similar as possible to the use of fundamental

source/declarations.tex

@@ -1514,19 +1514,19 @@
 \end{note}
 
 \pnum
-The \grammarterm{class-key} or \tcode{enum} keyword
+The \grammarterm{class-key} or \keyword{enum} keyword
 present in the
 \grammarterm{elaborated-type-specifier} shall agree in kind with the
 declaration to which the name in the
 \grammarterm{elaborated-type-specifier} refers. This rule also applies to
 the form of \grammarterm{elaborated-type-specifier} that declares a
 \grammarterm{class-name} or friend class since it can be construed
 as referring to the definition of the class. Thus, in any
-\grammarterm{elaborated-type-specifier}, the \tcode{enum} keyword
+\grammarterm{elaborated-type-specifier}, the \keyword{enum} keyword
 shall be
-used to refer to an enumeration\iref{dcl.enum}, the \tcode{union}
+used to refer to an enumeration\iref{dcl.enum}, the \keyword{union}
 \grammarterm{class-key} shall be used to refer to a union\iref{class.union},
-and either the \tcode{class} or \tcode{struct}
+and either the \keyword{class} or \keyword{struct}
 \grammarterm{class-key} shall be used to refer to a non-union class\iref{class.pre}.
 \begin{example}
 \begin{codeblock}
@@ -6791,7 +6791,7 @@
 in that \grammarterm{attribute-specifier-seq} are thereafter considered attributes of the
 enumeration whenever it is named.
 A \tcode{:} following
-``\tcode{enum} \opt{\grammarterm{nested-name-specifier}} \grammarterm{identifier}''
+``\keyword{enum} \opt{\grammarterm{nested-name-specifier}} \grammarterm{identifier}''
 within the \grammarterm{decl-specifier-seq} of a \grammarterm{member-declaration}
 is parsed as part of an \grammarterm{enum-base}.
 \begin{note}
@@ -6818,7 +6818,7 @@
 \pnum
 \indextext{constant!enumeration}%
 The enumeration type declared with an \grammarterm{enum-key}
-of only \tcode{enum} is an \defnadj{unscoped}{enumeration},
+of only \keyword{enum} is an \defnadj{unscoped}{enumeration},
 and its \grammarterm{enumerator}{s} are \defnx{unscoped enumerators}{enumerator!unscoped}.
 The \grammarterm{enum-key}{s} \tcode{enum class} and
 \tcode{enum struct} are semantically equivalent; an enumeration
@@ -6988,7 +6988,7 @@
 color c = 1;                    // error: type mismatch, no conversion from \tcode{int} to \tcode{color}
 int i = yellow;                 // OK: \tcode{yellow} converted to integral value \tcode{1}, integral promotion
 \end{codeblock}
-Note that this implicit \tcode{enum} to \tcode{int}
+Note that this implicit \keyword{enum} to \tcode{int}
 conversion is not provided for a scoped enumeration:
 \begin{codeblock}
 enum class Col { red, yellow, green };

source/numerics.tex

@@ -2826,7 +2826,7 @@
 
 \pnum
 It is unspecified whether \tcode{D::param_type}
-is declared as a (nested) \tcode{class}
+is declared as a (nested) \keyword{class}
 or via a \keyword{typedef}.
 In this subclause \ref{rand},
 declarations of \tcode{D::param_type}

source/templates.tex

@@ -258,7 +258,7 @@
 
 \pnum
 There is no semantic difference between
-\tcode{class}
+\keyword{class}
 and
 \keyword{typename}
 in a
@@ -284,7 +284,7 @@
 \end{footnote}
 \grammarterm{parameter-declaration}.
 A \grammarterm{template-parameter} of the form
-\tcode{class} \grammarterm{identifier} is a \grammarterm{type-parameter}.
+\keyword{class} \grammarterm{identifier} is a \grammarterm{type-parameter}.
 \begin{example}
 \begin{codeblock}
 class T { @\commentellip@ };
@@ -5868,7 +5868,7 @@
 \end{codeblock}
 
 Nothing in this example requires
-\tcode{class}
+\keyword{class}
 \tcode{Z<double>},
 \tcode{Z<int>::g()},
 or

source/threads.tex

@@ -5998,7 +5998,7 @@
 \end{codeblock}
 
 \pnum
-The \tcode{enum} type \tcode{launch} is a bitmask type\iref{bitmask.types} with
+The \keyword{enum} type \tcode{launch} is a bitmask type\iref{bitmask.types} with
 elements \tcode{launch::async} and \tcode{launch::deferred}.
 \begin{note}
 Implementations can provide bitmasks to specify restrictions on task

source/utilities.tex

@@ -1189,7 +1189,7 @@
 \end{itemdecl}
 
 \pnum
-The \tcode{struct} \tcode{piecewise_construct_t} is an empty class type
+The \keyword{struct} \tcode{piecewise_construct_t} is an empty class type
 used as a unique type to disambiguate constructor and function overloading. Specifically,
 \tcode{pair} has a constructor with \tcode{piecewise_construct_t} as the
 first argument, immediately followed by two \tcode{tuple}\iref{tuple} arguments used
@@ -16786,7 +16786,7 @@
 
 \indexlibraryglobal{is_trivially_constructible}%
 \tcode{template<class T, class... Args>}\br
-  \tcode{struct}\br
+  \keyword{struct}\br
   \tcode{is_trivially_constructible;} &
   \tcode{is_constructible_v<T,}\br
   \tcode{Args...>} is \tcode{true} and the variable
@@ -17641,7 +17641,7 @@
 \tcode{template<class, class,}
  \hspace*{2ex}\tcode{template<class> class,}
  \hspace*{2ex}\tcode{template<class> class>}
- \tcode{struct}
+ \keyword{struct}
  \hspace*{2ex}\tcode{basic_common_reference;}
  &
  Unless this trait is specialized (as specified in Note D, below),