Beginning C++17: From Novice to Professional

0-9/Symbols

!

!=

#

##

%

&

address-of operator

bitwise operator

capture default

&&

*

indirection operator

iterators

multiplication

+

iterators

++

increment operator

iterators

,

-

--

decrement operator

iterators

/

=

capture default

==

?:

[]

arrays

lambda initializer

map<>

sequence containers

std::array<>

std::string

std::vector<>

structured binding

^

||

->

iterators

lambda return type

member access operator

trailing return type

<

<=

<<

bitwise operator

overloading

stream operator

>

>=

>>

bitwise operator

overloading

stream operator

A

abort()

abs()

Absolute value

Abstract classes

Accessor function

Access specifiers

private

protected

public

Access violation

acos()

Addition

Address

Address-of

adjecent_find()

Aggregation

Algorithms

Alias

function pointer type

namespace

type

Alias template

Alignment

Alpha channel

AND

bitwise operator

logical operators

Anonymous function

append()

Argument

function

function template

Arithmetic expressions

Array

characters

index

initialization

multidimensional

size

variable

variable-length

<array>

array<>

ASCII

as_const()

asin()

assert()

Assertion

runtime

static

assign()

string

vector

Assignment

Assignment operator

copy

move

Associative array

Associativity

at()

array<>

sequence containers

string

vector<>

atan()

atan2()

auto

in range-based for

return type

variable type

Automatic variable

B

back()

sequence containers

string

vector<>

back_inserter()

bad_alloc

bad_cast

bad_function_call

bad_optional_access

bad_typeid

Balanced tree

Base

Base class

Base class pointer

Base class specifier

basic_string

begin()

Behavior

Bidirectional iterator

Bi-endian

Binary addition

Binary literals

Binary notation

binary_search()

Binding

Bit

bit_and<>

bit_not<>

bit_or<>

Bitwise operators

AND

combining

complement

logical

OR

shift

XOR

bit_xor<>

Block

bool

boolalpha

Booleans

Braced initializer

break

from loop

from switch

Byte

C

C++11

C++14

C++17

Callback function

Capitalize letters

Capture-by-value

Capture clause

Capture default

case

Cast

const_cast<>

C-style

dynamic_cast<>

overloading

static_cast<>

Catastrophic cancellation

catch

Catch-all

cbegin()

ceil()

cend()

char

Character arrays

Character classification

Character conversion

Character literal

Characters

ASCII

escaping

representation

source

Unicode

char16_t

char32_t

cin

Class

class

class definition

template parameter

Class definition

Class diagram

Class template

Class template argument deduction

clear()

containers

set<>

string

vector<>

<cmath>

Code duplication

Coding style

Combining logical operators

Comments

compare()

Comparing strings

Comparison operators

Compiler

Composition

Compound assignment

Compound statement

Concatenation

characters

numbers

strings

string views

Conditional operator

conditional_t<>

const

functions

objects

overloading

parameter

pointer

variable

const -and-back-again

Constants

const_cast<>

const correctness

constexpr

Const iterator

Constructor

delegation

inheritance

Container adapter

Containers

continue

Conversion

copy()

Copy-and-swap

Copy assignment operator

Copy constructor

copy_if()

cos()

count()

Coupling

cout

Covariance

__cplusplus

Crash dump

Crosscast

c_str()

D

Dangling pointer

data()

array<>

sequence containers

string

string_view

Data hiding

Data member

__DATE_

Debugging

dec

Decimal number

Declaration

decltype()

decltype(auto)

Decrementing

Deep copy

default

constructor

destructor

switch case

Default argument values

Default constructor

defaultfloat

#define

defined

Definition

Delegating constructor

delete

deallocation

special member function

delete[]

Dependent type

<deque>

deque<>

Dereference operator

Derived class

Destructor

Diamond problem

Digit grouping

digits

divides<>

Division

do - while

domain_error

Don’t Repeat Yourself (DRY)

double

Double-ended queue

Double precision

Doubly linked list

Downcast

Dynamic array

Dynamic binding

dynamic_cast<>

Dynamic memory

Dynamic resolution

Dynamic type

E

Early binding

#elif

else

#else

empty()

Encapsulation

end()

Endianness

endl

enum

Enumerations

Equality operator

equal_to<>

erase()

during iteration

sequence containers

set<>

string

#error

Escape sequences

Exception

Exception safety

execution::par

Execution policy

exit()

_Exit()

exp()

explicit

Explicit template instantiation

Exponent

extern

External functions

External linkage

External variables

F

Fallthrough

[[fallthrough]]

Field

__FILE_

fill()

final

find()

algorithm

string

find_end()

find_first_of()

find_if()

find_if_not()

find_last_of()

