[std] Use \keyword for 'const_cast'.

Author: jensmaurer

source/basic.tex

@@ -4392,7 +4392,7 @@
 \item
   a
   \begin{itemize}
-  \item \tcode{const_cast}\iref{expr.const.cast},
+  \item \keyword{const_cast}\iref{expr.const.cast},
   \item \keyword{static_cast}\iref{expr.static.cast},
   \item \tcode{dynamic_cast}\iref{expr.dynamic.cast}, or
   \item \tcode{reinterpret_cast}\iref{expr.reinterpret.cast}

source/compatibility.tex

@@ -2546,7 +2546,7 @@
 be provided.
 If non-volatile semantics are required,
 an explicit
-\tcode{const_cast}
+\keyword{const_cast}
 can be used.
 \howwide
 Seldom.

source/expressions.tex

@@ -2931,7 +2931,7 @@
 The \tcode{>} token following the
 \grammarterm{type-id} in a \tcode{dynamic_cast},
 \keyword{static_cast}, \tcode{reinterpret_cast}, or
-\tcode{const_cast} can be the product of replacing a
+\keyword{const_cast} can be the product of replacing a
 \tcode{>>} token by two consecutive \tcode{>}
 tokens\iref{temp.names}.
 \end{note}
@@ -3174,7 +3174,7 @@
 A function can change the values of its non-const parameters, but these
 changes cannot affect the values of the arguments except where a
 parameter is of a reference type\iref{dcl.ref}; if the reference is to
-a const-qualified type, \tcode{const_cast} is required to be used to
+a const-qualified type, \keyword{const_cast} is required to be used to
 cast away the constness in order to modify the argument's value. Where a
 parameter is of \tcode{const} reference type a temporary object is
 introduced if
@@ -4131,22 +4131,22 @@
 lvalue-to-rvalue\iref{conv.lval}, array-to-pointer\iref{conv.array},
 and function-to-pointer\iref{conv.func} standard conversions are
 performed on the expression \tcode{v}. Conversions that can be performed explicitly using
-\tcode{const_cast} are listed below. No other conversion shall be
-performed explicitly using \tcode{const_cast}.
+\keyword{const_cast} are listed below. No other conversion shall be
+performed explicitly using \keyword{const_cast}.
 
 \pnum
 \begin{note}
 Subject to the restrictions in this subclause, an expression can be cast
-to its own type using a \tcode{const_cast} operator.
+to its own type using a \keyword{const_cast} operator.
 \end{note}
 
 \pnum
 For two similar types \tcode{T1} and \tcode{T2}\iref{conv.qual},
 a prvalue of type \tcode{T1} may be explicitly
-converted to the type \tcode{T2} using a \tcode{const_cast}
+converted to the type \tcode{T2} using a \keyword{const_cast}
 if, considering the qualification-decompositions of both types,
 each $P^1_i$ is the same as $P^2_i$ for all $i$.
-The result of a \tcode{const_cast} refers to the original entity.
+The result of a \keyword{const_cast} refers to the original entity.
 \begin{example}
 \begin{codeblock}
 typedef int *A[3];                  // array of 3 pointer to \tcode{int}
@@ -4162,7 +4162,7 @@
 \pnum
 For two object types \tcode{T1} and \tcode{T2}, if a pointer to \tcode{T1} can
 be explicitly converted to the type ``pointer to \tcode{T2}'' using a
-\tcode{const_cast}, then the following conversions can also be made:
+\keyword{const_cast}, then the following conversions can also be made:
 \begin{itemize}
 \item an lvalue of type \tcode{T1} can be explicitly converted to an lvalue
 of type \tcode{T2} using the cast \tcode{const_cast<T2\&>};
@@ -4175,7 +4175,7 @@
 \tcode{const_cast<T2\&\&>}.
 \end{itemize}
 
-The result of a reference \tcode{const_cast} refers
+The result of a reference \keyword{const_cast} refers
 to the original object if the operand is a glvalue and
 to the result of applying the temporary materialization conversion\iref{conv.rval} otherwise.
 
@@ -4189,9 +4189,9 @@
 \begin{note}
 Depending on the type of the object, a write operation through the
 pointer, lvalue or pointer to data member resulting from a
-\tcode{const_cast} that casts away a const-qualifier
+\keyword{const_cast} that casts away a const-qualifier
 \begin{footnote}
-\tcode{const_cast}
+\keyword{const_cast}
 is not limited to conversions that cast away a
 const-qualifier.
 \end{footnote}
@@ -5660,7 +5660,7 @@
 An explicit type conversion can be expressed using functional
 notation\iref{expr.type.conv}, a type conversion operator
 (\tcode{dynamic_cast}, \keyword{static_cast}, \tcode{reinterpret_cast},
-\tcode{const_cast}), or the \term{cast} notation.
+\keyword{const_cast}), or the \term{cast} notation.
 
 \begin{bnf}
 \nontermdef{cast-expression}\br
@@ -5678,11 +5678,11 @@
 \indextext{cast!const}%
 \indextext{cast!static}%
 \indextext{cast!reinterpret}%
-\item a \tcode{const_cast}\iref{expr.const.cast},
+\item a \keyword{const_cast}\iref{expr.const.cast},
 \item a \keyword{static_cast}\iref{expr.static.cast},
-\item a \keyword{static_cast} followed by a \tcode{const_cast},
+\item a \keyword{static_cast} followed by a \keyword{const_cast},
 \item a \tcode{reinterpret_cast}\iref{expr.reinterpret.cast}, or
-\item a \tcode{reinterpret_cast} followed by a \tcode{const_cast},
+\item a \tcode{reinterpret_cast} followed by a \keyword{const_cast},
 \end{itemize}
 can be performed using the cast notation of explicit type conversion.
 The same semantic restrictions and behaviors apply, with the exception
@@ -5708,7 +5708,7 @@
 above, the interpretation that appears first in the list is used, even
 if a cast resulting from that interpretation is ill-formed. If a
 conversion can be interpreted in more than one way as a
-\keyword{static_cast} followed by a \tcode{const_cast}, the conversion is
+\keyword{static_cast} followed by a \keyword{const_cast}, the conversion is
 ill-formed.
 \begin{example}
 \begin{codeblock}

source/iterators.tex

@@ -1291,7 +1291,7 @@
 
 \pnum
 \begin{note}
-\libconcept{indirectly_writable} has the awkward \tcode{const_cast} expressions to reject
+\libconcept{indirectly_writable} has the awkward \keyword{const_cast} expressions to reject
 iterators with prvalue non-proxy reference types that permit rvalue
 assignment but do not also permit \tcode{const} rvalue assignment.
 Consequently, an iterator type \tcode{I} that returns \tcode{std::string}

source/templates.tex

@@ -748,7 +748,7 @@
 \begin{footnote}
 A \tcode{>} that encloses the \grammarterm{type-id}
 of a \tcode{dynamic_cast}, \keyword{static_cast}, \tcode{reinterpret_cast}
-or \tcode{const_cast}, or which encloses the \grammarterm{template-argument}{s}
+or \keyword{const_cast}, or which encloses the \grammarterm{template-argument}{s}
 of a subsequent \grammarterm{template-id}, is considered nested for the purpose
 of this description.
 \end{footnote}