What's not in the course

Nobody has claimed this yet.

This is intended as a meta issue to collect and track C++ constructs that are not yet part of the course. If we decide to add them, we will create new issues for them with more details and remove them here. In case we decided to not add them, we provide a reason here. Please edit the table below to add new content instead of commenting.

C++ feature	What is this about?	Reason if we don't want it
freestanding	A mode of C++ for non-hosted programs (i.e. embedded systems)
the C++ memory model	The theoretical model on which memory and concurrency is built
incomplete types	Restrictions and use cases for declared-only types.
alignment	`alignas`, `alignof`, overalignment, aligned allocation with `new` and `align_val_t`
unicode	`char8_t`/`char16_t`/`char32_t` and their literals, `u8string`, `wchar_t` and why `char` is sometimes enough
conversion operator	`operator T()` on a class
`thread_local`	variables global for a thread
anonymous unions	Union members inside structs which have no names
`volatile`	Disables optimizations around e.g. a variable.
pragmas	Discuss some important pragmas (e.g. unroll, pack, etc.)
[[attributes]]	We have `[[fallthrough]]`, but there are a lot more
package managers	how to get external libraries via conan, vcpkg, spack, ...
`typeid`	It is mentioned once around `std::any`, but not explained. Include `std::typeindex` here.
namespace aliases	`namespace stdx = std::experimental`
ref qualifiers	`struct S { void f() && { ... }};`
member pointers	pointers to member functions and non-static data members
function pointers	Pointers to functions and how to define their type
full template specialization	we only have 1 example for partial specialization
function template specialization vs. overloading	Why overloading is preferable to specialization. How SFINAE and `requires` help here.
template meta programming	Type lists, type functions, template template parameters, algorithms on type lists, ...
bit fields	`struct S { int a : 4; int b : 28; };`
type traits and named requirements	trivially copyable, trivial, copy constructible, POD, standard layout, aggregate, etc.
`std::bitset`
`std::deque`
file IO	probably `std::fstream`
all of `<filesystem>`	how to handle paths, iterate directories, copy/delete files, etc.
IO manipulators	`std::endl`, `std::left`, `std::hex`, etc.
`std::stringstream`
Lists	`std::list` and `std::forward_list`. Why they are slow for many applications and when they are useful
Locals	Changing language, formatting decimal points, etc. Which functions are affected? Why you cannot read back a text file on your en_US notebook, written on a de_AT system.
Associative containers	`std::set`, `std::multiset`, `std::unordered_set`, `std::map`, `std::multimap`, `std::unordered_map`, `std::flat_set`, `std::flat_map`, ...
`std::hash`
`std::queue`
`std::stack`
`std::pair` and `std::tuple`
`std::integer_sequence`	This connects to `std::tuple` and meta programming
Optimization utilities	`std::unreachable`, `[[likely]]`, etc.
`std::valarray`
`std::array`
`<chrono>`	Basically all the header: clocks, dates, times, timezones, calendars, weekdays, etc.
`std::regex`
`<system_error>`	All about error codes and handling platform specific errors
Allocators	Discuss that many STL constructs can be augmented with allocators to change their allocation behavior
Memory resources	All from `std::pmr` and `<memory_resource>`
Barriers and latches	From `<barrier>` and `<latch>`
Bit and byte manipulation	From `<bit>`, e.g. `bit_cast`, `bit_ceil`, `rotl`, `endian`, `byteswap`, ...
Math. constants from `<numbers>`	We can use `std::numbers::pi` now instead of non-standard `M_PI`
`<semaphore>`
`std::source_location`	As a replacement for `__FILE__`, `__LINE__`, etc.
`std::expected`	Alternative to errorcode/exception based error handling. We mention it briefly around exceptions.
stack traces	use `std::stracktrace` to get a stack trace. And you can print it.
floating points	There are a lot of myths around floats and also IEEE 754. We could discuss a bit how the format works, INF, NAN, rounding modes, precision, comparison, fast-math, ...
iterators	we mention them around the STL, but we never discuss their requirements, the iterator hierarchy, and some concepts behind them
memory order	Atomic operations have a memory order and we don't talk about its semantics. Especially, that `relaxed` is faster than the default `seq_consistent`, and when we need `acquire` and `release` semantic.
deducing `this`	Member functions with explicit object parameters
value categories	We only discuss rvalue and lvalue, but not xvalue, glvalue and prvalue

Start by reviewing the feature table in issue #269 and the existing course coverage; no source files or tests are named. For each candidate construct, confirm whether it belongs in the course, then record a reason or create a separate detailed issue and remove the entry as appropriate.

Written by the indexing model from the issue text.

Description

Contributor guide

First steps

Research direction

Assessment