Everand Logo

Welcome to Everand!

  • Discover millions of ebooks, audiobooks, and so much more with a free trial

    Only $11.99/month after trial. Cancel anytime.

    C++17 Standard Library Quick Reference: A Pocket Guide to Data Structures, Algorithms, and Functions
    C++17 Standard Library Quick Reference: A Pocket Guide to Data Structures, Algorithms, and Functions
    C++17 Standard Library Quick Reference: A Pocket Guide to Data Structures, Algorithms, and Functions
    Ebook610 pages4 hours

    C++17 Standard Library Quick Reference: A Pocket Guide to Data Structures, Algorithms, and Functions

    By Peter Van Weert and Marc Gregoire

    ()

    Read preview

    About this ebook

    This quick reference is a condensed guide to the essential data structures, algorithms, and functions provided by the C++17 Standard Library. It does not explain the C++ language or syntax, but is accessible to anyone with basic C++ knowledge or programming experience. Even the most experienced C++ programmer will learn a thing or two from it and find it a useful memory-aid. 
    It is hard to remember all the possibilities, details, and intricacies of the vast and growing Standard Library. This handy reference guide is therefore indispensable to any C++ programmer. It offers a condensed, well-structured summary of all essential aspects of the C++ Standard Library. No page-long, repetitive examples or obscure, rarely used features. Instead, everything you need to know and watch out for in practice is outlined in a compact, to-the-point style, interspersed with practical tips and well-chosen, clarifying examples. 
    This new edition is updated to include all Standard Library changes in C++17, including the new vocabulary types std::string_view, any, optional, and variant; parallel algorithms; the file system library; specialized mathematical functions; and more.

    What You Will Learn
    • Gain the essentials that the C++ Standard Library has to offer
    • Use containers to efficiently store and retrieve your data
    • Inspect and manipulate your data with algorithms 
    • See how lambda expressions allow for elegant use of algorithms
    • Discover what the standard string class provides and how to use it
    • Write localized applications
    • Work with file and stream-based I/O
    • Prevent memory leaks with smart pointers
    • Write safe and efficient multi-threaded code using the threading libraries

    Who This Book Is For
    All C++ programmers, irrespective of their proficiency with the language or the Standard Library. A secondary audience is developers who are new to C++, but not new to programming, and who want to learn more about the C++ Standard Library in a quick, condensed manner.
    LanguageEnglish
    PublisherApress
    Release dateJul 31, 2019
    ISBN9781484249239
    C++17 Standard Library Quick Reference: A Pocket Guide to Data Structures, Algorithms, and Functions

    Read more from Peter Van Weert

    Related to C++17 Standard Library Quick Reference

    Related ebooks

    Programming For You

    View More
    View More

    Related podcast episodes

    Related articles

    • Article

      Enhance GIMP With Must-have Plugins

      Apr 4, 2023

      Credit: http://gimp.org Karsten Günther loves to extend his GIMP installations with useful plugins. And playing with the new tools… Many of the most important plugins presented here are quite old, but they are still maintained and sometimes even deve

      9 min read

    • Article

      Rokoko Studio 2.0

      Feb 23, 2021

      Rokoko Studio 2.0
      1 min read

    • Article

      We Need an FDA For Algorithms

      Nov 1, 2018

      In the introduction to her new book, Hannah Fry points out something interesting about the phrase “Hello World.” It’s never been quite clear, she says, whether the phrase—which is frequently the entire output of a student’s first computer program—is

      10 min read

    • Article

      Rise Of The Robots

      Jan 12, 2021

      Rise Of The Robots
      7 min read

    • Article

      Lightning Strikes

      Apr 14, 2020

      Lightning Strikes
      3 min read

    • Article

      The LXF Shell In… The Redirection Redemption

      Feb 6, 2024

      OUR EXPERT Ferenc Deák is sure that the usual suspects of programming languages fit for writing a shell have been exhausted, so he sticks to C++. The code for the LXF Shell can still be found at https://github. com/fritzone/lxf-shell. Previously in o

      10 min read

    • Article

      GO Inside Parsing – How Go Handles The Code

      Jul 30, 2019

      This tutorial has two aspects: a theoretical one and a practical one. In the theoretical part, you will learn about parsing, grammar and regular expressions; this is how languages are built and therefore understood in terms of construction and usage.

      8 min read

    • Article

      Direct From the Source

      Oct 22, 2019

      Direct From the Source
      8 min read

    • Article

      HotPicks

      Jun 4, 2019

      HotPicks
      12 min read

    • Article

      Microcontrollers In Amateur Radio

      May 1, 2022

      When you hit the compile button for your compiler, there’s a whole bunch of stuff that takes place that isn’t obvious while the code compiles. In general terms, the C compiler: 1) invokes a preprocessor pass on the code;2) performs syntax/semantic ch

      4 min read

    • Article

      The Body Syntonic

      Aug 23, 2022

      The Body Syntonic
      4 min read

    • Article

      Revealing The Shell Behind The Shell

      Mar 5, 2024

      Ferenc Deák sees no way back from the C++ mayhem he brought upon readers with this quick and dirty shell, so you just have to accept it. C++. The code for the shell can still be found at https://github. com/fritzone/lxf-shell. In the first three part

      11 min read

    • Article

      Next-gen Terminals

      Jan 12, 2021

      Next-gen Terminals
      9 min read

    • Article

      Language Support

      Jul 28, 2020

      Language Support
      1 min read

    • Article

      Evolution Of Coding

      Jul 25, 2023

      Evolution Of Coding
      9 min read

    • Article

      Text Docs To Rich Docs

      Dec 17, 2019

      Text Docs To Rich Docs
      6 min read

    • Article

      CudaText

      Jul 25, 2023

      CudaText
      2 min read

    • Article

      Write A Linux Shell From Scratch

      Dec 12, 2023

      Part One! Don’t miss next issue, subscribe on page 16! Ferenc Deak wanted to use Malbolge to create a Linux shell, but after several days in hell, he quickly came to his senses and continued the project in C++. Not that there is a huge difference… E

      9 min read

    • Article

      Extensibility

      Jun 30, 2020

      Since it’s KDE’s flagship file manager, Dolphin is meant to do everything it needs to without modification. Still, you can find various service menus in the KDE store, which are easy enough to install. Common applications will integrate nicely anyway

      1 min read

    • Article

      HotPicks

      Sep 22, 2020

      HotPicks
      12 min read

    Related categories

    Reviews for C++17 Standard Library Quick Reference

    0 ratings

    0 ratings0 reviews

    What did you think?

    Tap to rate

    Review must be at least 10 words

      Book preview

      C++17 Standard Library Quick Reference - Peter Van Weert

      © Peter Van Weert and Marc Gregoire 2019

      Peter Van Weert and Marc GregoireC++17 Standard Library Quick Referencehttps://doi.org/10.1007/978-1-4842-4923-9_1

      1. Numerics and Math

      Peter Van Weert¹  and Marc Gregoire²

      (1)

      Kessel-Lo, Belgium

      (2)

      Meldert, Belgium

      Common Mathematical Functions

      The header defines an extensive collection of common math functions in the std namespace. Unless otherwise specified, all functions are overloaded to accept all standard numerical types, with the following rules for determining the return type:

      If all arguments are float, the return type is float as well. Analogous for double and long double inputs.

      If mixed types or integers are passed, these numbers are converted to double, and a double is returned as well. If one of the inputs is a long double, long double is used instead.

      Basic Functions

      Exponential and Logarithmic Functions

      Power Functions

      Trigonometric and Hyperbolic Functions

      provides all basic trigonometric (sin(), cos(), tan(), asin(), acos(), atan()) and hyperbolic functions (sinh(), cosh(), tanh(), asinh(), acosh(), atanh()). All angles are expressed in radians.

      The lesser-known trigonometric function atan2() is available as well. You use it to compute the angle between a vector (x, y) and the positive X axis. atan2(y, x) is similar to atan(y / x) except that its result correctly reflects the quadrant the vector is in (and that it also works if x is zero). Essentially, by dividing y by x in atan(y / x), one loses information regarding the sign of x and y.

      Integral Rounding of Floating-Point Numbers

      Floating-Point Manipulation Functions

      Classification and Comparison Functions

      gcd/lcm ../images/417649_2_En_1_Chapter/417649_2_En_1_Figc_HTML.gif

      The functions gcd() and lcm() compute the greatest common divisor and least common multiple, respectively. They are defined as follows:

      template

      constexpr std::common_type_t gcd(M, N);

      template

      constexpr std::common_type_t lcm(M, N);

      Both M and N must be integer types. As explained in Chapter 2, std::common_type_t is a so-called type trait, which in this case results in a type that both M and N can implicitly be converted to. Concretely, the common type of two integer types M and N is determined by the following rules (applied in order):

      If N and M are equal, their common type is that same type as well.

      If N and M are both smaller than int, their common type is int.

      If the size of N and M differs, their common type is the largest type.

      Otherwise, the common type is the one that is unsigned.

      Error Handling

      The mathematical functions from can report errors in two ways depending on the value of math_errhandling (defined in , although not in the std namespace). It has an integral type and can have one of the following values or their bitwise OR combination:

      MATH_ERRNO: Use the global errno variable (see Chapter 8).

      MATH_ERREXCEPT: Use the floating-point environment, , not further discussed in this book.

      Special Mathematical Functions ../images/417649_2_En_1_Chapter/417649_2_En_1_Figd_HTML.gif

      C++17 adds a collection of specialized mathematical functions. All of these are available in multiple overloads. In the following table, the functions without an asterisk always return a double. For the functions marked with an asterisk, the return type is always double, unless one of its arguments is a long double, then the return type is long double as well.

      Additionally, there are two extra versions of each function with a postfix f or l. These additional functions accept floats and return a float (f postfix), or accept long doubles and return a long double (l postfix). For example, assoc_laguerre(), assoc_laguerref(), and assoc_laguerrel().

      Explaining all the details of these mathematical functions falls outside the scope of this book. The following table just shows the mathematical formula for each function. Please consult a mathematical reference for more details.

      Note

      At the time of writing, libc++, the implementation that ships with the Clang compiler, has not implemented these special mathematical functions yet.

      Bessel Functions

      Polynomials

      Elliptic Integrals

      Exponential Integrals

      Error Functions

      Gamma Functions

      Beta Functions

      Zeta Functions

      Minimum, Maximum, and Clamping

      The Standard Library provides a set of functions related to finding the minimum and maximum of two or more values. In the following function definitions, T is the element type, and the optional Compare parameter is a function object to be used to compare elements. T can be any type, not just a fundamental type. If no Compare function object is specified, operator< is used. The function object accepts two parameters and returns true if the first argument is less than the second, false otherwise. The ordering imposed must be a strict weak ordering, just as with the default operator<:

      constexpr const T& min(const T& x, const T& y[, Compare comp])

      constexpr const T& max(const T& x, const T& y[, Compare comp])

      Returns a reference to the minimum or maximum of two values, or the first value if they are equal.

      constexpr T min(initializer_list list[, Compare comp])

      constexpr T max(initializer_list list[, Compare comp])

      Returns a copy of the minimum or maximum value in a given initializer_list (discussed in Chapter 2), or a copy of the leftmost minimum or maximum if there are several elements equal to this extreme. Allows expressions of the form std::min({ x, y, z }) to quickly determine the extreme of a limited number of elements.

      constexpr pair

         minmax(const T& x, const T& y[, Compare comp])

      Returns a pair containing references to the minimum and maximum of two values, in that order. If x and y are equal, pair(x, y) is returned.

      constexpr pair minmax(initializer_list list[, Compare comp])

      Returns a pair containing a copy of the minimum and maximum values in an initializer_list, in that order. If several elements are equal to the minimum, then a copy of the leftmost one is returned; if several are equal to the maximum, a copy of the rightmost is returned.

      C++17 also adds the following std::clamp() function which can be used to clamp, or bound, a given value to a given range ../images/417649_2_En_1_Chapter/417649_2_En_1_Fige_HTML.gif :

      constexpr const T&

         clamp(const T& value, const T& low, const T& high[, Compare comp])

      This function returns the following:

      A reference to low if value < low

      A reference to value if low ≤ value ≤ high

      A reference to high if high < value

      Fixed-Width Integer Types

      The header contains platform-dependent type aliases for integer types with different and more portable width requirements than the fundamental integer types:

      std::(u)intX_t, an (unsigned) integer of exactly X bits (X= 8, 16, 32, or 64). Present only if supported by the target platform.

      std::(u)int_leastX_t, the smallest (unsigned) integer type of at least X bits (X= 8, 16, 32, or 64).

      std::(u)int_fastX_t, the fastest (unsigned) integer type of at least X bits (X= 8, 16, 32, or 64).

      std::(u)intmax_t, the largest supported (unsigned) integer type.

      std::(u)intptr_t, (unsigned) integer type large enough to hold a pointer. These type aliases are optional.

      The header further defines macros for the minimum and maximum values of these (and some other) types, for instance, INT_FAST_8_MIN and INT_FAST_8_MAX for std::int_fast8_t. The standard C++ way of obtaining these values though is with the facilities of discussed next.

      Arithmetic Type Properties

      The std::numeric_limits template class offers a multitude of static functions and constants to obtain properties of a numeric type T. It is specialized for all fundamental numeric types, both integral and floating-point, and can hence be used to inspect properties of all their aliases as well, such as size_t or those of the previous section. The various members offered are listed as follows. Functions are only and always used to obtain a T value, whereas Booleans, ints, and enum values are defined as constants.

      The following members are relevant only for floating-point types. For integer types, they always equal or return zero:

      Complex Numbers

      The std::complex type, defined for at least T equal to float, double, and long double, is used to represent complex numbers as follows:

      ../images/417649_2_En_1_Chapter/417649_2_En_1_Figf_HTML.png

      All expected operators are available: +, -, *, /, +=, -=, *=, /=, =, ==, and !=, including overloads with a floating-point operand (which is then treated as a complex number with a zero imaginary part), and the >> and << operators for interaction with the streams of Chapter 5.

      The std::literals::complex_literals namespace defines convenient literal operators for creating complex numbers: i, if, and il, creating values with T equal to double, float, and long double, respectively. Using this, the c value in the previous example could have been created with ‘auto c = 1.f + 2if;’.

      The header furthermore defines the complex equivalents of several of the basic math functions seen earlier, that is, pow(), sqrt(), exp(), log(), and log10(), as well as all trigonometric and hyperbolic functions, that is, sin(), cos(), tan(), asin(), acos(), atan(), sinh(), cosh(), tanh(), asinh(), acosh(), and atanh().

      Besides these, the following complex-specific non-member functions exist:

      Compile-Time Rational Numbers

      The std::ratio type template from the header represents a rational number. What makes it peculiar is that it does so at the type level, rather than the usual value level (std::complex numbers are an example of the latter). While ratio values can be default-constructed, this is rarely the intention. Rather, the ratio type is generally used as type argument for other templates. For example, the std::chrono::duration> template explained in Chapter 2 may be instantiated as duration> to represent a duration of milliseconds, or as duration> for a duration of minutes.

      Convenience type aliases exist for all standard SI ratios: std::kilo, for instance, is defined as ratio<1000>, and std::centi as ratio<1,100>. The full list is atto (10−18), femto (10−15), pico (10−12), nano (10−9), micro (10−6), milli (10−3), centi (10−2), deci (10−1), deca (10¹), hecto (10²), kilo (10³), mega (10⁶), giga (10⁹), tera (10¹²), peta (10¹⁵), and exa (10¹⁸), and for platforms with an integer type that is wider than 64 bit yocto (10−24), zepto (10−21), zetta (10²¹), and yotta (10²⁴).

      All ratio types define two static members: num and den, containing the numerator and denominator of the rational number, but after normalization. The ratio’s type member equals the ratio type of this normalized rational number.

      Arithmetic operations with ratios are possible, but it is again at the type level: the std::ratio_add template, for instance, takes two ratio types as template arguments and evaluates to the type that corresponds to the sum of these rational numbers. The ratio_subtract, ratio_multiply, and ratio_divide templates are analogous. To compare two ratio types, similar ratio_xxx templates are provided with xxx either equal, not_equal, less, less_equal, greater, or greater_equal.

      The following example clarifies ratio arithmetic (, discussed in Chapter 2, must be included when using the typeid operator):

      ../images/417649_2_En_1_Chapter/417649_2_En_1_Figg_HTML.png

      Random Numbers

      Enjoying the preview?
      Page 1 of 1