\documentclass[10pt,a4paper]{article}

% Packages
\usepackage{fancyhdr}           % For header and footer
\usepackage{multicol}           % Allows multicols in tables
\usepackage{tabularx}           % Intelligent column widths
\usepackage{tabulary}           % Used in header and footer
\usepackage{hhline}             % Border under tables
\usepackage{graphicx}           % For images
\usepackage{xcolor}             % For hex colours
%\usepackage[utf8x]{inputenc}    % For unicode character support
\usepackage[T1]{fontenc}        % Without this we get weird character replacements
\usepackage{colortbl}           % For coloured tables
\usepackage{setspace}           % For line height
\usepackage{lastpage}           % Needed for total page number
\usepackage{seqsplit}           % Splits long words.
%\usepackage{opensans}          % Can't make this work so far. Shame. Would be lovely.
\usepackage[normalem]{ulem}     % For underlining links
% Most of the following are not required for the majority
% of cheat sheets but are needed for some symbol support.
\usepackage{amsmath}            % Symbols
\usepackage{MnSymbol}           % Symbols
\usepackage{wasysym}            % Symbols
%\usepackage[english,german,french,spanish,italian]{babel}              % Languages

% Document Info
\author{blakecromar}
\pdfinfo{
  /Title (c-std-library.pdf)
  /Creator (Cheatography)
  /Author (blakecromar)
  /Subject (C++ Std Library Cheat Sheet)
}

% Lengths and widths
\addtolength{\textwidth}{6cm}
\addtolength{\textheight}{-1cm}
\addtolength{\hoffset}{-3cm}
\addtolength{\voffset}{-2cm}
\setlength{\tabcolsep}{0.2cm} % Space between columns
\setlength{\headsep}{-12pt} % Reduce space between header and content
\setlength{\headheight}{85pt} % If less, LaTeX automatically increases it
\renewcommand{\footrulewidth}{0pt} % Remove footer line
\renewcommand{\headrulewidth}{0pt} % Remove header line
\renewcommand{\seqinsert}{\ifmmode\allowbreak\else\-\fi} % Hyphens in seqsplit
% This two commands together give roughly
% the right line height in the tables
\renewcommand{\arraystretch}{1.3}
\onehalfspacing

