C++ pensieve

operator precedence

scope::
suffix++ -- () [] . -> typeid() const_cast dynamic_cast reinterpret_cast static_cast
prefix++ -- + - ! ~ (type) * & sizeof new new[] delete delete[]
member.* ->*
multiplication* / %
addition+ -
shifts<< >>
comparison< <= > >=
equates== !=
and&
xor^
or|
logical and&&
logical or||
conditional?:
assignment= += -= *= /= %= <<= >>= &= ^= |=
exceptionthrow
sequence,

operator signatures

assignmentR &operator=(L l) {}
arithmeticR operator+(L l) const {}
R operator-(L l) const {}
R operator*(L l) const {}
R operator/(L l) const {}
R operator%(L l) const {}
compound arithmeticR &operator+=(L l) {}
R &operator-=(L l) {}
R &operator*=(L l) {}
R &operator/=(L l) {}
R &operator%=(L l) {}
incrementalR &operator++() {}
R &operator++(int) {}
R &operator--() {}
R &operator--(int) {}
logicalR operator!() const {}
R operator&&(L l) const {}
R operator||(L l) const {}
bitwiseR operator~() const {}
R operator&(L l) const {}
R operator|(L l) const {}
R operator^(L l) const {}
compound bitwiseR &operator&=(L l) {}
R &operator|=(L l) {}
R &operator^=(L l) {}
shiftR operator<<(L l) const {}
R operator>>(L l) const {}
compound shiftR &operator<<=(L l) {}
R &operator>>=(L l) {}
comparisonR operator==(L const &l) const {}
R operator!=(L const &l) const {}
R operator<(L const &l) const {}
R operator>(L const &l) const {}
R operator<=(L const &l) const {}
R operator>=(L const &l) const {}
subscriptR &operator[](L l) {}
indirectionR &operator*(L l) {}
address ofR *operator&(L l) {}
dereferenceR *operator->(L l) {}
R &operator->*(L l) {}
commaR operator,(L l) {}

format specifiers

	std::format("{fill align sign # 0 width L .precision type}", variables);
fill[char]padding (default SP)
align<left (default)
>right
^centre
alternate#alternate form
numeric0leading zeroes
sign-negative sign (default)
+negative or positive sign
SPsign or space
widthnfixed width
{}parameterized width
precisionnfixed precision
{}parameterized precision
localeLlocale specific form
typeccharacter
∅string
sstring
?escaped string
ddecimal
bBbinary
ooctal
xXhexadecimal
∅floating point
eEexponent floating point
fFfixed point
aAhexadecimal floating point
pPhexadecimal pointer

stdexcept categories

logic_errorgeneric error in condition or invariant
invalid_argumentargument invalid
domain_errorargument domain error
length_errorargument of excessive size
out_of_rangeargument outside expected range
runtime_errorerrors in the runtime context
range_errorcomputational range errors
overflow_errorarithmetic overflows
underflow_errorarithmetic underflows

self embedded script

	#ifdef _SCRIPT
	filename=$0; set -x; g++ -std=c++20 -O2 -o ${filename%%.*} ${filename}; exit
	#endif

makefile template

	CPPFLAGS = -O2 @gcc.conf
	LDFLAGS = -O2
	%.elf: %.o
		$(CXX) $(LDFLAGS) -o $@ $^
	-include *.d

error checking gcc configuration

	-std=c++23
	-fmodules-ts
	-Wall
	-Wextra
	-MMD
	-Mno-modules

compiler definitions

	gcc -dM -E - <dev/null

logging to a debug file

	#include <fstream>
	static std::ofstream debug("debug.log");
	⋮
	debug << "test" << std::endl;

timing an operation

	#include <chrono>
	auto t_start = std::chrono::high_resolution_clock::now();
	⋮
	auto t_elapsed = std::chrono::high_resolution_clock::now() - t_start;
	… << elapsed.count()/1e9 …

process lines in text file

	#include <string>
	#include <iostream>
	#include <regex>
	⋮
	using std::string, std::getline;
	using std::cin;
	using std::regex, std::smatch, std::regex_match;
	for (string text; getline(cin, text);)
		if (smatch subtext; std::regex_match(text, subtext, regex{R"(…)"}))
			// process subtext

command line arguments

	#include <unistd.h>
	using std::cerr, std::endl;
	⋮
	struct Flags {bool debug; const char *filename} flags;
	int c;
	const auto opts{"hdf"};
	while ((c = getopt(argc, argv, opts)) != -1)
		switch (c)
		{
		case 'h': case '?': cerr << "Usage: " << argv[0] << " -" << opts << endl; break;
		case 'd': flags.debug = true; break;
		case 'f': flags.filename = optarg; break;
		}

random number generation

	#include <random>
	⋮
	std::mt19937 rng(std::random_device{}());
	std::uniform_real_distribution rnd(0.0, 1.0);
	⋮
	auto r = rnd(rng);

first order approximation to atan2

	copysign(1-x/(fabs(x)+fabs(y)), y)*(std::numbers::pi/2);