First-class function

First-in-first-out (FIFO)

fixed

float

Floating-point

infinity

literals

loop control variables

NaN

numbers

types

floor()

for

loop

range-based

for_each()

Formatting

Forward declaration

SeeFunction prototype

Forward iterator

<forward_list>

forward_list<>

Fraction

Fragmentation

Free store

friend

class

class templates

function

front()

queue<>

sequence containers

string

vector<>

front_inserter()

function<>

Function argument

Function declarations

Function definitions

Function header

Function object

Function overriding

Function parameter

Function pointers

Function prototype

Functions

Function signature

Function template

Function template specialization

Functor

SeeFunction object

G

get()

unique_ptr<>

getline()

Getter

Global namespace

Global variable

greater<>

greater_equal

H

Has a relation

__has_include

has_value()

Hash map

Hash table

Header

<array>

<cmath>

<deque>

<forward_list>

<ios>

<list>

<map>

<queue>

<set>

<stack>

<string_view>

<type_traits>

<unordered_map>

<unordered_set>

Header file

Heap

hex

Hexadecimal literals

Hexadecimal numbers

Hiding members

Higher-order function

I

IDE

if

else

initialization statement

statement

#if

#ifdef

#ifndef

Implicit conversion

#include

#include guard

Incrementing

Indefinite loop

Indirection operator

Infinite loop

Infinity

infinity()

Information hiding

Inheritance

Inheriting constructors

Initialization statement

for

if

switch

initializer_list<>

inline

functions

variables

Input iterator

Input/output

Input parameter

insert()

sequence containers

set<>

string

inserter()

Instance

class

class template

function template

int

Integer division

Integer literals

Integer variables

Integrated development environment (IDE)

Interface

Internal functions

Internal linkage

Internationalization

SeeLocale

invalid_argument

Invalidated iterator

<ios>

isalnum()

isalpha()

Is a relation

is_arithmetic_v<>

is_assignable_v<>

isblank()

is_class_v<>

iscntrl()

is_copy_constructible_v<>

is_default_constructible_v<>

isdigit()

is_enum<>

is_floating_point_v<>

isgraph()

is_integral_v<>

islower()

is_nothrow_move_assignable_v<>

is_null_pointer_v<>

is_pointer_v<>

isprint()

ispunct()

is_signed_v<>

isspace()

isupper()

is_unsigned_v<>

isxdigit()

Iterator

containers

pattern

J, K

Justification

L

Lambda capture clause

Lambda expressions

Lambda initializer

Last-in first-out (LIFO)

Late binding

left

length()

length_error

less<>

less_equal<>

Lexicographical comparison

Lifetime

#line

__LINE_

Linkage

Linked list

Linker

list<>

Literals

binary

Boolean

character

digit grouping

hexadecimal

integer

octal

raw string

string

Little-endian

Locale

Local variable

log()

log10()

logical_and<>

logical_not<>

Logical operators

AND

combining

negation

OR

short-circuit evaluation

XOR

logical_or<>

logic_error

long

long double

long long

Loop

breaking

do - while

for

indefinite

overview

range-based for

skipping iterations

while

Lowercase

lowest()

Lvalue

M

Macro

function-like

identifier

Magic numbers

Magnitude

main()

make_shared<>()

make_unique<>()

T

T[]

Mangled names

Mantissa

<map>

map<>

Mathematical functions

max()

algorithm

numeric_limits<>

max_element()

Member function

Member initializer list

Member variable

Memory leak

Metaprogramming

Method

Method chaining

min()

algorithm

numeric_limits<>

min_element()

minmax_element()

minus

Mixin

Modern C++

Modulus

modulus

move()

Move-and-swap

Move assignment operator

Move constructor

move_if_no_except()

Move-only types

Move semantics

Multidimensional arrays

Multiple inheritance

Multiplication

multiplies<>

multiset<>

mutable

lambda expression

member function

Mutual recursion

N

Names

namespace

Namespace alias

Namespaces

Narrow characters

Narrowing conversion

NDEBUG

negate<>

Negation

bitwise

logical

Nested class

Nested class template

Nested namespaces

new

new[]

Newline character

noexcept

noexcept()

Nonmember operator function

Nontype template parameter

class template

function template

Not-a-number (NaN)

not_equal_to<>

npos

Null character

nullopt

nullptr

Numbers

binary

endianness

floating-point

hexadecimal

negative

octal

O

Object

Object file

Object slicing

P

pair<>

par

Parallel algorithms

Parameter list

class template

function

function template

lambda expression

Parsing

partition()

Pass-by-reference

Pass-by-rvalue-reference

Pass-by-value

Passing arrays

multidimensional

plus

Pointer