% Commands
\newcommand{\SetRowColor}[1]{\noalign{\gdef\RowColorName{#1}}\rowcolor{\RowColorName}} % Shortcut for row colour
\newcommand{\mymulticolumn}[3]{\multicolumn{#1}{>{\columncolor{\RowColorName}}#2}{#3}} % For coloured multi-cols
\newcolumntype{x}[1]{>{\raggedright}p{#1}} % New column types for ragged-right paragraph columns
\newcommand{\tn}{\tabularnewline} % Required as custom column type in use

% Font and Colours
\definecolor{HeadBackground}{HTML}{333333}
\definecolor{FootBackground}{HTML}{666666}
\definecolor{TextColor}{HTML}{333333}
\definecolor{DarkBackground}{HTML}{424169}
\definecolor{LightBackground}{HTML}{F3F3F5}
\renewcommand{\familydefault}{\sfdefault}
\color{TextColor}

% Header and Footer
\pagestyle{fancy}
\fancyhead{} % Set header to blank
\fancyfoot{} % Set footer to blank
\fancyhead[L]{
\noindent
\begin{multicols}{3}
\begin{tabulary}{5.8cm}{C}
    \SetRowColor{DarkBackground}
    \vspace{-7pt}
    {\parbox{\dimexpr\textwidth-2\fboxsep\relax}{\noindent
        \hspace*{-6pt}\includegraphics[width=5.8cm]{/web/www.cheatography.com/public/images/cheatography_logo.pdf}}
    }
\end{tabulary}
\columnbreak
\begin{tabulary}{11cm}{L}
    \vspace{-2pt}\large{\bf{\textcolor{DarkBackground}{\textrm{C++ Std Library Cheat Sheet}}}} \\
    \normalsize{by \textcolor{DarkBackground}{blakecromar} via \textcolor{DarkBackground}{\uline{cheatography.com/218070/cs/48109/}}}
\end{tabulary}
\end{multicols}}

\fancyfoot[L]{ \footnotesize
\noindent
\begin{multicols}{3}
\begin{tabulary}{5.8cm}{LL}
  \SetRowColor{FootBackground}
  \mymulticolumn{2}{p{5.377cm}}{\bf\textcolor{white}{Cheatographer}}  \\
  \vspace{-2pt}blakecromar \\
  \uline{cheatography.com/blakecromar} \\
  \end{tabulary}
\vfill
\columnbreak
\begin{tabulary}{5.8cm}{L}
  \SetRowColor{FootBackground}
  \mymulticolumn{1}{p{5.377cm}}{\bf\textcolor{white}{Cheat Sheet}}  \\
   \vspace{-2pt}Not Yet Published.\\
   Updated 26th June, 2026.\\
   Page {\thepage} of \pageref{LastPage}.
\end{tabulary}
\vfill
\columnbreak
\begin{tabulary}{5.8cm}{L}
  \SetRowColor{FootBackground}
  \mymulticolumn{1}{p{5.377cm}}{\bf\textcolor{white}{Sponsor}}  \\
  \SetRowColor{white}
  \vspace{-5pt}
  %\includegraphics[width=48px,height=48px]{dave.jpeg}
  Measure your website readability!\\
  www.readability-score.com
\end{tabulary}
\end{multicols}}




\begin{document}
\raggedright
\raggedcolumns

% Set font size to small. Switch to any value
% from this page to resize cheat sheet text:
% www.emerson.emory.edu/services/latex/latex_169.html
\footnotesize % Small font.

\begin{multicols*}{3}

\begin{tabularx}{5.377cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{5.377cm}}{\bf\textcolor{white}{std::move}}  \tn
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{5.377cm}}{// Basic Usage \newline std::move(\textless{}object\textgreater{}); \newline  \newline -{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-- \newline  \newline // Not using move \newline MyObject a; \newline MyObject b = a;        // a and b both exist, a is unchanged \newline  \newline // With move — transfers ownership (cheap, always works) \newline MyObject a; \newline MyObject b = std::move(a); // b has everything, a is now empty \newline  \newline // With a caller \newline MyObject buildThing() \newline \{ \newline     MyObject thing; \newline     return std::move(thing); // transfers ownership to the caller \newline \} \newline  \newline MyObject result = buildThing(); // result now owns everything} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{5.377cm}}{1. Transfers ownership of an object to another location, leaving the original empty. It prevents expensive or impossible copies by moving the underlying data instead.}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{5.377cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{5.377cm}}{\bf\textcolor{white}{std::error\_code}}  \tn
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{5.377cm}}{std::error\_code ec;} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{5.377cm}}{std::error\_code is a lightweight C++ object for holding an error without throwing an exception.}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{5.377cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{5.377cm}}{\bf\textcolor{white}{std::make\_unique}}  \tn
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{5.377cm}}{auto myObject = std::make\_unique\textless{}ClassName\textgreater{}(arg1, arg2, ...);} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{5.377cm}}{You get back a std::unique\_ptr\textless{}ClassName\textgreater{} that automatically deletes the object when it goes out of scope. \newline  \newline \textless{}ClassName\textgreater{} — the type you want to allocate \newline \textless{}arg1, arg2, ...\textgreater{} — the arguments forwarded to its constructor (can be zero or more) \newline  \newline Note: Scope is defined as where it was originally declared.}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{5.377cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{5.377cm}}{\bf\textcolor{white}{\seqsplit{std::memory\_order\_acquire}}}  \tn
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{5.377cm}}{\seqsplit{std::memory\_order\_acquire}} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{5.377cm}}{memory\_order\_acquire is a constant within the memory\_order enum. When a thread loads an atomic value with acquire, it is guaranteed to see all writes that the other thread made before its corresponding release store.}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{5.377cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{5.377cm}}{\bf\textcolor{white}{std::exception}}  \tn
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{5.377cm}}{try \newline \{ \newline     // code that might throw \newline \} \newline catch (const std::exception\& e) \newline \{ \newline     std::cout \textless{}\textless{} e.what();  // returns a description of the error \newline \}} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{5.377cm}}{std::exception is the base class for all standard C++ exceptions, caught using a const reference. \newline  \newline Give me one sentence on the method what}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{5.377cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{5.377cm}}{\bf\textcolor{white}{std::nullopt}}  \tn
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{5.377cm}}{// std::nullopt \newline // A special constant from \textless{}optional\textgreater{}. \newline // Represents "no value" for a std::optional. \newline // Use it to clear an optional or signal that a value is absent. \newline  \newline \#include \textless{}optional\textgreater{} \newline  \newline std::optional\textless{}int\textgreater{} age = 25;        // has a value \newline age = std::nullopt;                 // now has no value} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{5.377cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{5.377cm}}{\bf\textcolor{white}{std::unique\_ptr}}  \tn
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{5.377cm}}{std::unique\_ptr\textless{}T\textgreater{}; \newline  \newline .reset() // If the pointer points to an object it will destroy it and set it back to being a null pointer.} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{5.377cm}}{Declares a pointer of a certain type. It starts as a null pointer.}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{5.377cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{5.377cm}}{\bf\textcolor{white}{std::lock\_gaurd}}  \tn
\SetRowColor{white}
\mymulticolumn{1}{x{5.377cm}}{std::lock\_guard\textless{}MutexType\textgreater{} \seqsplit{objectName(mutexInstance);}% Row Count 2 (+ 2)
} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{5.377cm}}{A wrapper that takes a mutexInstance and ensures that is is locked and automatically unlocked when it goes out of scope.}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{5.377cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{5.377cm}}{\bf\textcolor{white}{std:string}}  \tn
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{5.377cm}}{std::string name = "\textless{}text\textgreater{}"; \newline  \newline .clear() // Sets the string back to "". \newline  \newline .c\_str() // Converts a std::string to a const char* (C-style string).} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{5.377cm}}{Make a string object that is dynamic and has methods associated with it. This is different than a primitive string.}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{5.377cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{5.377cm}}{\bf\textcolor{white}{std::optional\textless{}T\textgreater{}}}  \tn
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{5.377cm}}{std::optional\textless{}int\textgreater{} val = std::nullopt; // val holds nothing \newline val = 42;                               // val now holds 42} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{5.377cm}}{A wrapper that holds either a value of type T or nothing (std::nullopt). Use it as a return type when a function might produce no result, instead of returning a sentinel like -1 or nullptr.}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{5.377cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{5.377cm}}{\bf\textcolor{white}{std::thread}}  \tn
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{5.377cm}}{std::thread t(callable, arg1, arg2, arg3, ...); \newline  \newline // Methods \newline .joinable() // Returns a bool determining if a thread can eventually be joined \newline  \newline .join() // Block the calling thread until this thread completes} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{5.377cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{5.377cm}}{\bf\textcolor{white}{std::queue}}  \tn
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{5.377cm}}{std::queue\textless{}dataType\textgreater{} \newline  \newline // Returns the first item in the queue \newline .front() \newline  \newline // Removes the first item from the queue \newline .pop()} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{5.377cm}}{Creates a queue data structure for holding information}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{5.377cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{5.377cm}}{\bf\textcolor{white}{std::unique\_lock}}  \tn
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{5.377cm}}{// std::uniquelock is a scoped mutex wrapper that  \newline // automatically unlocks on destruction. \newline  \newline // std::unique\_lock is a scoped mutex wrapper that automatically unlocks on destruction. \newline // Unlike lock\_guard, it can unlock and re-lock mid-scope, which is required by \seqsplit{condition\_variable::wait()}. \newline  \newline std::unique\_lock\textless{}std::mutex\textgreater{} lock(mtx); \newline cv.wait(lock, {[}this{]} \{ return ready; \});} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{5.377cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{5.377cm}}{\bf\textcolor{white}{std::getenv}}  \tn
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{5.377cm}}{const char{\emph{ path = std::getenv("PATH"); \newline  \newline if (path) \{ \newline     std::string path\_string = path;  // safe to use \newline \}  \newline  \newline // or with a fallback \newline const char}} value = std::getenv("MY\_VAR"); \newline std::string result = value ? value : "";  // empty string if not set} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{5.377cm}}{Reads the value of an environment variable by name. \newline  \newline Returns a const char* to the value string, or nullptr if the variable doesn't exist. \newline  \newline Always check for nullptr before using the result to avoid crashes.}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{5.377cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{5.377cm}}{\bf\textcolor{white}{\seqsplit{std::memory\_order\_relaxed}}}  \tn
\SetRowColor{white}
\mymulticolumn{1}{x{5.377cm}}{\seqsplit{std::memory\_order\_relaxed}% Row Count 1 (+ 1)
} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{5.377cm}}{A value of a enum that signals that the compiler and CPU that it is allowed to reorder an operation relative to when the code was written in the most optimized way it thinks it should.}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{5.377cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{5.377cm}}{\bf\textcolor{white}{\seqsplit{std::memory\_order\_released}}}  \tn
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{5.377cm}}{std:memory\_order\_release} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{5.377cm}}{This is an memory\_order enum flag that is used to suggest an atomic object can only perform an operation if every line above it has already ran.}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{5.377cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{5.377cm}}{\bf\textcolor{white}{std:condition\_variable}}  \tn
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{5.377cm}}{std:condition\_variable \textless{}variableName\textgreater{}; \newline  \newline // Method to force a thread to wait. If false is returned then the thread waits. \newline .wait(lock, {[}this{]} \{ return someCondition; \}); \newline  \newline // Method to wake up all sleeping threads \newline .notify\_all()  \newline  \newline // Just notifies one thread.  \newline // The one chosen can't be determined ahead of time. \newline // They are usually all lined up to do the same thing. \newline .notify\_one()} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{5.377cm}}{This will force the thread to sleep that was holding a unique lock. It is only woken up once .notify\_all() or .notify\_one() is called. These commands wake up the lock and check the conditional in wait(). If it evaluates to true it will proceed. If false, it will go back to sleep.}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{5.377cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{5.377cm}}{\bf\textcolor{white}{std::mutex}}  \tn
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{5.377cm}}{std:mutex mutexInstance \newline  \newline mutexInstance.lock() // Lock the process for the thread \newline mutexInstance.unlock() // Unlock the process for the thread.} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{5.377cm}}{This creates a mutexInstance. Has the ability to create a lock and unlock mechanism over processes. This prevents certain processes from happening simultaneously more than once.}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{5.377cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{5.377cm}}{\bf\textcolor{white}{std::atomic}}  \tn
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{5.377cm}}{std::atomic\textless{}T\textgreater{} name \{ initial\_value \}; \newline  \newline // Methods \newline .store(value, ordering)  // writes a new value to the atomic object.  An enum value from memory\_order  \newline  \newline .load(ordering) // Reads that value so that it can be used by other processes} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{5.377cm}}{std::atomic\textless{}T\textgreater{} wraps any type T and guarantees that reading and writing to it from multiple threads is always safe. Without it, two threads touching the same variable simultaneously is undefined behaviour in C++. It essentially puts a protection around the variable so every read and write is always a clean, complete operation.}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{5.377cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{5.377cm}}{\bf\textcolor{white}{std::ofstream}}  \tn
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{5.377cm}}{std::ofstream my\_file("file.txt"); \newline  \newline my\_file \textless{}\textless{} "some text" \textless{}\textless{} std::endl; \newline my\_file \textless{}\textless{} "more text" \textless{}\textless{} std::endl;} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{5.377cm}}{Opens a file for writing, creating it if it doesn't exist. \newline  \newline Writing to it works just like std::cout using the \textless{}\textless{} operator. \newline  \newline The file is automatically closed when the object goes out of scope.}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}


% That's all folks
\end{multicols*}

\end{document}