René's URL Explorer Experiment


Title: C++ Core Guidelines

Description: The C++ Core Guidelines are a set of tried-and-true guidelines, rules, and best practices about coding in C++

direct link

Domain: isocpp.github.io

Nonetext/html; charset=utf-8

Links:

Tophttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#main
In: Introductionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-introduction
P: Philosophyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-philosophy
I: Interfaceshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-interfaces
F: Functionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-functions
C: Classes and class hierarchieshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-class
Enum: Enumerationshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-enum
R: Resource managementhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-resource
ES: Expressions and statementshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-expr
Per: Performancehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-performance
CP: Concurrencyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-concurrency
E: Error handlinghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-errors
Con: Constants and immutabilityhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-const
T: Templates and generic programminghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-templates
CPL: C-style programminghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-cpl
SF: Source fileshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-source
SL: The Standard libraryhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-stdlib
A: Architectural Ideashttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-a
NR: Non-Rules and mythshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-not
RF: Referenceshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-references
Pro: Profileshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-profile
GSL: Guideline support libraryhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-gsl
NL: Naming and layouthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-naming
FAQ: Frequently asked questionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-faq
Appendix A: Librarieshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-libraries
Appendix B: Modernizing codehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-modernizing
Appendix C: Discussionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-discussion
Appendix D: Tools supporthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-tools
Glossaryhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-glossary
To-do: Unclassified proto-ruleshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-unclassified
https://github.com/isocpp/CppCoreGuidelines
Bjarne Stroustruphttps://www.stroustrup.com
Herb Sutterhttps://herbsutter.com/
LICENSEhttps://github.com/isocpp/CppCoreGuidelines/blob/master/LICENSE
the introductionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-introduction
herehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-ack
To-do: Unclassified proto-ruleshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-unclassified
read an explanation of the scope and structure of this Guidehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-abstract
In: Introductionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-introduction
P: Philosophyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-philosophy
I: Interfaceshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-interfaces
F: Functionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-functions
C: Classes and class hierarchieshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-class
Enum: Enumerationshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-enum
R: Resource managementhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-resource
ES: Expressions and statementshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-expr
Per: Performancehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-performance
CP: Concurrency and parallelismhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-concurrency
E: Error handlinghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-errors
Con: Constants and immutabilityhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-const
T: Templates and generic programminghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-templates
CPL: C-style programminghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-cpl
SF: Source fileshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-source
SL: The Standard Libraryhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#sl-the-standard-library
A: Architectural ideashttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-a
NR: Non-Rules and mythshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-not
RF: Referenceshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-references
Pro: Profileshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-profile
GSL: Guidelines support libraryhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-gsl
NL: Naming and layout suggestionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-naming
FAQ: Answers to frequently asked questionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-faq
Appendix A: Librarieshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-libraries
Appendix B: Modernizing codehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-modernizing
Appendix C: Discussionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-discussion
Appendix D: Supporting toolshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-tools
Glossaryhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-glossary
To-do: Unclassified proto-ruleshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-unclassified
regular typeshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-regular
prefer initializationhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-initialize
copyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-copy-semantic
movehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-move-semantic
other operationshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-matched
defaulthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-eqdefault
datahttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-org
invarianthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-struct
membershttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-member
helpershttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-helper
concrete typeshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-concrete
ctors, =, and dtorshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-ctor
hierarchyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-hier
operatorshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-overload
ruleshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-concepts
in generic programminghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-raise
template argumentshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-concepts
semanticshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-low
invarianthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-struct
establish invarianthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-ctor
throwhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-throw
defaulthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-default0
not neededhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-default
explicithttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-explicit
delegatinghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-delegating
virtualhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-ctor-virtual
when to usehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-domain
as interfacehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-abstract
destructorshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-dtor
copyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-copy
getters and settershttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-get
multiple inheritancehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-mi-interface
overloadinghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-using
slicinghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-copy-virtual
dynamic_casthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-dynamic_cast
and constructorshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-matched
when needed?https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-dtor
must not failhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-dtor-fail
errorshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-errors
throwhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-throw
for errors onlyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-errors
noexcepthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-noexcept
minimize tryhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-catch
what if no exceptions?https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-no-throw-codes
range-for and forhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-for-range
for and whilehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-for-while
for-initializerhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-for-init
empty bodyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-empty
loop variablehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-loop-counter
loop variable type ???https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-???
naminghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-package
single operationhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-logical
no throwhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-noexcept
argumentshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-smart
argument passinghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-conventional
multiple return valueshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-out-multi
pointershttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-return-ptr
lambdashttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-capture-vs-overload
small functionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-inline
in headershttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rs-inline
alwayshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-always
prefer {}https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-list
lambdashttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-lambda-init
default member initializershttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-in-class-initializer
class membershttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-initialize
factory functionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-factory
when to usehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-lambdas
conventionalhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ro-conventional
avoid conversion operatorshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ro-conversion
and lambdashttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ro-lambda
information hidinghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-private
consistencyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-public
protectedhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-protected
compile-time checkinghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rp-compile-time
and conceptshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-check-class
for organizing datahttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-org
use if no invarianthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-struct
no private membershttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-class
abstractionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-raise
containershttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-cont
conceptshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-concepts
and signedhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-mix
bit manipulationhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-unsigned
interfaceshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ri-abstract
not virtualhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-concrete
destructorhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-dtor-virtual
never failhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-dtor-fail
In.target: Target readershiphttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-readers
In.aims: Aimshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-aims
In.not: Non-aimshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-non
In.force: Enforcementhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-force
In.struct: The structure of this documenthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-struct
In.sec: Major sectionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-sec
programmers who might consider Chttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-cpl
Stroustrup05https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Stroustrup05
library componentshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#gsl-guidelines-support-library
gradual adoptionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-modernizing
the referenceshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-references
the modernization sectionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-modernizing
C.134https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-public
type.4https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#pro-type-cstylecast
bounds.2https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#pro-bounds-arrayindex
Discussionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-discussion
Issuehttps://github.com/isocpp/CppCoreGuidelines/issues
the referenceshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-references
In: Introductionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-introduction
P: Philosophyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-philosophy
I: Interfaceshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-interfaces
F: Functionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-functions
C: Classes and class hierarchieshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-class
Enum: Enumerationshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-enum
R: Resource managementhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-resource
ES: Expressions and statementshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-expr
Per: Performancehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-performance
CP: Concurrency and parallelismhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-concurrency
E: Error handlinghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-errors
Con: Constants and immutabilityhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-const
T: Templates and generic programminghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-templates
CPL: C-style programminghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-cpl
SF: Source fileshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-source
SL: The Standard Libraryhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#sl-the-standard-library
A: Architectural ideashttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-a
NR: Non-Rules and mythshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-not
RF: Referenceshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-references
Pro: Profileshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-profile
GSL: Guidelines support libraryhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#gsl-guidelines-support-library
NL: Naming and layout suggestionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-naming
FAQ: Answers to frequently asked questionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-faq
Appendix A: Librarieshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-libraries
Appendix B: Modernizing codehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-modernizing
Appendix C: Discussionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-discussion
Appendix D: Supporting toolshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-tools
Glossaryhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-glossary
To-do: Unclassified proto-ruleshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-unclassified
P.1: Express ideas directly in codehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rp-direct
P.2: Write in ISO Standard C++https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rp-cplusplus
P.3: Express intenthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rp-what
P.4: Ideally, a program should be statically type safehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rp-typesafe
P.5: Prefer compile-time checking to run-time checkinghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rp-compile-time
P.6: What cannot be checked at compile time should be checkable at run timehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rp-run-time
P.7: Catch run-time errors earlyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rp-early
P.8: Don’t leak any resourceshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rp-leak
P.9: Don’t waste time or spacehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rp-waste
P.10: Prefer immutable data to mutable datahttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rp-mutable
P.11: Encapsulate messy constructs, rather than spreading through the codehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rp-library
P.12: Use supporting tools as appropriatehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rp-tools
P.13: Use support libraries as appropriatehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rp-lib
guidelines support libraryhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#gsl-guidelines-support-library
undefined order of evaluationhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-order
ES.71https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-for-range
The guidelines support libraryhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#gsl-guidelines-support-library
The ISO C++ Standard Libraryhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#sl-the-standard-library
RAIIhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-raii
The resource management sectionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-resource
the lifetime safety profilehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-lifetime
RAIIhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-raii
the type and bounds profileshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-force
the GSLhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#gsl-guidelines-support-library
Con: Constants and immutabilityhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-const
subset of superset principlehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#r0
Static analysis toolshttps://en.wikipedia.org/wiki/List_of_tools_for_static_code_analysis
Concurrency toolshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-tools
Testing toolshttps://github.com/isocpp/CppCoreGuidelines/tree/master
ISO C++ Standard Libraryhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#sl-the-standard-library
Guidelines Support Libraryhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#gsl-guidelines-support-library
I.1: Make interfaces explicithttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ri-explicit
I.2: Avoid non-const global variableshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ri-global
I.3: Avoid singletonshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ri-singleton
I.4: Make interfaces precisely and strongly typedhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ri-typed
I.5: State preconditions (if any)https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ri-pre
I.6: Prefer Expects() for expressing preconditionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ri-expects
I.7: State postconditionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ri-post
I.8: Prefer Ensures() for expressing postconditionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ri-ensures
I.9: If an interface is a template, document its parameters using conceptshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ri-concepts
I.10: Use exceptions to signal a failure to perform a required taskhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ri-except
I.11: Never transfer ownership by a raw pointer (T*) or reference (T&)https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ri-raw
I.12: Declare a pointer that must not be null as not_nullhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ri-nullptr
I.13: Do not pass an array as a single pointerhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ri-array
I.22: Avoid complex initialization of global objectshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ri-global-init
I.23: Keep the number of function arguments lowhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ri-nargs
I.24: Avoid adjacent parameters that can be invoked by the same arguments in either order with different meaninghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ri-unrelated
I.25: Prefer empty abstract classes as interfaces to class hierarchieshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ri-abstract
I.26: If you want a cross-compiler ABI, use a C-style subsethttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ri-abi
I.27: For stable library ABI, consider the Pimpl idiomhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ri-pimpl
I.30: Encapsulate rule violationshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ri-encapsulate
F: Functionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-functions
C.concrete: Concrete typeshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-concrete
C.hier: Class hierarchieshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-hier
C.over: Overloading and overloaded operatorshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-overload
C.con: Containers and other resource handleshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-containers
E: Error handlinghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-errors
T: Templates and generic programminghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-templates
rules for calling functionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-call
GSLhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#gsl-guidelines-support-library
contract proposalhttps://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0380r1.pdf
ensuring that a value is non-negativehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-nonnegative
RAIIhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-raii
RAIIhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-raii
contract proposalhttps://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0380r1.pdf
Generic programminghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-gp
conceptshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-concepts
criticalhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rper-critical
measurehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rper-measure
I.5https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ri-pre
I.7https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ri-post
Pass ownershiphttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-smartptrparam
guidelines support libraryhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#gsl-guidelines-support-library
Argument passinghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-conventional
use of smart pointer argumentshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-smartptrparam
value returnhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-value-return
guidelines support libraryhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#gsl-guidelines-support-library
GSLhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#gsl-guidelines-support-library
GOTW #100https://herbsutter.com/gotw/_100/
cppreferencehttps://en.cppreference.com/w/cpp/language/pimpl
against uninitialized variableshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-always
ignoring ownershiphttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ri-raw
against magic constantshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-magic
[Str15]https://www.stroustrup.com/resource-model.pdf
F.1: “Package” meaningful operations as carefully named functionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-package
F.2: A function should perform a single logical operationhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-logical
F.3: Keep functions short and simplehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-single
F.4: If a function might have to be evaluated at compile time, declare it constexprhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-constexpr
F.5: If a function is very small and time-critical, declare it inlinehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-inline
F.6: If your function must not throw, declare it noexcepthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-noexcept
F.7: For general use, take T* or T& arguments rather than smart pointershttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-smart
F.8: Prefer pure functionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-pure
F.9: Unused parameters should be unnamedhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-unused
F.10: If an operation can be reused, give it a namehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-name
F.11: Use an unnamed lambda if you need a simple function object in one place onlyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-lambda
F.15: Prefer simple and conventional ways of passing informationhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-conventional
F.16: For “in” parameters, pass cheaply-copied types by value and others by reference to consthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-in
F.17: For “in-out” parameters, pass by reference to non-consthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-inout
F.18: For “will-move-from” parameters, pass by X&& and std::move the parameterhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-consume
F.19: For “forward” parameters, pass by TP&& and only std::forward the parameterhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-forward
F.20: For “out” output values, prefer return values to output parametershttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-out
F.21: To return multiple “out” values, prefer returning a structhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-out-multi
F.60: Prefer T* over T& when “no argument” is a valid optionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-ptr-ref
F.22: Use T* or owner to designate a single objecthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-ptr
F.23: Use a not_null to indicate that “null” is not a valid valuehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-nullptr
F.24: Use a span or a span_p to designate a half-open sequencehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-range
F.25: Use a zstring or a not_null to designate a C-style stringhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-zstring
F.26: Use a unique_ptr to transfer ownership where a pointer is neededhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-unique_ptr
F.27: Use a shared_ptr to share ownershiphttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-shared_ptr
F.42: Return a T* to indicate a position (only)https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-return-ptr
F.43: Never (directly or indirectly) return a pointer or a reference to a local objecthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-dangle
F.44: Return a T& when copy is undesirable and “returning no object” isn’t neededhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-return-ref
F.45: Don’t return a T&&https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-return-ref-ref
F.46: int is the return type for main()https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-main
F.47: Return T& from assignment operatorshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-assignment-op
F.48: Don’t return std::move(local)https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-return-move-local
F.49: Don’t return const Thttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-return-const
F.50: Use a lambda when a function won’t do (to capture local variables, or to write a local function)https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-capture-vs-overload
F.51: Where there is a choice, prefer default arguments over overloadinghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-default-args
F.52: Prefer capturing by reference in lambdas that will be used locally, including passed to algorithmshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-reference-capture
F.53: Avoid capturing by reference in lambdas that will be used non-locally, including returned, stored on the heap, or passed to another threadhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-value-capture
F.54: When writing a lambda that captures this or any class data member, don’t use [=] default capturehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-this-capture
F.55: Don’t use va_arg argumentshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#f-varargs
F.56: Avoid unnecessary condition nestinghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#f-nesting
C.lambdas: Function objects and lambdashttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-lambdas
Keep functions short and simplehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-single
Keep functions short and simplehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-single
C.44https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-default00
lifetime safety profilehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-lifetime
Prefer T* over T& when “no argument” is a valid optionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-ptr-ref
Smart pointer rule summaryhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-summary-smartptrs
initializershttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#???
Stringhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-string
R.34https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-sharedptrparam-owner
R.35https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-sharedptrparam
R.36https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-sharedptrparam-const
F.18https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-consume
F.18https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-consume
F.19https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-forward
F.18https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-consume
F.19https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-forward
R.34https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-sharedptrparam-owner
R.36https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-sharedptrparam-const
cheap to copyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-in
That could be dangeroushttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-move-semantic
R.34https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-sharedptrparam-owner
use a tuplehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-out-multi
treat it as an in/out parameter and pass by referencehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-out-multi
T&https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-inout
ES.56https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-move
Support libraryhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#gsl-guidelines-support-library
Do not pass an array as a single pointerhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ri-array
Support libraryhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#gsl-guidelines-support-library
Support libraryhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#gsl-guidelines-support-library
C.50https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-factory
if there is no need to use nullptrhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-ptr-ref
if the object referred to should not changehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-const
F.43https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-dangle
discussion of dangling pointer preventionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#???
pointer invalidationhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#???
discussion of dangling pointer preventionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#???
discussion of ownershiphttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#???
lifetime safety profilehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-lifetime
F.18https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-consume
F.19https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-forward
F.20, the general item about “out” output valueshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-out
Default arguments for virtual functionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-virtual-default-arg
C.1: Organize related data into structures (structs or classes)https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-org
C.2: Use class if the class has an invariant; use struct if the data members can vary independentlyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-struct
C.3: Represent the distinction between an interface and an implementation using a classhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-interface
C.4: Make a function a member only if it needs direct access to the representation of a classhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-member
C.5: Place helper functions in the same namespace as the class they supporthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-helper
C.7: Don’t define a class or enum and declare a variable of its type in the same statementhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-standalone
C.8: Use class rather than struct if any member is non-publichttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-class
C.9: Minimize exposure of membershttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-private
C.concrete: Concrete typeshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-concrete
C.ctor: Constructors, assignments, and destructorshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-ctor
C.con: Containers and other resource handleshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-containers
C.lambdas: Function objects and lambdashttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-lambdas
C.hier: Class hierarchies (OOP)https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-hier
C.over: Overloading and overloaded operatorshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-overload
C.union: Unionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-union
define a class with private data as classhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-class
Prefer to place the interface first in a classhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rl-order
minimize exposure of membershttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-private
Avoid protected datahttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-protected
“uniform function call”https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0251r0.pdf
multi-methodshttps://web.archive.org/web/20200605021759/https://parasol.tamu.edu/~yuriys/papers/OMM10.pdf
overloaded operatorshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ro-namespace
see NL.16https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rl-order
protected data is a bad ideahttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-protected
NL.16https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rl-order
Flag protected datahttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-protected
C.10: Prefer concrete types over class hierarchieshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-concrete
C.11: Make concrete types regularhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-regular
C.12: Don’t make data members const or references in a copyable or movable typehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-constref
C.13: If data member B uses another data member A, declare A before Bhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-lifetime
C.20: If you can avoid defining any default operations, dohttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-zero
C.21: If you define or =delete any copy, move, or destructor function, define or =delete them allhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-five
C.22: Make default operations consistenthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-matched
C.30: Define a destructor if a class needs an explicit action at object destructionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-dtor
C.31: All resources acquired by a class must be released by the class’s destructorhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-dtor-release
C.32: If a class has a raw pointer (T*) or reference (T&), consider whether it might be owninghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-dtor-ptr
C.33: If a class has an owning pointer member, define a destructorhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-dtor-ptr2
C.35: A base class destructor should be either public and virtual, or protected and non-virtualhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-dtor-virtual
C.36: A destructor must not failhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-dtor-fail
C.37: Make destructors noexcepthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-dtor-noexcept
C.40: Define a constructor if a class has an invarianthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-ctor
C.41: A constructor should create a fully initialized objecthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-complete
C.42: If a constructor cannot construct a valid object, throw an exceptionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-throw
C.43: Ensure that a copyable class has a default constructorhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-default0
C.44: Prefer default constructors to be simple and non-throwinghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-default00
C.45: Don’t define a default constructor that only initializes data members; use member initializers insteadhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-default
C.46: By default, declare single-argument constructors explicithttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-explicit
C.47: Define and initialize data members in the order of member declarationhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-order
C.48: Prefer default member initializers to member initializers in constructors for constant initializershttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-in-class-initializer
C.49: Prefer initialization to assignment in constructorshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-initialize
C.50: Use a factory function if you need “virtual behavior” during initializationhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-factory
C.51: Use delegating constructors to represent common actions for all constructors of a classhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-delegating
C.52: Use inheriting constructors to import constructors into a derived class that does not need further explicit initializationhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-inheriting
C.60: Make copy assignment non-virtual, take the parameter by const&, and return by non-const&https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-copy-assignment
C.61: A copy operation should copyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-copy-semantic
C.62: Make copy assignment safe for self-assignmenthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-copy-self
C.63: Make move assignment non-virtual, take the parameter by &&, and return by non-const&https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-move-assignment
C.64: A move operation should move and leave its source in a valid statehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-move-semantic
C.65: Make move assignment safe for self-assignmenthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-move-self
C.66: Make move operations noexcepthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-move-noexcept
C.67: A polymorphic class should suppress public copy/movehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-copy-virtual
C.80: Use =default if you have to be explicit about using the default semanticshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-eqdefault
C.81: Use =delete when you want to disable default behavior (without wanting an alternative)https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-delete
C.82: Don’t call virtual functions in constructors and destructorshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-ctor-virtual
C.83: For value-like types, consider providing a noexcept swap functionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-swap
C.84: A swap must not failhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-swap-fail
C.85: Make swap noexcepthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-swap-noexcept
C.86: Make == symmetric with respect of operand types and noexcepthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-eq
C.87: Beware of == on base classeshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-eq-base
C.89: Make a hash noexcepthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-hash
C.90: Rely on constructors and assignment operators, not memset and memcpyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-memset
C.67https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-copy-virtual
rule of zerohttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-zero
the rule of zerohttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-zero
the rule of fivehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-five
should never failhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-dtor-fail
discussionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#sd-never-fail
R.20https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-owner
R.3https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-ptr
R.4https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-ref
A T* should not do sohttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-ptr
all default operationshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-five
this in the Discussion sectionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#sd-dtor
discussionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#sd-never-fail
A destructor must not failhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-dtor-fail
default member initializerhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-in-class-initializer
construct valid objecthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-complete
constructor throwshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-throw
use a factory functionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-factory
released by the destructorhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-dtor-release
RAIIhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-raii
RAIIhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-raii
factory functionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-factory
Delegating constructorshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-delegating
default member initializationhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-in-class-initializer
not to declare a variable until it can be properly initializedhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-init
moved-from statehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#???
Discussion of implicit conversionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ro-conversion
Discussionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#sd-order
a more general way to present arguments to a functionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rstr-view
Discussionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#sd-factory
a default member initializerhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-in-class-initializer
F.18https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-consume
strong guaranteehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Abrahams01
the basic guaranteehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Abrahams01
self-assignmenthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-copy-self
copy constructor vs. clone()https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-copy-virtual
using swaphttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-swap
The rule for copy-assignmenthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-copy-assignment
copy-assignmenthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-copy-assignment
self-assignmenthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-copy-self
C.130https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-copy
factory functionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-factory
destructors, deallocation, and swap must never failhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-never-fail
A swap must not failhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-swap-fail
C.41https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-complete
C.100: Follow the STL when defining a containerhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rcon-stl
C.101: Give a container value semanticshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rcon-val
C.102: Give a container move operationshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rcon-move
C.103: Give a container an initializer list constructorhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rcon-init
C.104: Give a container a default constructor that sets it to emptyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rcon-empty
C.109: If a resource handle has pointer semantics, provide * and ->https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rcon-ptr
Resourceshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-resource
passed by valuehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-in
F.10: If an operation can be reused, give it a namehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-name
F.11: Use an unnamed lambda if you need a simple function object in one place onlyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-lambda
F.50: Use a lambda when a function won’t do (to capture local variables, or to write a local function)https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-capture-vs-overload
F.52: Prefer capturing by reference in lambdas that will be used locally, including passed to algorithmshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-reference-capture
F.53: Avoid capturing by reference in lambdas that will be used non-locally, including returned, stored on the heap, or passed to another threadhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-value-capture
ES.28: Use lambdas for complex initialization, especially of const variableshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-lambda-init
C.120: Use class hierarchies to represent concepts with inherent hierarchical structure (only)https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-domain
C.121: If a base class is used as an interface, make it a pure abstract classhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-abstract
C.122: Use abstract classes as interfaces when complete separation of interface and implementation is neededhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-separation
C.126: An abstract class typically doesn’t need a user-written constructorhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-abstract-ctor
C.127: A class with a virtual function should have a virtual or protected destructorhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-dtor
C.128: Virtual functions should specify exactly one of virtual, override, or finalhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-override
C.129: When designing a class hierarchy, distinguish between implementation inheritance and interface inheritancehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-kind
C.130: For making deep copies of polymorphic classes prefer a virtual clone function instead of public copy construction/assignmenthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-copy
C.131: Avoid trivial getters and settershttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-get
C.132: Don’t make a function virtual without reasonhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-virtual
C.133: Avoid protected datahttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-protected
C.134: Ensure all non-const data members have the same access levelhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-public
C.135: Use multiple inheritance to represent multiple distinct interfaceshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-mi-interface
C.136: Use multiple inheritance to represent the union of implementation attributeshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-mi-implementation
C.137: Use virtual bases to avoid overly general base classeshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-vbase
C.138: Create an overload set for a derived class and its bases with usinghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-using
C.139: Use final on classes sparinglyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-final
C.140: Do not provide different default arguments for a virtual function and an overriderhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-virtual-default-arg
C.145: Access polymorphic objects through pointers and referenceshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-poly
C.146: Use dynamic_cast where class hierarchy navigation is unavoidablehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-dynamic_cast
C.147: Use dynamic_cast to a reference type when failure to find the required class is considered an errorhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-ref-cast
C.148: Use dynamic_cast to a pointer type when failure to find the required class is considered a valid alternativehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-ptr-cast
C.149: Use unique_ptr or shared_ptr to avoid forgetting to delete objects created using newhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-smart
C.150: Use make_unique() to construct objects owned by unique_ptrshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-make_unique
C.151: Use make_shared() to construct objects owned by shared_ptrshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-make_shared
C.152: Never assign a pointer to an array of derived class objects to a pointer to its basehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-array
C.153: Prefer virtual function to castinghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-use-virtual
C.35https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-dtor-virtual
I.25https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ri-abstract
Pimplhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ri-pimpl
C.67https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-copy-virtual
R.20https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-owner
Guidelines Support Libraryhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-views
C.49: Prefer initialization to assignment in constructorshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-initialize
Prefer private datahttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-private
keep data out of any class used as an interfacehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-abstract
By convention, declare such classes struct rather than classhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-struct
interface hierarchyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-abstract
implementation hierarchyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-kind
a slightly more realistic examplehttps://www.quora.com/What-are-the-uses-and-advantages-of-virtual-base-class-in-C%2B%2B/answer/Lance-Diduck
A polymorphic class should suppress copyinghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-copy-virtual
Prefer virtual functions to castinghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-use-virtual
static polymorphismhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#???
fast constant timehttps://www.stroustrup.com/fast_dynamic_casting.pdf
type-safety profilehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#pro-type-downcast
C.147https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-ref-cast
R.23https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-make_unique
R.22https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-make_shared
C.146https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-dynamic_cast
C.160: Define operators primarily to mimic conventional usagehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ro-conventional
C.161: Use non-member functions for symmetric operatorshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ro-symmetric
C.162: Overload operations that are roughly equivalenthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ro-equivalent
C.163: Overload only for operations that are roughly equivalenthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ro-equivalent-2
C.164: Avoid implicit conversion operatorshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ro-conversion
C.165: Use using for customization pointshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ro-custom
C.166: Overload unary & only as part of a system of smart pointers and referenceshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ro-address-of
C.167: Use an operator for an operation with its conventional meaninghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ro-overload
C.168: Define overloaded operators in the namespace of their operandshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ro-namespace
C.170: If you feel like overloading a lambda, use a generic lambdahttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ro-lambda
Copies compare equalhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-copy
the same namespace as their operandshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ro-namespace
Binary operators should treat their operands equivalentlyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ro-symmetric
Operator Dot (R2)https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4477.pdf
helper functions should be defined in the same namespace as their classhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-helper
C.180: Use unions to save Memoryhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ru-union
C.181: Avoid “naked” unionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ru-naked
C.182: Use anonymous unions to implement tagged unionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ru-anonymous
C.183: Don’t use a union for type punninghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ru-pun
Avoid “naked” unionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ru-naked
Enum.1: Prefer enumerations over macroshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#renum-macro
Enum.2: Use enumerations to represent sets of related named constantshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#renum-set
Enum.3: Prefer enum classes over “plain” enumshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#renum-class
Enum.4: Define operations on enumerations for safe and simple usehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#renum-oper
Enum.5: Don’t use ALL_CAPS for enumeratorshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#renum-caps
Enum.6: Avoid unnamed enumerationshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#renum-unnamed
Enum.7: Specify the underlying type of an enumeration only when necessaryhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#renum-underlying
Enum.8: Specify enumerator values only when necessaryhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#renum-value
R.1: Manage resources automatically using resource handles and RAII (Resource Acquisition Is Initialization)https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-raii
R.2: In interfaces, use raw pointers to denote individual objects (only)https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-use-ptr
R.3: A raw pointer (a T*) is non-owninghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-ptr
R.4: A raw reference (a T&) is non-owninghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-ref
R.5: Prefer scoped objects, don’t heap-allocate unnecessarilyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-scoped
R.6: Avoid non-const global variableshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-global
R.10: Avoid malloc() and free()https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-mallocfree
R.11: Avoid calling new and delete explicitlyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-newdelete
R.12: Immediately give the result of an explicit resource allocation to a manager objecthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-immediate-alloc
R.13: Perform at most one explicit resource allocation in a single expression statementhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-single-alloc
R.14: Avoid [] parameters, prefer spanhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-ap
R.15: Always overload matched allocation/deallocation pairshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-pair
R.20: Use unique_ptr or shared_ptr to represent ownershiphttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-owner
R.21: Prefer unique_ptr over shared_ptr unless you need to share ownershiphttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-unique
R.22: Use make_shared() to make shared_ptrshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-make_shared
R.23: Use make_unique() to make unique_ptrshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-make_unique
R.24: Use std::weak_ptr to break cycles of shared_ptrshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-weak_ptr
R.30: Take smart pointers as parameters only to explicitly express lifetime semanticshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-smartptrparam
R.31: If you have non-std smart pointers, follow the basic pattern from stdhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-smart
R.32: Take a unique_ptr parameter to express that a function assumes ownership of a widgethttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-uniqueptrparam
R.33: Take a unique_ptr& parameter to express that a function reseats the widgethttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-reseat
R.34: Take a shared_ptr parameter to express shared ownershiphttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-sharedptrparam-owner
R.35: Take a shared_ptr& parameter to express that a function might reseat the shared pointerhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-sharedptrparam
R.36: Take a const shared_ptr& parameter to express that it might retain a reference count to the object ???https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-sharedptrparam-const
R.37: Do not pass a pointer or reference obtained from an aliased smart pointerhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-smartptrget
finallyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-finally
RAIIhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-raii
leakhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rp-leak
“out” return valueshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-out
The raw pointer rulehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-ptr
the raw pointer rulehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-ptr
I.2https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ri-global
F.7https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-smart
sharedptrparam guidelinehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-smartptrparam
NL: Naming and layouthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-naming
ES.1: Prefer the standard library to other libraries and to “handcrafted code”https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-lib
ES.2: Prefer suitable abstractions to direct use of language featureshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-abstr
ES.3: Don’t repeat yourself, avoid redundant codehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-dry
ES.5: Keep scopes smallhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-scope
ES.6: Declare names in for-statement initializers and conditions to limit scopehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-cond
ES.7: Keep common and local names short, and keep uncommon and non-local names longerhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-name-length
ES.8: Avoid similar-looking nameshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-name-similar
ES.9: Avoid ALL_CAPS nameshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-not-caps
ES.10: Declare one name (only) per declarationhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-name-one
ES.11: Use auto to avoid redundant repetition of type nameshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-auto
ES.12: Do not reuse names in nested scopeshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-reuse
ES.20: Always initialize an objecthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-always
ES.21: Don’t introduce a variable (or constant) before you need to use ithttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-introduce
ES.22: Don’t declare a variable until you have a value to initialize it withhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-init
ES.23: Prefer the {}-initializer syntaxhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-list
ES.24: Use a unique_ptr to hold pointershttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-unique
ES.25: Declare an object const or constexpr unless you want to modify its value later onhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-const
ES.26: Don’t use a variable for two unrelated purposeshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-recycle
ES.27: Use std::array or stack_array for arrays on the stackhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-stack
ES.28: Use lambdas for complex initialization, especially of const variableshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-lambda-init
ES.30: Don’t use macros for program text manipulationhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-macros
ES.31: Don’t use macros for constants or “functions”https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-macros2
ES.32: Use ALL_CAPS for all macro nameshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-all_caps
ES.33: If you must use macros, give them unique nameshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-macros3
ES.34: Don’t define a (C-style) variadic functionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-ellipses
ES.40: Avoid complicated expressionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-complicated
ES.41: If in doubt about operator precedence, parenthesizehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-parens
ES.42: Keep use of pointers simple and straightforwardhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-ptr
ES.43: Avoid expressions with undefined order of evaluationhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-order
ES.44: Don’t depend on order of evaluation of function argumentshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-order-fct
ES.45: Avoid “magic constants”; use symbolic constantshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-magic
ES.46: Avoid narrowing conversionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-narrowing
ES.47: Use nullptr rather than 0 or NULLhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-nullptr
ES.48: Avoid castshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-casts
ES.49: If you must use a cast, use a named casthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-casts-named
ES.50: Don’t cast away consthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-casts-const
ES.55: Avoid the need for range checkinghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-range-checking
ES.56: Write std::move() only when you need to explicitly move an object to another scopehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-move
ES.60: Avoid new and delete outside resource management functionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-new
ES.61: Delete arrays using delete[] and non-arrays using deletehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-del
ES.62: Don’t compare pointers into different arrayshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-arr2
ES.63: Don’t slicehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-slice
ES.64: Use the T{e}notation for constructionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-construct
ES.65: Don’t dereference an invalid pointerhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-deref
ES.70: Prefer a switch-statement to an if-statement when there is a choicehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-switch-if
ES.71: Prefer a range-for-statement to a for-statement when there is a choicehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-for-range
ES.72: Prefer a for-statement to a while-statement when there is an obvious loop variablehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-for-while
ES.73: Prefer a while-statement to a for-statement when there is no obvious loop variablehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-while-for
ES.74: Prefer to declare a loop variable in the initializer part of a for-statementhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-for-init
ES.75: Avoid do-statementshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-do
ES.76: Avoid gotohttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-goto
ES.77: Minimize the use of break and continue in loopshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-continue
ES.78: Don’t rely on implicit fallthrough in switch statementshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-break
ES.79: Use default to handle common cases (only)https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-default
ES.84: Don’t try to declare a local variable with no namehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-noname
ES.85: Make empty statements visiblehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-empty
ES.86: Avoid modifying loop control variables inside the body of raw for-loopshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-loop-counter
ES.87: Don’t add redundant == or != to conditionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-if
ES.100: Don’t mix signed and unsigned arithmetichttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-mix
ES.101: Use unsigned types for bit manipulationhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-unsigned
ES.102: Use signed types for arithmetichttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-signed
ES.103: Don’t overflowhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-overflow
ES.104: Don’t underflowhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-underflow
ES.105: Don’t divide by integer zerohttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-zero
ES.106: Don’t try to avoid negative values by using unsignedhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-nonnegative
ES.107: Don’t use unsigned for subscripts, prefer gsl::indexhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-subscripts
SL.1https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rsl-lib
ES.11https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-auto
Don’t use a variable for two unrelated purposeshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-recycle
ES.28https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-lambda-init
ES.28https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-lambda-init
ES.28https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-lambda-init
Discussionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#???
ES.30https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-macros
ES.31https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-macros2
ES.32https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-all_caps
see ES.43https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-order
only refer to single objectshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ri-array
bounds-safety profilehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-bounds
contextual conversions to boolhttps://en.cppreference.com/w/cpp/language/implicit_conversion#Contextual_conversions
type profilehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#pro-type-reinterpretcast
ES.64https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-construct
identity castshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#pro-type-identitycast
implicithttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#pro-type-implicitpointercast
ES.64https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-construct
type profilehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#pro-type-reinterpretcast
type profilehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#pro-type-arithmeticcast
type-safety profilehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#pro-type-constcast
C.64https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-move-semantic
C.64https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-move-semantic
Meyers15https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Meyers15
R: Resource managementhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-resource
no naked new rulehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-new
define the base class Shape not to allow thishttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-copy-virtual
Avoid castshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-casts
prefer named castshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-casts-named
initializer notationhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-list
C++’s model for type- and resource-safetyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Stroustrup15
RAIIhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-raii
unique_ptrhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-unique_ptr
shared_ptrhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-shared_ptr
referenceshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-ptr-ref
not_nullhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-nullptr
bounds profilehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-bounds
lifetime safety profilehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-lifetime
ES.6https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-cond
modifying the loop variablehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-loop-counter
gotohttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-goto
see ES.107https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-subscripts
see ES.107https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-subscripts
Per.1: Don’t optimize without reasonhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rper-reason
Per.2: Don’t optimize prematurelyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rper-knuth
Per.3: Don’t optimize something that’s not performance criticalhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rper-critical
Per.4: Don’t assume that complicated code is necessarily faster than simple codehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rper-simple
Per.5: Don’t assume that low-level code is necessarily faster than high-level codehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rper-low
Per.6: Don’t make claims about performance without measurementshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rper-measure
Per.7: Design to enable optimizationhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rper-efficiency
Per.10: Rely on the static type systemhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rper-type
Per.11: Move computation from run time to compile timehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rper-comp
Per.12: Eliminate redundant aliaseshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rper-alias
Per.13: Eliminate redundant indirectionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rper-indirect
Per.14: Minimize the number of allocations and deallocationshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rper-alloc
Per.15: Do not allocate on a critical branchhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rper-alloc0
Per.16: Use compact data structureshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rper-compact
Per.17: Declare the most used member of a time-critical struct firsthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rper-struct
Per.18: Space is timehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rper-space
Per.19: Access memory predictablyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rper-access
Per.30: Avoid context switches on the critical pathhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rper-context
Per.1https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rper-reason
Per.2https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rper-knuth
the root of all evilhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rper-knuth
interfaceshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-interfaces
use compact datahttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rper-compact
access it in a systematic fashionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rper-access
conventional wayshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-conventional
standard libraryhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#sl-the-standard-library
low-level codehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rper-low
Don’t optimize prematurelyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rper-knuth
CP.1: Assume that your code will run as part of a multi-threaded programhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-multi
CP.2: Avoid data raceshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-races
CP.3: Minimize explicit sharing of writable datahttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-data
CP.4: Think in terms of tasks, rather than threadshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-task
CP.8: Don’t try to use volatile for synchronizationhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-volatile
CP.9: Whenever feasible use tools to validate your concurrent codehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-tools
CP.con: Concurrencyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#sscp-con
CP.coro: Coroutineshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#sscp-coro
CP.par: Parallelismhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#sscp-par
CP.mess: Message passinghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#sscp-mess
CP.vec: Vectorizationhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#sscp-vec
CP.free: Lock-free programminghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#sscp-free
CP.etc: Etc. concurrency ruleshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#sscp-etc
Carefully study the literaturehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-literature
CP.mess: Message Passinghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#sscp-mess
CP.31: prefer pass by valuehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-data-by-value
(rare) proper uses of volatilehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-volatile2
clanghttps://clang.llvm.org/docs/ThreadSafetyAnalysis.html
GCChttps://gcc.gnu.org/wiki/ThreadSafetyAnnotation
Thread Sanitizerhttps://clang.llvm.org/docs/ThreadSanitizer.html
parallelismhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#sscp-par
messaginghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#sscp-mess
vectorizationhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#sscp-vec
lock freehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#sscp-free
CP.20: Use RAII, never plain lock()/unlock()https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-raii
CP.21: Use std::lock() or std::scoped_lock to acquire multiple mutexeshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-lock
CP.22: Never call unknown code while holding a lock (e.g., a callback)https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-unknown
CP.23: Think of a joining thread as a scoped containerhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-join
CP.24: Think of a thread as a global containerhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-detach
CP.25: Prefer gsl::joining_thread over std::threadhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-joining_thread
CP.26: Don’t detach() a threadhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-detached_thread
CP.31: Pass small amounts of data between threads by value, rather than by reference or pointerhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-data-by-value
CP.32: To share ownership between unrelated threads use shared_ptrhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-shared
CP.40: Minimize context switchinghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-switch
CP.41: Minimize thread creation and destructionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-create
CP.42: Don’t wait without a conditionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-wait
CP.43: Minimize time spent in a critical sectionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-time
CP.44: Remember to name your lock_guards and unique_lockshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-name
CP.50: Define a mutex together with the data it guards. Use synchronized_value where possiblehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-mutex
don’t detach()https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-detached_thread
use gsl::joining_threadhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-joining_thread
Don’t detachhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-detached_thread
“exporting ownership”https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-detached_thread
use RAIIhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-raii
WG21 proposalhttps://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p0290r4.html
CP.51: Do not use capturing lambdas that are coroutineshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rcoro-capture
CP.52: Do not hold locks or other synchronization primitives across suspension pointshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rcoro-locks
CP.53: Parameters to coroutines should not be passed by referencehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rcoro-reference-parameters
F.20: For “out” output values, prefer return values to output parametershttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-out
CP.60: Use a future to return a value from a concurrent taskhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-future
CP.61: Use async() to spawn concurrent taskshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-async
R.12https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-immediate-alloc
CP.100: Don’t use lock-free programming unless you absolutely have tohttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-lockfree
CP.101: Distrust your hardware/compiler combinationhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-distrust
CP.102: Carefully study the literaturehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-literature
CP.110: Do not write your own double-checked locking for initializationhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-double
CP.111: Use a conventional pattern if you really need double-checked lockinghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-double-pattern
Atomic variableshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#???
CP.110: Do not write your own double-checked locking for initializationhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-double
CP.100: Don’t use lock-free programming unless you absolutely have tohttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-lockfree
CP.110: Do not write your own double-checked locking for initializationhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-double
CP.200: Use volatile only to talk to non-C++ memoryhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-volatile2
CP.200: Use volatile only to talk to non-C++ memoryhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-volatile2
CP.201: ??? Signalshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-signal
nothing to do with synchronizationhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconc-volatile
E.1: Develop an error-handling strategy early in a designhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-design
E.2: Throw an exception to signal that a function can’t perform its assigned taskhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-throw
E.3: Use exceptions for error handling onlyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-errors
E.4: Design your error-handling strategy around invariantshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-design-invariants
E.5: Let a constructor establish an invariant, and throw if it cannothttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-invariant
E.6: Use RAII to prevent leakshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-raii
E.7: State your preconditionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-precondition
E.8: State your postconditionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-postcondition
E.12: Use noexcept when exiting a function because of a throw is impossible or unacceptablehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-noexcept
E.13: Never throw while being the direct owner of an objecthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-never-throw
E.14: Use purpose-designed user-defined types as exceptions (not built-in types)https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-exception-types
E.15: Throw by value, catch exceptions from a hierarchy by referencehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-exception-ref
E.16: Destructors, deallocation, swap, and exception type copy/move construction must never failhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-never-fail
E.17: Don’t try to catch every exception in every functionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-not-always
E.18: Minimize the use of explicit try/catchhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-catch
E.19: Use a final_action object to express cleanup if no suitable resource handle is availablehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-finally
E.25: If you can’t throw exceptions, simulate RAII for resource managementhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-no-throw-raii
E.26: If you can’t throw exceptions, consider failing fasthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-no-throw-crash
E.27: If you can’t throw exceptions, use error codes systematicallyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-no-throw-codes
E.28: Avoid error handling based on global state (e.g. errno)https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-no-throw
E.30: Don’t use exception specificationshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-specifications
E.31: Properly order your catch-clauseshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re_catch
invarianthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-struct
RAIIhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-raii
discussionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#sd-noexcept
alternativeshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-no-throw-raii
invarianthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-struct
If a constructor cannot construct a valid object, throw an exceptionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-throw
final_actionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-finally
Use of noexcepthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-noexcept
precondition rulehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ri-pre
postcondition rulehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ri-post
exception-specificationshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-specifications
discussionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#sd-noexcept
finally()https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-finally
recommend use of consthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-const
Don’t try to catch every exception in every functionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-not-always
Minimize the use of explicit try/catchhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-catch
make move operations noexcepthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-move-noexcept
discussionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#sd-never-fail
RAIIhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-raii
RAIIhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-raii
finallyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-finally
GSLhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#gsl-guidelines-support-library
proper resource management objectshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-raii
goto exit; techniquehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-no-throw-codes
RAIIhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-raii
RAIIhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-raii
error codeshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-no-throw-codes
Discussionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#sd-???
Simulating RAIIhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-no-throw-raii
Simulating RAIIhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-no-throw-raii
simulated RAII resource managementhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-no-throw-raii
ease the pain a bithttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-finally
prefer exception-based error handlinghttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-throw
keeping functions shorthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-single
Discussionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#sd-???
Returning multiple valueshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-out-multi
Simulating RAIIhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-no-throw-raii
Stroustrup94https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Stroustrup94
noexcepthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-noexcept
Con.1: By default, make objects immutablehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconst-immutable
Con.2: By default, make member functions consthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconst-fct
Con.3: By default, pass pointers and references to constshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconst-ref
Con.4: Use const to define objects with values that do not change after constructionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconst-const
Con.5: Use constexpr for values that can be computed at compile timehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rconst-constexpr
best avoidedhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-casts-const
Pimplhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ri-pimpl
Do not cast away consthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-casts-const
T.1: Use templates to raise the level of abstraction of codehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-raise
T.2: Use templates to express algorithms that apply to many argument typeshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-algo
T.3: Use templates to express containers and rangeshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-cont
T.4: Use templates to express syntax tree manipulationhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-expr
T.5: Combine generic and OO techniques to amplify their strengths, not their costshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-generic-oo
T.10: Specify concepts for all template argumentshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-concepts
T.11: Whenever possible use standard conceptshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-std-concepts
T.12: Prefer concept names over auto for local variableshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-auto
T.13: Prefer the shorthand notation for simple, single-type argument conceptshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-shorthand
T.20: Avoid “concepts” without meaningful semanticshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-low
T.21: Require a complete set of operations for a concepthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-complete
T.22: Specify axioms for conceptshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-axiom
T.23: Differentiate a refined concept from its more general case by adding new use patternshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-refine
T.24: Use tag classes or traits to differentiate concepts that differ only in semanticshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-tag
T.25: Avoid complementary constraintshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-not
T.26: Prefer to define concepts in terms of use-patterns rather than simple syntaxhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-use
T.30: Use concept negation (!C) sparingly to express a minor differencehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-???
T.31: Use concept disjunction (C1 || C2) sparingly to express alternativeshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-???
T.40: Use function objects to pass operations to algorithmshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-fo
T.41: Require only essential properties in a template’s conceptshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-essential
T.42: Use template aliases to simplify notation and hide implementation detailshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-alias
T.43: Prefer using over typedef for defining aliaseshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-using
T.44: Use function templates to deduce class template argument types (where feasible)https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-deduce
T.46: (removed)https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-regular
T.47: Avoid highly visible unconstrained templates with common nameshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-visible
T.48: If your compiler does not support concepts, fake them with enable_ifhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-concept-def
T.49: Where possible, avoid type-erasurehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-erasure
T.60: Minimize a template’s context dependencieshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-depend
T.61: Do not over-parameterize members (SCARY)https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-scary
T.62: Place non-dependent class template members in a non-templated base classhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-nondependent
T.64: Use specialization to provide alternative implementations of class templateshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-specialization
T.65: Use tag dispatch to provide alternative implementations of functionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-tag-dispatch
T.67: Use specialization to provide alternative implementations for irregular typeshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-specialization2
T.68: Use {} rather than () within templates to avoid ambiguitieshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-cast
T.69: Inside a template, don’t make an unqualified non-member function call unless you intend it to be a customization pointhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-customization
T.80: Do not naively templatize a class hierarchyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-hier
T.81: Do not mix hierarchies and arrayshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-array
T.82: Linearize a hierarchy when virtual functions are undesirablehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-linear
T.83: Do not declare a member function template virtualhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-virtual
T.84: Use a non-template core implementation to provide an ABI-stable interfacehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-abi
T.??: ????https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-???
T.100: Use variadic templates when you need a function that takes a variable number of arguments of a variety of typeshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-variadic
T.101: ??? How to pass arguments to a variadic template ???https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-variadic-pass
T.102: ??? How to process arguments to a variadic template ???https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-variadic-process
T.103: Don’t use variadic templates for homogeneous argument listshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-variadic-not
T.??: ????https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-???
T.120: Use template metaprogramming only when you really need tohttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-metameta
T.121: Use template metaprogramming primarily to emulate conceptshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-emulate
T.122: Use templates (usually template aliases) to compute types at compile timehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-tmp
T.123: Use constexpr functions to compute values at compile timehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-fct
T.124: Prefer to use standard-library TMP facilitieshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-std-tmp
T.125: If you need to go beyond the standard-library TMP facilities, use an existing libraryhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-lib
T.??: ????https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-???
T.140: If an operation can be reused, give it a namehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-name
T.141: Use an unnamed lambda if you need a simple function object in one place onlyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-lambda
T.142: Use template variables to simplify notationhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-var
T.143: Don’t write unintentionally non-generic codehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-non-generic
T.144: Don’t specialize function templateshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-specialize-function
T.150: Check that a class matches a concept using static_asserthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-check-class
T.??: ????https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-???
Stable basehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-abi
don’t overuse type erasurehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-erasure
T.10: Specify concepts for all template argumentshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-concepts
T.11: Whenever possible use standard conceptshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-std-concepts
T.12: Prefer concept names over autohttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-auto
T.13: Prefer the shorthand notation for simple, single-type argument conceptshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-shorthand
T.20: Avoid “concepts” without meaningful semanticshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-low
T.21: Require a complete set of operations for a concepthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-complete
T.22: Specify axioms for conceptshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-axiom
T.23: Differentiate a refined concept from its more general case by adding new use patternshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-refine
T.24: Use tag classes or traits to differentiate concepts that differ only in semanticshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-tag
T.25: Avoid complimentary constraintshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-not
T.26: Prefer to define concepts in terms of use-patterns rather than simple syntaxhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-use
GSLhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#gsl-guidelines-support-library
an early experimenthttps://www.stroustrup.com/sle2010_webversion.pdf
a concept must make semantic sensehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-low
Palo Alto TRhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-references
T.24https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-tag
Template parameter deduction for constructors (Rev. 3)https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0091r1.html
complementary constraintshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-not
T.69https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-customization
SCARYhttps://www.open-std.org/jtc1/sc22/WG21/docs/papers/2009/n2911.pdf
T.61https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-scary
unintentionally invoking unconstrained function templateshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-visible
“stable base”https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-abi
OO and GPhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-generic-oo
T* points to an individual object rulehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-ptr
no-slicing rulehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-slice
Pimplhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ri-pimpl
How to emulate concepts if you don’t have language supporthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-emulate
constexpr functionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rt-fct
F.10https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-name
F.11https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-lambda
CPL.1: Prefer C++ to Chttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rcpl-c
CPL.2: If you must use C, use the common subset of C and C++, and compile the C code as C++https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rcpl-subset
CPL.3: If you must use C for interfaces, use C++ in the calling code using such interfaceshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rcpl-interface
SF.1: Use a .cpp suffix for code files and .h for interface files if your project doesn’t already follow another conventionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rs-file-suffix
SF.2: A header file must not contain object definitions or non-inline function definitionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rs-inline
SF.3: Use header files for all declarations used in multiple source fileshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rs-declaration-header
SF.4: Include header files before other declarations in a filehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rs-include-order
SF.5: A .cpp file must include the header file(s) that defines its interfacehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rs-consistency
SF.6: Use using namespace directives for transition, for foundation libraries (such as std), or within a local scope (only)https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rs-using
SF.7: Don’t write using namespace at global scope in a header filehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rs-using-directive
SF.8: Use #include guards for all header fileshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rs-guards
SF.9: Avoid cyclic dependencies among source fileshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rs-cycles
SF.10: Avoid dependencies on implicitly #included nameshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rs-implicit
SF.11: Header files should be self-containedhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rs-contained
SF.12: Prefer the quoted form of #include for files relative to the including file and the angle bracket form everywhere elsehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rs-incform
SF.13: Use portable header identifiers in #include statementshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rs-portable-header-id
SF.20: Use namespaces to express logical structurehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rs-namespace
SF.21: Don’t use an unnamed (anonymous) namespace in a headerhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rs-unnamed
SF.22: Use an unnamed (anonymous) namespace for all internal/non-exported entitieshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rs-unnamed2
NL.27https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rl-file-suffix
Working Draft, Extensions to C++ for Moduleshttps://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/n4592.pdf
Modules, Componentization, and Transitionhttps://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0141r0.pdf
Don’t write using namespace at global scope in a header filehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rs-using-directive
the ruleshttps://eel.is/c++draft/over.literal
rule P.2https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rp-cplusplus
standardhttps://eel.is/c++draft/cpp.include
standardhttps://eel.is/c++draft/cpp.include
SL.con: Containershttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-con
SL.str: Stringhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-string
SL.io: Iostreamhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-io
SL.regex: Regexhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-regex
SL.chrono: Timehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-chrono
SL.C: The C Standard Libraryhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-clib
SL.1: Use libraries wherever possiblehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rsl-lib
SL.2: Prefer the standard library to other librarieshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rsl-sl
SL.3: Do not add non-standard entities to namespace stdhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#sl-std
SL.4: Use the standard library in a type-safe mannerhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#sl-safe
SL.4: Use the standard library in a type-safe mannerhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#sl-safe
SL.con.1: Prefer using STL array or vector instead of a C arrayhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rsl-arrays
SL.con.2: Prefer using STL vector by default unless you have a reason to use a different containerhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rsl-vector
SL.con.3: Avoid bounds errorshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rsl-bounds
SL.con.4: don’t use memset or memcpy for arguments that are not trivially-copyablehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rsl-copy
Prefer the {}-initializer syntaxhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-list
bounds profilehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-bounds
regular expressionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-regex
SL.str.1: Use std::string to own character sequenceshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rstr-string
SL.str.2: Use std::string_view or gsl::span to refer to character sequenceshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rstr-view
SL.str.3: Use zstring or czstring to refer to a C-style, zero-terminated, sequence of charactershttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rstr-zstring
SL.str.4: Use char* to refer to a single characterhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rstr-charp
SL.str.5: Use std::byte to refer to byte values that do not necessarily represent charactershttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rstr-byte
SL.str.10: Use std::string when you need to perform locale-sensitive string operationshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rstr-locale
SL.str.11: Use gsl::span rather than std::string_view when you need to mutate a stringhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rstr-span
SL.str.12: Use the s suffix for string literals meant to be standard-library stringshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rstr-s
F.24 spanhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-range
F.25 zstringhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-zstring
Don’t optimize prematurelyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rper-knuth
zstringhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rstr-zstring
stringhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rstr-string
string_viewhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rstr-view
locale facilitieshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rstr-locale
SL.io.1: Use character-level input only when you have tohttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rio-low
SL.io.2: When reading, always consider ill-formed inputhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rio-validate
SL.io.3: Prefer iostreams for I/Ohttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rio-streams
SL.io.10: Unless you use printf-family functions call ios_base::sync_with_stdio(false)https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rio-sync
SL.io.50: Avoid endlhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rio-endl
???https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#???
SL.C.1: Don’t use setjmp/longjmphttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rclib-jmp
???https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#???
???https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#???
A.1: Separate stable code from less stable codehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ra-stable
A.2: Express potentially reusable parts as a libraryhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ra-lib
A.4: There should be no cycles among librarieshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ra-dag
???https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#???
???https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#???
???https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#???
???https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#???
???https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#???
???https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#???
NR.1: Don’t insist that all declarations should be at the top of a functionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rnr-top
NR.2: Don’t insist on having only a single return-statement in a functionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rnr-single-return
NR.3: Don’t avoid exceptionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rnr-no-exceptions
NR.4: Don’t insist on placing each class definition in its own source filehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rnr-lots-of-files
NR.5: Don’t use two-phase initializationhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rnr-two-phase-init
NR.6: Don’t place all cleanup actions at the end of a function and goto exithttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rnr-goto-exit
NR.7: Don’t make data members protectedhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rnr-protected-data
Always initialize an objecthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-always
ES.21: Don’t introduce a variable (or constant) before you need to use ithttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-introduce
goto exithttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rnr-goto-exit
RAIIhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-raii
RAIIhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-raii
finallyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#re-finally
Avoid protected datahttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-protected
RF.rules: Coding ruleshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-rules
RF.books: Books with coding guidelineshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-books
RF.C++: C++ Programming (C++11/C++14/C++17)https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-cplusplus
RF.web: Websiteshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-web
RS.video: Videos about “modern C++”https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-vid
RF.man: Manualshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-man
RF.core: Core Guidelines materialshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-core
AUTOSAR Guidelines for the use of the C++14 language in critical and safety-related systems v22.11https://www.autosar.org/fileadmin/standards/R22-11/AP/AUTOSAR_RS_CPP14Guidelines.pdf
MISRA C++:2023https://misra.org.uk/product/misra-cpp2023/
Boost Library Requirements and Guidelineshttps://www.boost.org/development/requirements.html
Bloomberg: BDE C++ Codinghttps://github.com/bloomberg/bde/wiki/CodingStandards.pdf
GCC Coding Conventionshttps://gcc.gnu.org/codingconventions.html
Google C++ Style Guidehttps://google.github.io/styleguide/cppguide.html
JSF++: JOINT STRIKE FIGHTER AIR VEHICLE C++ CODING STANDARDShttps://www.stroustrup.com/JSF-AV-rules.pdf
MISRA C++:2023 Guidelines for the use C++17 in critical systemshttps://misra.org.uk/product/misra-cpp2023/
Using C++ in Mozilla Codehttps://firefox-source-docs.mozilla.org/code-quality/coding-style/using_cxx_in_firefox_code.html
Geosoft.no: C++ Programming Style Guidelineshttps://geosoft.no/development/cppstyle.html
Possibility.com: C++ Coding Standardhttps://www.possibility.com/Cpp/CppCodingStandard.html
SEI CERT: Secure C++ Coding Standardhttps://wiki.sei.cmu.edu/confluence/x/Wnw-BQ
High Integrity C++ Coding Standardhttps://www.codingstandard.com/
llvmhttps://llvm.org/docs/CodingStandards.html
Meyers96https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Meyers96
Meyers97https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Meyers97
Meyers01https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Meyers01
Meyers05https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Meyers05
Meyers15https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Meyers15
SuttAlex05https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#SuttAlex05
Stroustrup05https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Stroustrup05
A rationale for semantically enhanced library languageshttps://www.stroustrup.com/SELLrationale.pdf
Stroustrup14https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Stroustrup05
A Tour of C++https://www.stroustrup.com/Tour.html
Stroustrup13https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Stroustrup13
The C++ Programming Language (4th Edition)https://www.stroustrup.com/4th.html
Style Guidehttps://www.stroustrup.com/Programming/PPP-style.pdf
Programming: Principles and Practice using C++https://www.stroustrup.com/programming.html
TC++PL4https://www.stroustrup.com/4th.html
Tour++https://www.stroustrup.com/Tour.html
Programming: Principles and Practice using C++https://www.stroustrup.com/programming.html
isocpp.orghttps://isocpp.org
Bjarne Stroustrup’s home pageshttps://www.stroustrup.com
WG21https://www.open-std.org/jtc1/sc22/wg21/
Boosthttps://www.boost.org
Adobe open sourcehttps://opensource.adobe.com/
Poco librarieshttps://pocoproject.org/
C++11 Stylehttps://learn.microsoft.com/en-us/shows/goingnative-2012/keynote-bjarne-stroustrup-cpp11-style
The Essence of C++: With Examples in C++84, C++98, C++11, and C++14https://learn.microsoft.com/en-us/shows/goingnative-2013/opening-keynote-bjarne-stroustrup
CppCon ’14https://isocpp.org/blog/2014/11/cppcon-videos-c9
The essence of C++https://www.youtube.com/watch?v=86xWVb4XIyE
The Evolution of C++ Past, Present and Futurehttps://www.youtube.com/watch?v=_wzc7a3McOs
Make Simple Tasks Simple!https://www.youtube.com/watch?v=nesCaocNjtQ
Writing Good C++14https://www.youtube.com/watch?v=1OEu9C51K2A
Writing Good C++14… By Defaulthttps://www.youtube.com/watch?v=hEx5DNLWGgA
ISO C++ Standard C++17https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/n4606.pdf
Palo Alto “Concepts” TRhttps://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3351.pdf
ISO C++ Concepts TShttps://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4553.pdf
WG21 Ranges reporthttps://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/n4569.pdf
Our documents directoryhttps://github.com/isocpp/CppCoreGuidelines/tree/master/docs
A brief introduction to C++’s model for type- and resource-safetyhttps://www.stroustrup.com/resource-model.pdf
a Core Guidelines talkhttps://www.youtube.com/watch?v=DyLwdl_6vmU
slideshttps://www.slideshare.net/slideshow/c-core-guidelines-72335317/72335317
The Guideline Support Library: One Year Laterhttps://www.youtube.com/watch?v=_GhNnCuaEjo
Writing Good C++14https://www.youtube.com/watch?v=1OEu9C51K2A
Writing Good C++14… By Defaulthttps://www.youtube.com/watch?v=hEx5DNLWGgA
C++ Core Guidelines - Modernize your C++ Code Basehttps://www.youtube.com/watch?v=fQ926v4ZzAM
No Littering!https://www.youtube.com/watch?v=01zI9kV4h8c
gradual adoptionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-modernizing
Pro.type: Type safetyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-type
Pro.bounds: Bounds safetyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-bounds
Pro.lifetime: Lifetime safetyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-lifetime
Bounds safetyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-bounds
Lifetime safetyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-lifetime
Avoid castshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-casts
Avoid castshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-casts
prefer named castshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-casts-named
Avoid castshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-casts
prefer named castshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-casts-named
Avoid castshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-casts
Avoid castshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-casts
Use dynamic_cast insteadhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rh-dynamic_cast
Don’t cast away consthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-casts-const
constructionhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-construct
named castshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-casts-named
always initializehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-always
always initializehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-always
default constructorshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-default0
default member initializershttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-in-class-initializer
Use variant insteadhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ru-naked
Don’t use va_arg argumentshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#f-varargs
Bounds safetyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-bounds
Lifetime safetyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-lifetime
Type safetyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-type
Lifetime safetyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-lifetime
Pass pointers to single objects (only)https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ri-array
Keep pointer arithmetic simplehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-ptr
Pass pointers to single objects (only)https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ri-array
Keep pointer arithmetic simplehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-ptr
Pass pointers to single objects (only)https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ri-array
Keep pointer arithmetic simplehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-ptr
Use the standard library in a type-safe mannerhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rsl-bounds
See the current design specification here.https://github.com/isocpp/CppCoreGuidelines/blob/master/docs/Lifetime.pdf
detect or avoidhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-deref
GSL: Guidelines support libraryhttps://github.com/Microsoft/GSL
the one voted into C++17https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0088r3.html
GSL.view: Viewshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-views
GSL.owner: Ownership pointershttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-ownership
GSL.assert: Assertionshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-assertions
GSL.util: Utilitieshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-utilities
GSL.concept: Conceptshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-gsl-concepts
R.4https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rr-ref
the contract proposalhttps://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0380r1.pdf
NL.1: Don’t say in comments what can be clearly stated in codehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rl-comments
NL.2: State intent in commentshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rl-comments-intent
NL.3: Keep comments crisphttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rl-comments-crisp
NL.4: Maintain a consistent indentation stylehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rl-indent
NL.5: Avoid encoding type information in nameshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rl-name-type
NL.7: Make the length of a name roughly proportional to the length of its scopehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rl-name-length
NL.8: Use a consistent naming stylehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rl-name
NL.9: Use ALL_CAPS for macro names onlyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rl-all-caps
NL.10: Prefer underscore_style nameshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rl-camel
NL.11: Make literals readablehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rl-literals
NL.15: Use spaces sparinglyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rl-space
NL.16: Use a conventional class member declaration orderhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rl-order
NL.17: Use K&R-derived layouthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rl-knr
NL.18: Use C++-style declarator layouthttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rl-ptr
NL.19: Avoid names that are easily misreadhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rl-misread
NL.20: Don’t place two statements on the same linehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rl-stmt
NL.21: Declare one name (only) per declarationhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rl-dcl
NL.25: Don’t use void as an argument typehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rl-void
NL.26: Use conventional const notationhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rl-const
NL.27: Use a .cpp suffix for code files and .h for interface fileshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rl-file-suffix
PPP Style Guidehttps://www.stroustrup.com/Programming/PPP-style.pdf
Programming: Principles and Practice using C++https://www.stroustrup.com/programming.html
Stroustruphttps://www.stroustrup.com/Programming/PPP-style.pdf
Enum.5: Don’t use ALL_CAPS for enumeratorshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#renum-caps
consistencyhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rl-name
when you have no constraints or better ideashttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-naming
Stroustruphttps://www.stroustrup.com/Programming/PPP-style.pdf
“magic constants”https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-magic
when you have no constraints or better ideashttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-naming
when you have no constraints or better ideashttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-naming
when you have no constraints or better ideashttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-naming
when you have no constraints or better ideashttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-naming
ES.10https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#res-name-one
when you have no constraints or better ideashttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-naming
top of this pagehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#s-abstract
Bjarne Stroustrup in his CppCon 2015 opening keynote, “Writing Good C++14”https://isocpp.org/blog/2015/09/stroustrup-cppcon15-keynote
accompanying isocpp.org blog posthttps://isocpp.org/blog/2015/09/bjarne-stroustrup-announces-cpp-core-guidelines
Herb Sutter’s follow-up CppCon 2015 talk, “Writing Good C++14 … By Default”https://isocpp.org/blog/2015/09/sutter-cppcon15-day2plenary
CONTRIBUTING.mdhttps://github.com/isocpp/CppCoreGuidelines/blob/master/CONTRIBUTING.md
CONTRIBUTING.mdhttps://github.com/isocpp/CppCoreGuidelines/blob/master/CONTRIBUTING.md
github.com/cplusplushttps://github.com/cplusplus
C++ FAQhttps://isocpp.org/faq
CommonMarkhttps://commonmark.org
GitHub Flavored Markdown (GFM)https://help.github.com/articles/github-flavored-markdown/
github.com/Microsoft/GSLhttps://github.com/Microsoft/GSL
use spanhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-views
[Cline99]https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Cline99
[Dewhurst03]https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Dewhurst03
[Koenig97]https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Koenig97
[Lakos96]https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Lakos96
[Meyers97]https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Meyers97
[Murray93]https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Murray93
[Sutter00]https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Sutter00
[Taligent94]https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Taligent94
SuttAlex05https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#SuttAlex05
[Alexandrescu01]https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Alexandrescu01
[Boost]https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Boost
[Dewhurst03]https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Dewhurst03
[Meyers97]https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Meyers97
[Stroustrup00]https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Stroustrup00
[Taligent94]https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Taligent94
[SuttAlex05]https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#SuttAlex05
[Cargill92]https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Cargill92
[Cline99]https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Cline99
[Henricson97]https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Henricson97
[Koenig97]https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Koenig97
[Meyers97]https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Meyers97
[Stroustrup00]https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Stroustrup00
[Sutter02]https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Sutter02
[Sutter04]https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Sutter04
[C++03]https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Cplusplus03
[C++03]https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Cplusplus03
[SuttAlex05]https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#SuttAlex05
[C++03]https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Cplusplus03
[Meyers96]https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Meyers96
[Stroustrup00]https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Stroustrup00
[Sutter00]https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Sutter00
[Sutter02]https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Sutter02
[SuttAlex05]https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#SuttAlex05
[Cline99]https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Cline99
[Koenig97]https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Koenig97
[Stroustrup00]https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#Stroustrup00
[SuttHysl04b]https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#SuttHysl04b
Provide strong resource safety; that is, never leak anything that you think of as a resourcehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#cr-safety
Never return or throw while holding a resource not owned by a handlehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#cr-never
A “raw” pointer or reference is never a resource handlehttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#cr-raw
Never let a pointer outlive the object it points tohttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#cr-outlive
Use templates to express containers (and other resource handles)https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#cr-templates
Return containers by value (relying on move or copy elision for efficiency)https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#cr-value-return
If a class is a resource handle, it needs a constructor, a destructor, and copy and/or move operationshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#cr-handle
If a class is a container, give it an initializer-list constructorhttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#cr-list
the copy, move, and destruction operationshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rc-five
F.20, the general item about “out” output valueshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-out
F.20https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#rf-out
the default operationshttps://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html#ss-ctor
Clang-tidyhttps://clang.llvm.org/extra/clang-tidy/checks/list.html
CppCoreCheckhttps://docs.microsoft.com/en-us/visualstudio/code-quality/using-the-cpp-core-guidelines-checkers
Programming: Principles and Practice using C++https://www.stroustrup.com/programming.html
Standard C++ Foundationhttps://isocpp.org
iso.orghttps://iso.org
Technical Specificationhttps://www.iso.org/deliverables-all.html?type=ts
Exception-Safety in Generic Componentshttps://www.boost.org/community/exception_safety.html
A rationale for semantically enhanced library languageshttps://www.stroustrup.com/SELLrationale.pdf
The C++ Programming Language (4th Edition)https://www.stroustrup.com/4th.html
A Tour of C++https://www.stroustrup.com/Tour.html
A brief introduction to C++’s model for type- and resource-safetyhttps://github.com/isocpp/CppCoreGuidelines/blob/master/docs/Introduction%20to%20type%20and%20resource%20safety.pdf
Collecting Shared Objectshttps://web.archive.org/web/20120926011837/http://www.drdobbs.com/collecting-shared-objects/184401839

Viewport: width=device-width, initial-scale=1.0, maximum-scale=1

URLs of crawlers that visited me.