|
121 | 121 | \indexdefn{access}%
|
122 | 122 | \definition{access}{defns.access}
|
123 | 123 | \defncontext{execution-time action}
|
124 |
| -read\iref{conv.lval} or |
125 |
| -modify (\ref{expr.ass}, \ref{expr.post.incr}, \ref{expr.pre.incr}) |
126 |
| -the value of an object |
| 124 | +read or modify the value of an object |
127 | 125 |
|
128 | 126 | \begin{defnote}
|
129 | 127 | Only objects of scalar type can be accessed.
|
|
137 | 135 | \definition{arbitrary-positional stream}{defns.arbitrary.stream}
|
138 | 136 | \defncontext{library}
|
139 | 137 | \indexdefn{stream!arbitrary-positional}%
|
140 |
| -stream (described in \ref{input.output}) that can seek to any integral position within |
| 138 | +stream that can seek to any integral position within |
141 | 139 | the length of the stream
|
142 | 140 |
|
143 | 141 | \begin{defnote}
|
144 |
| -Every arbitrary-positional stream is also a repositional stream. |
| 142 | +Every arbitrary-positional stream is also a repositional stream\iref{defns.repositional.stream}. |
145 | 143 | \end{defnote}
|
146 | 144 |
|
147 | 145 | \indexdefn{argument}%
|
148 | 146 | \indexdefn{argument!function call expression}
|
149 | 147 | \definition{argument}{defns.argument}
|
150 | 148 | \defncontext{function call expression} expression in the
|
151 |
| -comma-separated list bounded by the parentheses\iref{expr.call} |
| 149 | +comma-separated list bounded by the parentheses |
152 | 150 |
|
153 | 151 | \indexdefn{argument}%
|
154 | 152 | \indexdefn{argument!function-like macro}%
|
155 | 153 | \definition{argument}{defns.argument.macro}
|
156 | 154 | \defncontext{function-like macro} sequence of preprocessing tokens in the
|
157 |
| -comma-separated list bounded by the parentheses\iref{cpp.replace} |
| 155 | +comma-separated list bounded by the parentheses |
158 | 156 |
|
159 | 157 | \indexdefn{argument}%
|
160 | 158 | \indexdefn{argument!throw expression}%
|
161 | 159 | \definition{argument}{defns.argument.throw}
|
162 |
| -\defncontext{throw expression} operand of \tcode{throw}\iref{expr.throw} |
| 160 | +\defncontext{throw expression} operand of \keyword{throw} |
163 | 161 |
|
164 | 162 | \indexdefn{argument}%
|
165 | 163 | \indexdefn{argument!template instantiation}%
|
|
168 | 166 | \grammarterm{constant-expression},
|
169 | 167 | \grammarterm{type-id}, or
|
170 | 168 | \grammarterm{id-expression} in the comma-separated
|
171 |
| -list bounded by the angle brackets\iref{temp.arg} |
| 169 | +list bounded by the angle brackets |
172 | 170 |
|
173 | 171 | \indexdefn{block (execution)}%
|
174 | 172 | \definition{block}{defns.block}
|
|
180 | 178 | \indexdefn{block (statement)}%
|
181 | 179 | \definition{block}{defns.block.stmt}
|
182 | 180 | \defncontext{statement}
|
183 |
| -compound statement\iref{stmt.block} |
| 181 | +compound statement |
184 | 182 |
|
185 | 183 | \definition{character}{defns.character}
|
186 | 184 | \indexdefn{character}%
|
|
197 | 195 | \tcode{char32_t},
|
198 | 196 | and
|
199 | 197 | \tcode{wchar_t}
|
200 |
| -objects, |
| 198 | +objects\iref{basic.fundamental}, |
201 | 199 | but any value that can be represented by a type
|
202 | 200 | that provides the definitions specified in
|
203 | 201 | \ref{strings}, \ref{localization}, \ref{input.output}, or~\ref{re}.
|
|
243 | 241 | \indexdefn{constant subexpression}%
|
244 | 242 | expression whose evaluation as subexpression of a
|
245 | 243 | \grammarterm{conditional-expression}
|
246 |
| -\tcode{CE}\iref{expr.cond} would not prevent \tcode{CE} |
247 |
| -from being a core constant expression\iref{expr.const} |
| 244 | +\tcode{CE} would not prevent \tcode{CE} |
| 245 | +from being a core constant expression |
248 | 246 |
|
249 | 247 | \definition{deadlock}{defns.deadlock}
|
250 | 248 | \defncontext{library}
|
|
266 | 264 |
|
267 | 265 | \definition{direct-non-list-initialization}{defns.direct-non-list-init}
|
268 | 266 | \indexdefn{direct-non-list-initialization}%
|
269 |
| -direct-initialization\iref{dcl.init} |
270 |
| -that is not list-initialization\iref{dcl.init.list} |
| 267 | +direct-initialization |
| 268 | +that is not list-initialization |
271 | 269 |
|
272 | 270 | \indexdefn{type!dynamic}%
|
273 | 271 | \definition{dynamic type}{defns.dynamic.type}
|
274 |
| -\defncontext{glvalue} type of the most derived object\iref{intro.object} to which the |
| 272 | +\defncontext{glvalue} type of the most derived object to which the |
275 | 273 | glvalue refers
|
276 | 274 |
|
277 | 275 | \begin{example}
|
|
291 | 289 | \indexdefn{expression-equivalent}%
|
292 | 290 | expressions that all have the same effects,
|
293 | 291 | either
|
294 |
| -are all potentially-throwing\iref{except.spec} or |
| 292 | +are all potentially-throwing or |
295 | 293 | are all not potentially-throwing,
|
296 | 294 | and
|
297 | 295 | either
|
|
345 | 343 |
|
346 | 344 | \definition{iostream class templates}{defns.iostream.templates}
|
347 | 345 | \defncontext{library}
|
348 |
| -templates, defined in \ref{input.output}, |
349 |
| -that take two template arguments |
| 346 | +templates that take two template arguments |
| 347 | +and are declared in header \libheader{iosfwd} |
350 | 348 |
|
351 | 349 | \begin{defnote}
|
352 | 350 | The arguments are named \tcode{charT} and \tcode{traits}.
|
|
365 | 363 | \definition{modifier function}{defns.modifier}
|
366 | 364 | \defncontext{library}
|
367 | 365 | \indexdefn{function!modifier}%
|
368 |
| -class member function\iref{class.mfct} other than a constructor, |
| 366 | +class member function other than a constructor, |
369 | 367 | assignment operator, or destructor
|
370 | 368 | that alters the state of an object of the class
|
371 | 369 |
|
|
402 | 400 | \definition{observer function}{defns.observer}
|
403 | 401 | \defncontext{library}
|
404 | 402 | \indexdefn{function!observer}%
|
405 |
| -class member function\iref{class.mfct} that accesses the state of an object of the class |
| 403 | +class member function that accesses the state of an object of the class |
406 | 404 | but does not alter that state
|
407 | 405 |
|
408 | 406 | \begin{defnote}
|
|
495 | 493 | \definition{repositional stream}{defns.repositional.stream}
|
496 | 494 | \defncontext{library}
|
497 | 495 | \indexdefn{stream!repositional}%
|
498 |
| -stream (described in \ref{input.output}) that can seek to a position that was |
499 |
| -previously encountered |
| 496 | +stream that can seek to a position that was previously encountered |
500 | 497 |
|
501 | 498 | \definition{required behavior}{defns.required.behavior}
|
502 | 499 | \defncontext{library}
|
|
526 | 523 | \definition{signature}{defns.signature}
|
527 | 524 | \defncontext{function}
|
528 | 525 | name,
|
529 |
| -parameter-type-list\iref{dcl.fct}, |
| 526 | +parameter-type-list, |
530 | 527 | and enclosing namespace (if any)
|
531 | 528 |
|
532 | 529 | \begin{defnote}
|
|
538 | 535 | \definition{signature}{defns.signature.friend}
|
539 | 536 | \defncontext{non-template friend function with trailing \grammarterm{requires-clause}}
|
540 | 537 | name,
|
541 |
| -parameter-type-list\iref{dcl.fct}, |
| 538 | +parameter-type-list, |
542 | 539 | enclosing class,
|
543 | 540 | and
|
544 |
| -trailing \grammarterm{requires-clause}\iref{dcl.decl} |
| 541 | +trailing \grammarterm{requires-clause} |
545 | 542 |
|
546 | 543 | \indexdefn{signature}%
|
547 | 544 | \definition{signature}{defns.signature.templ}
|
548 | 545 | \defncontext{function template}
|
549 | 546 | name,
|
550 |
| -parameter-type-list\iref{dcl.fct}, |
| 547 | +parameter-type-list, |
551 | 548 | enclosing namespace (if any),
|
552 | 549 | return type,
|
553 | 550 | \grammarterm{template-head},
|
554 | 551 | and
|
555 |
| -trailing \grammarterm{requires-clause}\iref{dcl.decl} (if any) |
| 552 | +trailing \grammarterm{requires-clause} (if any) |
556 | 553 |
|
557 | 554 | \indexdefn{signature}%
|
558 | 555 | \definition{signature}{defns.signature.templ.friend}
|
559 | 556 | \defncontext{friend function template with constraint involving enclosing template parameters}
|
560 | 557 | name,
|
561 |
| -parameter-type-list\iref{dcl.fct}, |
| 558 | +parameter-type-list, |
562 | 559 | return type,
|
563 | 560 | enclosing class,
|
564 | 561 | \grammarterm{template-head},
|
565 | 562 | and
|
566 |
| -trailing \grammarterm{requires-clause}\iref{dcl.decl} (if any) |
| 563 | +trailing \grammarterm{requires-clause} (if any) |
567 | 564 |
|
568 | 565 | \indexdefn{signature}%
|
569 | 566 | \definition{signature}{defns.signature.spec}
|
|
574 | 571 | \definition{signature}{defns.signature.member}
|
575 | 572 | \defncontext{class member function}
|
576 | 573 | name,
|
577 |
| -parameter-type-list\iref{dcl.fct}, |
| 574 | +parameter-type-list, |
578 | 575 | class of which the function is a member,
|
579 | 576 | \cv-qualifiers (if any),
|
580 | 577 | \grammarterm{ref-qualifier} (if any),
|
581 | 578 | and
|
582 |
| -trailing \grammarterm{requires-clause}\iref{dcl.decl} (if any) |
| 579 | +trailing \grammarterm{requires-clause} (if any) |
583 | 580 |
|
584 | 581 | \indexdefn{signature}%
|
585 | 582 | \definition{signature}{defns.signature.member.templ}
|
586 | 583 | \defncontext{class member function template}
|
587 | 584 | name,
|
588 |
| -parameter-type-list\iref{dcl.fct}, |
| 585 | +parameter-type-list, |
589 | 586 | class of which the function is a member,
|
590 | 587 | \cv-qualifiers (if any),
|
591 | 588 | \grammarterm{ref-qualifier} (if any),
|
592 | 589 | return type (if any),
|
593 | 590 | \grammarterm{template-head},
|
594 | 591 | and
|
595 |
| -trailing \grammarterm{requires-clause}\iref{dcl.decl} (if any) |
| 592 | +trailing \grammarterm{requires-clause} (if any) |
596 | 593 |
|
597 | 594 | \indexdefn{signature}%
|
598 | 595 | \definition{signature}{defns.signature.member.spec}
|
|
612 | 609 |
|
613 | 610 | \indexdefn{type!static}%
|
614 | 611 | \definition{static type}{defns.static.type}
|
615 |
| -type of an expression\iref{basic.types} resulting from |
| 612 | +type of an expression resulting from |
616 | 613 | analysis of the program without considering execution semantics
|
617 | 614 |
|
618 | 615 | \begin{defnote}
|
|
678 | 675 | \indexdefn{program!well-formed}%
|
679 | 676 | \definition{well-formed program}{defns.well.formed}
|
680 | 677 | \Cpp{} program constructed according to the syntax rules, diagnosable
|
681 |
| -semantic rules, and the one-definition rule\iref{basic.def.odr}% |
| 678 | +semantic rules, and the one-definition rule% |
682 | 679 | \indextext{definitions|)}
|
683 | 680 |
|
684 | 681 | \rSec0[intro]{General principles}
|
|
0 commit comments