Index
A
Absolute value (absval) function template
absval function
Access levels
class keyword
inheritance
privacy setting
public keyword
rational class
acehigh_less function
advance function
advance() member function
Algorithms
getline function
Palindromes
Argument-dependent lookup (ADL)
compiler
function arguments
numeric namespace
operator<<
Arithmetic operators
Arrays and vectors
problem
artifact_impl class
artifact Pimpl Wrapper Class
Assignment operators
Associative containers
acehigh_less
card module
high-card program
ordered containers
unordered containers
B
back_inserter
bad() member function
base() member function
begin() member function
Bidirectional iterator
Big and little numbers
byte-sized integers
conversion
discovering number of bits
integer arithmetic
integer literals
long integers
overload resolution
promotion
short integers
type casting
user-defined literal
Big-endian platform
Binary search algorithms
Bits
bitmasks
integer
bitwise operators
Flags Functions
formatting flags
manipulators
setf Member Function
unsetf Member Function
safe shifting
bitfields
overflow
portability
rotating integers
signed types
std
type conversions
unsigned types
shifting
bmi() function
Body mass index (BMI)
Bogus Metabolic Index (BMI)
Books and magazines
actions
attributes
behaviors
categorizations
differences
similarities
Boolean type
Byte-sized integers
C
C++ language
clang
command-line compiler options
command-line tools
comment
compliers
console application
library implementation
main program
menu item
modules
output operator
standard library
statements
test the program
variable
can_insert_back concept
Case-folding
harder cases
accents
error results
Greek fonts
problematic character sets
simple cases
tolower
toupper
word-counting program
Characters
calling std::isalnum
escape sequences
I/O
locale
newlines/portability
sets
std::locale{""} argument
types
wide characters
std::wstring type()
wchar_t
wide strings
character I/O
is_palindrome function
Character set
Character traits
comma
copying input to output
eq_int_type
get() function
invalid character values
policy functions
template
while loop
Class
dot (.) operator
Cartesian Point
compiler
constructor
SeeConstructors
definition
member functions
multiple data members in one declaration
struct keyword
Class keyword
point
vs. struct
Class templates
comparison operators
constraints
default constructor
member functions
mixing types
assignment operator
member template constructor
rational base types
rational.hpp header
overloaded function
point class
rational class
use
variable
clear() member function
Comma operator
Comparison algorithms
Comparison operators
Compile-time
conditional operator
consteval functions
constexpr functions
constinit variables
metaprogramming
user-defined literals
variable-length template
variables
Compound statements
errors
expression
finding statement errors
local definitions and scope
communicating intent
erase member function
local variable definitions
for loop
lower_bound algorithm
nested block
preventing mistakes
reusing names and memory
separator variable
for loop header definitions
null statement
simplified parse tree
syntax
while statement
Concepts
constraint
definition
signed_integral
Conditional operator
constexpr declarations
Seeif constexpr
constinit
consteval
const_iterator vs. const iterator
Constructors
addone return value
arguments
Class point
compiler’s default
container contents
copy constructor
human reader
implicit
initializer
normal initialization syntax
special member function
vector
visual
Containers
associative containers
ordered containers
unordered containers
characteristics
erase associative
erase sequence
exceptions
insert associative
insert/erase
insert sequence
iterators/references
member types
const_iterator
const_reference
iterator
key_type
reference
size_type
sequence containers
container.size() constraint
Contiguous iterator
convert member function
Copyable smart pointers
Copy constructor
copy_if function
count_down function
Currency value
Custom comparator
vs. primary template
Custom types
constructors
definition
overloading
rational Object
reduce Member Function
conversion
data members
I/O operators
I/O streams
member functions
assign member function
reduce() member function
new type definition
rational type
D
Declarations vs. definitions
member function
Decrement operator
erroneous program
input order
for loop header
Default constructor
Dependency graphs
Destructors
and constructors
copy constructor
expected and actual results
immediate base class
order of calling
pass-by-reference
special member function
Digital signal processors (DSPs)
Directed acyclic graph (DAG)
distance function
Documentation tag and markdown
@&, @@, @, @%, @<
@b word
@brief one-sentence-description
@c word
Doxygen code
@em word
@file file name
@link entity text @endlink
@mainpage title
@p name
palindrome documentation
@par title
@param name description
@post postcondition
@pre precondition
@return description
@see xref
dot (.) operator
Double-byte character set (DBCS)
Doxyfile
Doxygen
definition
structured comments
uses
drop_while adaptor
Dumb arrays
E
Enumerations
improvements
scoped
brand-new type
declaration
integral type
openmode type
underlying type
spaceship operator
strings
unscoped
eof() member function
equal algorithm
Error messages
bogus character
command-line tools
deliberate errors
errors and warnings
input and output operators
misspells
source code and compile
square-bracket character ([)
symbol errors
syntax and semantic errors
unknown name
Exception-handling system
Exceptions
catching
custom
error message
event-driven program
exception handler
I/O stream
numerator/denominator
program stack
standard
throw exceptions
throwing
Explicit specialization
Export modules
Exports area
Exports circumference ()
Exports pi
main program
std::istream
vital_stats class
Extern variables
F
Facets
I/O manipulators
num_put
use_facet function
fail() function
File I/O
reading files
writing files
File names
definition
directories navigation
errors
portable
extension
namespace-scope functions
path object
root name
working
hard links
path class
soft links
symbolic links
find() algorithm
Fixed-point numbers
fraction part
integer part
places
places10
round off
string representation
value_type
Floating-point
default format
definition
fixed format
format specifier
hexfloat format
literals
numbers
output
precision
scientific and fixed formats
significand
traits
Floating-point number
For loops
bounded loop
flow of control
initialization
loop control variable
missing condition
non-negative integers
postiteration
compute sum of integers
unbounded loop
format() function
Formatted output
default alignment
field width
fill characters
formatting output fields
member function syntax
multiplication table
powers program
problem
produce multiplication table
squares and cubes
std namespace
Forward iterator
fsys::copy() function
fsys::copy_symlink() function
fsys::create_hard_link() function
fsys::create_hard_link() function
fsys::path class
fsys::read_symlink() function
Full specialization
Function and operator overloading
adding base class
declaration
default arguments
primary restriction
print functions
type conversion
Function arguments
const_iterator
const placement
const reference
multiple output parameters
parameters
string
Function call operator
Function objects
Functions
counting word
declarations and definitions
examples
function call
main() function
print_result function
prompted_read function
return statement
Function templates
abbreviated
absolute value (absval) function
arguments
declarations/definitions
member
parameters
find algorithm
writing
G
Generate algorithm
generate_id class
Generic algorithm
common programming activities
output iterator
read iterator
std::copy algorithm
get() member function
get_dependency_order() function
get_money manipulator
Global module
Global namespaces
GNU Compiler Collection (GCC)
Graphical user interfaces (GUIs)
H
hash() function
hash<> class template
I
if constexpr statement
ignore_line function
Implicit conversion sequence (ICS)
Implicit specialization
Importing vs. including
Increment operator
Inheritance
default constructor
derived class
member function
printing messages, constructor
programming style
Initialization
Inline/not inline
forward declarations
include guards
module creation
quotes/brackets
Input iterators
Integer arithmetic
Integer expressions
division (/) operator
even/odd integers
procedural language
solution comparison
zero count
Integer literals
Integral constraint
Interface header
main.cpp file
rational.cpp file
rational.hpp file
International Components for Unicode (ICU)
I/O operators
error state
extractor
input operator
output operator
state flags
I/O streams
I/O texts
file modes
debug function
ifstream
ofstream
trivial debugging function
trunc mode
string streams
error checking
istringstream
Liters per Kilometer
miles-per-gallon approach
parsing string stream
str() member function
substr() function
unget() function
text conversion
calling interface
complicated version
destination string
format() function
from_string Function
rewriting to_string
std
to_string Function
ipower() function
isalnum function
istream_iterator
isupper/islower functions
Iterators
begin() member function
bidirectional
char and wchar_t types
constexpr specifier
const_iterator
constraints
contiguous
data vector
empty() member function
forward
functionality
input
member types
optimal algorithm
output
random access
random access and contiguous
sequence functor
sorting
specialized Iterators
base iterator
reverse_iterator
std::advance()
std::ranges::copy()
substitution tree
transforming data
type traits
virtual function
working principles, end iterators
J, K
javadoc tool
L
Lambda
lexicographical_compare algorithm
Linear search algorithms
Liskov’s Substitution Principle
Literals, numeric literal
Little-endian platform
Locales
num_get
numpunct
Locales
cached facet
character classification functions
character codes
classic locale
collation order
ctype facet
cultural differences
facets
global locale
I/O
isalpha function
ISO and POSIX standards
isprint
isupper function
number
real world
Logical operators
non-zero vector elements
short-circuiting guarantees
symbolic versions
Long integers
lower_bound function
M
main() function
Map data structure
dictionary/association
pairs
aligning words and counts
printing word frequencies
searching in
Math functions
Member access operators
Member functions
arguments
BMI Program
const
bmi_ member
Class point
passed by reference
print member function
record objects
Member function syntax
merge algorithm
message () function
message() member function
Metaprogramming
metafunction
variadic template
sizeof...operator
static_assert
mismatch function
Mix-ins
assignment_mixin Class Template
class template
protected access level
Modules
compling
declaration
definition
exporting
SeeExport modules
global
implementation
importing
interface
module keyword
rational class
writing
move algorithm
Multi-byte character sets
ASCII
DBCS
MBCS
SBCS
Multiple inheritance
mix-in
multiple base class
virtual base class
Multiplication operator
N
Name lookup
access rules
ADL
advantages
compiler
basic rule
class/enumeration/namespace
functions
member access operator
template parameters
unqualified name
Namespaces
alias
entities
fixed class
function declaration
global
lookup function
argument-dependent lookup (ADL)
global declarations
parser Namespace
token occurrences
macros
nested
rational class template
std
using declaration class
using directive
next function
next() member function
number_impl class
O
Object-oriented programming (OOP)
books/magazines
classification tree
inheritance
Liskov’s Substitution Principle
polymorphism
One-definition rule (ODR)
ostream_iterator type
Output iterator
Overloading
alpha string function
bool is_alpha(char ch)
bool is_alpha(std::string_view str)
char to_lower(char ch)
char to_upper(char ch)
definition
library writer
parameters
printing vectors
resize member function
sort function
std::string to_lower(std)
std::string to_upper(std)
uses
Overloading operators
arithmetic
binary/unary addition operators
floating-point implementation
optimizing operators
rational type
std
test program
comparing rational numbers
benefits
Equality Operator
implementation
< operator
testing
trivial functions
math functions
Overload resolution
add() function
compiler
implicit parameter
list initialization
rank functions
arithmetic conversions
exact match
ICS
promotion
standard conversion
tools
user-defined conversion
tie-breaker rules
tree() functions
override specifier
P
Parser-generator tools
Partial specialization
fixed class template
function template
template parameter
void argument
Pass-by-reference
permissions() member function
pipe (|) operator
point Class
access-level specifiers
store polar coordinates
Pointers
vs.addresses
definition
dependency graphs
programming problem
artifact
const pointer
containers
declaration
dependency graphs
flex-ref
makefile
references
topological sort
structured binding
Policy
array_storage Class Template
break statement
char_traits
class/class template
function parameter
input, mystring module
output, mystring module
mystring Class Template
std::basic_string
vector_storage Class Template
Polymorphism
precision member function
print_result function
print_table function
prompted_read function
Public vs. private
Pure virtual function
Hashable interface
HashableString Class
interface-based programming
Pure virtual functions
push_back() function
push_front member function
put_money manipulator
Q
Qualified name lookup
compiler
declaration
directive
now() function
scope (::) operator
typename keyword
value()
R
Random access iterator
Range adaptor
drop view
filter view
join view
keys view
reverse view
take view
transform view
values view
Range-flavored algorithms
Ranges
predicates
transsforming data
Rank functions
arithmetic conversions
exact match
ICS
promotion
standard conversion
tools
user-defined conversion
Rational operators, definition
rbegin() function
reduce() function
reduce() member function
References/slices
regex_match() function
Regular expressions
airifact module
depgraph module
local/global maps
NUM variable
parser module
parsing
per-target variables
SRC variable
std::regex object()
variable module
Regular expressions
airifact module
depgraph module
local/global maps
parser module
parsing
variable module
removal algorithm
remove_if() algorithm
rend() iterator
replace algorithm
Resource Acquisition Is Initialization (RAII)
ioflags class
I/O stream
object
skipws flag
std::hex manipulator
S
sanitize() function
Sequence containers
array class
card class
deque class
list class
vector class
Sequence module
Shift sequences
Short-circuiting operator
Short integers
Simple input
age-first program
interpreting input
name-first program
performs input and output
reading strings
sample inputs
undefined behavior results
uninitialized int variables
valid integer
Single-byte character set (SBCS)
size function
size () member function
Smart arrays
Smart pointers
iterators
pimpl
artifact class
artifact_impl classes
complete type
depgraph module
implementation
incomplete type
parser module
pimpl rapper
pointer-to-implementation
return type
smart arrays
sort algorithm
sort () function
Specialized iterators
Standard algorithms
Standard concepts
iterator
range
Standard exceptions
std::boolalpha manipulator()
std::format()
std::gcd()
std::generate algorithm()
std::generic_category()
std::locale::classic()
std::move()
artifact class
copying vs. moving
function argument
ordinary assignment
output
strings
gvalues
lvalues
member functions
copy assignment operator
copy constructor
default constructor
destructor
move assignment operator
move constructor
pointer-type data members
varibales members
prvalues
rvalues
xvalues
std::noboolalpha manipulator()
std::numeric_limits<bool>::min()
std::ranges::copy()
std::ranges::reverse()
std::ranges::size()
std::ranges::sort()
std::strcmp()
std::unordered_map()
Strings
Columns Aligned
Double-Quote Character
empty
initialize variables
nonempty strings
undefined behavior
uninitialized variables
variables
Substitution Failure Is Not An Error (SFINAE)
Substitution Principle
Symbolic links
T
Template instance
Template specializations
function template
primary
traits
TEST() function
Textual calculator
big leap forward
number_impl class
simple parser
Time-honored convention
transform algorithm
try-catch statement
Type casting
typedef
declaration
types
typedefs
compute_bmi() function
defining classes
using declaration
wrapper classes
Type polymorphism
class derived from B
format
output operator
parameter types
print function
reference-to-base class
showoff function
type traits
concepts
query
std::move()
U
unget() member function
Unicode
character set
code points
endianness
std
:u8string
surrogate pair
UTF-8
UTF-32
unique_ptr class
Universal character names
declaration
international characters
standard-compliant compiler
UTF-8 and UTF-16 strings
Unnamed functions
capturing local variables
.const capture
lambdas
naming
non-const capture
overloading
return type
Unqualified name lookup
V
Value template parameters
Value types
assigning
comparison
copying
height and weight types
ioflags class
moving
Vectors, sort function
Virtual function
base class function
destructors
movie class
print member function, movie class
override specifier
Visual constructors
vital_stats class
W, X, Y, Z
what() member function
while statement
world() function
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.