Pointer arithmetic

Pointers to functions

Pointer to constant

Polymorphic class

Polymorphic container

Polymorphism

pop()

pop_back()

sequence containers

vector<>

pop_front()

Postfix increment/decrement

pow()

#pragma

#pragma once

Precedence

Precision

Precondition

Prefix increment/decrement

Preprocessing directive

Preprocessor

priority_queue<>

private

access specifier

base class specifier

Procedural programming

Programming style

protected

access specifier

base class specifier

public

access specifier

base class specifier

Pure virtual functions

push()

push_back()

sequence containers

string

vector<>

push_front()

Q

<queue>

queue<>

Quicksort

quiet_NaN()

R

RAII

rand()

RAND_MAX

Random-access container

Random-access iterator

Random numbers

Range-based for loop

range_error

Raw string literals

Readability

Recursion

Recursive algorithms

Red-black tree

Reference

lvalue

rvalue

release()

unique_ptr<>

rel_ops

Remainder after integer division

remove()

remove_copy()

Remove-erase

remove_if()

Repeated inheritance

replace()

replace_copy()

replace_copy_if()

reserve()

reset()

optional<>

shared_ptr<>

unique_ptr<>

Resource Acquisition Is Initialization

SeeRAII

Rethrowing exceptions

return

Return-by-value

Return type

Return type deduction

Return value optimization

rfind()

right

round()

RTTI

Rule of Five

Rule of Zero

runtime_error

Runtime type

Runtime type information (RTTI)

Rvalue

Rvalue reference

S

scientific

2’s complement representation

Scope

search()

Segmentation fault

Sequence container

<set>

set<>

setfill()

setprecision()

Setter

setw()

Shallow copy

shared_ptr

short

Short-circuit evaluation

showbase

signaling_NaN()

Signature

signed

Signed integers

sin()

Single precision

Singly linked list

size()

arrays

containers

set<>

std::array<>

std::vector<>

string

sizeof

size_t

Slicing

Smart pointer

sort()

Sorting

Source file

Specialization

class

class template

function template

partial

Special member functions

sqrt()

Square root

Stack

call stack

<stack>

stack<>

Standard Library

State

Statement

static

internal linkage

member function

member variable

variable

static_assert()

Static binding

static_cast<>

Static constants

Static member variable

Static resolution

Static type

Static variable

std

stod()

stof()

stoi()

stol()

stold()

stoll()

stoul()

stoull()

str()

Stream

Stream manipulators

String

C-style

std::string

String concatenation

SeeConcatenation

String length

String literal

stringstream

String streams

string_view

<string_view>

struct

Structure

Structured bindings

Subclass

SeeDerived class

Substrings

accessing

erasing

finding

inserting

replacing

Subtraction

Superclass

SeeBase class

swap()

switch

T

tan()

Template

class

function

member function

template

Template argument deduction

class template

function template

Template metaprogramming

Template parameter

nontype

type

Template type argument

Template type parameter

terminate()

Ternary operator

this

thread_local

throw

exception

rethrow

throw()

__TIME_

tolower()

top()

to_string()

toupper()

Trailing return type

Translation unit

Tree

Trigonometric functions

try

Type alias

Type cast

SeeCast

Type deduction

return type

template argument

typedef

typeid()

type_info

typename

dependent type

template parameter

Type traits

<type_traits>

U

#undef

Underflow

underflow_error

Unhandled exceptions

Unicode

Unicode strings

Unified Modeling Language (UML)

Uniform initialization

unique_ptr<>

Universal Character Set (UCS)

Unnamed function

Unnamed namespaces

<unordered_map>

unordered_map<>

unordered_multiset<>

<unordered_set>

unordered_set<>

unsigned

Unsigned integers

Uppercase

using

changing access specifier

declaration

function pointer type alias

inheriting constructors

unhiding members

type alias

using namespace

u16string

u32string

UTF

V

value()

value_or()

Variable

Variable-length arrays

vector<>

virtual

destructor

function

inheritance

Virtual function table

void

vtable

W

wchar_t

wcout

weak_ptr<>

what()

while

Whitespace

Wide characters

Wide strings

wstring

X, Y

XOR

Z

Zero initialization

Table of Contents for
Beginning C++17: From Novice to Professional

Index

0-9/Symbols

A

B

C

D

E

F

G

H

I

J, K

L

M

N

O

P

Q

R

S

T

U

V

W

X, Y

Z

Table of Contents for Beginning C++17: From Novice to Professional

Index

0-9/Symbols

A

B

C

D

E

F

G

H

I

J, K

L

M

N

O

P

Q

R

S

T

U

V

W

X, Y

Z

Table of Contents for
Beginning C++17: From Novice to Professional