random things

inv: \R\setminus\{0\}\rightarrow\R \newline

inv(x) = \frac{1}x

double inv(double x)
{
  return 1.0 / x;
}

  double hmm = inv(0.0); // == ?

compile error
undefined behaviour
infinity
NaN

0 \notin D_{inv} \implies inv(0)\uparrow

preconditions and postconditions

inv: \R\setminus\{0\}\rightarrow\R \newline

inv(x) = \frac{1}x

double inv(double x)
{
  return 1.0 / x;
}

  double hmm = inv(0.0); // == ?

compile error
undefined behaviour
infinity
NaN

0 \notin D_{inv} \implies inv(0)\uparrow

double inv(double x) [[expects: i != 0.0]]
{
  return 1.0 / x;
}

contracts

C++20

#include <cassert>

double inv(double x)
{
  assert(x != 0);
  return 1.0 / x;
}

assertions

  double hmm = inv(0.0); // assertion failed

assertions

assert(condition)

static_assert(condition, message)

static_assert(condition)

preconditions
postconditions
invariants

condition

Integral types

char
short
int
long
long long

signed

unsigned

unsigned char

binary

decimal

signed char

decimal

11110011
--------
11101110
--------
00000000
--------

[0, 255]

[-128, 127]

Integral types

overflow: defined

overflow: undefined

bitwise and logical operations

NOT

and

or

xor

lshift

rshift

bitwise

logical

!a

a && b

a || b

~a

a & b

a | b

a ^ b

a << n

a >> n

(a != b)

alternative operator tokens

&&
&=
&
|
~
!
!=
||
|=
^
^=

and
and_eq
bitand
bitor
compl
not
not_eq
or
or_eq
xor
xor_eq

casts

c-style case

static_cast

reinterpret_cast

const_cast

dynamic_cast

ternary operator

x = condition ? true_value : false_value;

type ternary(bool condition, type true_value, type false_value)
{
  if (condition)
    return true_value;
  else
    return false_value;
}

x = ternary(condition, true_value, false_value);

\Leftrightarrow

ternary operator

int max(int a, int b)
{
  if (a < b)
  {
    return a;
  }
  else
  {
    return b;
  }
}

int max(int a, int b)
{
  return a < b ? a : b;
}

Comma operator

x = expression1, expression2, /* ..., */ expressionN;

expression1;
expression2;
/* ...; */
x = expressionN;

\Leftrightarrow

Comma operator

void print_pows(int n, int base)
{
    for (int i = 0, pow = 1; i < n; ++i)
    {
        std::cout << pow;
        pow *= base;
    }
}

void print_pows(int n, int base)
{
    for (int i = 0, pow = 1; i < n; ++i, pow *= base)
    {
        std::cout << pow;
    }
}

e p

x r

p o

r g

e r

s a

s m

i m

o i

n n

G

std::tuple<std::optional<float>, std::optional<float>>
quadric_expression(const float a, const float b, const float c)
{
    const float delta = b * b - 4 * a * c, 
           sqrt_delta = delta >= 0 ? sqrt(delta) : -1;
    return {
        delta >= 0 ? std::optional{(-b - sqrt_delta) / 2 * a} : std::nullopt,
        delta >  0 ? std::optional{(-b + sqrt_delta) / 2 * a} : std::nullopt
    };
}

std::tuple<std::optional<float>, std::optional<float>>
quadric_statement(const float a, const float b, const float c)
{
    const float delta = b * b - 4 * a * c;
    if (delta > 0)
    {
        const float sqrt_delta = sqrt(delta);
        const float x1 = (-b - sqrt_delta) / 2 * a;
        const float x2 = (-b + sqrt_delta) / 2 * a;
        return { x1, x2 };
    }
    else if (delta < 0)
    {
        return { std::nullopt, std::nullopt };
    }
    else // delta == 0
    {
        const float sqrt_delta = sqrt(delta);
        const float x1 = (-b - sqrt_delta) / 2 * a;
        return { x1, std::nullopt };
    }
}

type aliases

typedef type alias;

using alias = type;

\Leftrightarrow

type aliases

using int_ptr = int*;
using my_func_ptr = int*(*)(int, int);
using double_10_ar = double[10];

typedef int* int_ptr;
typedef int*(*my_func_ptr)(int, int);
typedef double double_10_ar[10];

\Leftrightarrow

template <typename T, size_t SIZE>
using raw_array = T[SIZE];

using namespace ns;
using namespace ns = long_namespace_name;

using namespace

auto

structured binding

variable type deduction

return type deduction

generic lamdas

abbreviated function templates

functions with trailing return type

decltype(auto)

non type template parameter with deduced type

auto

variable type deduction

auto msg = "Hello";
// const char*
  
auto x = fib();
// int

auto&& y = 3; 
// int&&

auto nums = std::vector{1, 2, 3, 4};
//std::vector<int>

auto begin = nums.begin();
//std::vector<int>::iterator

for (auto& element : nums) // int&
{
  element += 2;
}

structured binding

decltype(auto)

auto

struct vec2
{     
  float x, y;
} v{ 1.0, 2.0 };

auto [right, up] = v;
right += up;
// v.x == 1.0

auto& [right_ref, up_ref] = v;
right_ref += up_ref;
// v.x == (1.0 + 2.0)

structured binding

const int components[10] = { 1, 2, 3, 4 };
const auto& [x, y, z, w] = components;

struct divide_result
{
  int quotient;
  int remaineder;
}

divide_result
divide(int dividend, int divisor)
{
  assert(divisor != 0);

  return {
    dividend / divisor,
    dividend % divisor
  };
}

void use()
{
  auto result = divide(7, 3);
  int quot1 = divide.quotient,
      rmnd1 = result.remainder;

  int quot2, rmnd2;
  std::tie(quot2, rmnd2) = divide(7, 3);

  auto [quot3, rmnd3] = divide(7, 3);
}

std::map<std::string, int> ages = get_a();

int age_sum = 0;
for (const auto& [name, age] : ages)
{
  age_sum += age;
}

decltype(auto)

auto

auto x1 = get_int(); // int
auto x2 = get_int_ref(); // int
auto x3 = get_const_int_ref(); // int

auto& y1 = get_int(); // error!!!
auto& y2 = get_int_ref(); // int&
auto& y3 = get_const_int_ref(); // const int&

decltype(auto) z1 = get_int(); // int
decltype(auto) z2 = get_int_ref(); // int&
decltype(auto) z3 = get_const_int_ref(); // const int&

decltype(auto)

int get_int();
int& get_int_ref();
const int& get_const_int_ref();

enumerations

enum class VertexState
{
  Unvisited, Preordered, Postordered
};

std::vector<VertexState> vertices;

vertices[i] = VertexState::Unvisited;
vertices[i] = VertexState::Preordered;
vertices[i] = VertexState::Postordered;

#define Unvisited 0
#define Preordered 0
#define Postordered 0

std::vector<int> vertices;

vertices[i] = Unvisited;
vertices[i] = Preordered;
vertices[i] = Postordered;

enumerations

enum class Fruit : int
{
  Apple   /* = 0 */,
  Samsung /* = 1 */,
  Huawei  /* = 2 */,
  Xiaomi  /* = 3 */,
};

enum class Fruit : short
{
  Apple      = N,
  Samsung /* = N + 1 */,
  Huawei  /* = N + 2 */,
  Xiaomi  /* = N + 3 */,
};

enum /*class*/ Fruit
{
  Apple,
  Samsung,
  Huawei,
  Xiaomi,
};

enum /*class*/ Corp
{
  Apple, // error!!!
  Banana,
  Pear,
  Grape,
};

static_assert(static_cast<int>(Fruit::Apple) == 0);
static_assert(static_cast<int>(Fruit::Samsung) == 1);
static_assert(static_cast<int>(Fruit::Huawei) == 2);
static_assert(static_cast<int>(Fruit::Xiaomi) == 3);

static_assert(static_cast<Fruit>(0) == Fruit::Apple);
static_assert(static_cast<Fruit>(1) == Fruit::Samsung);
static_assert(static_cast<Fruit>(2) == Fruit::Huawei);
static_assert(static_cast<Fruit>(3) == Fruit::Xiaomi);

struct s {
  enum class e {
  }
}

#include <iostream>

int main()
{
  std::cout << "Welcome to The Useless Command!\n"
  			<< "Do you want to see The Useless Message? [y/n]";
  char c;
  std::cin >> c;
  if (c == 'y' || c == 'Y')
  {
    std::cout << "You are witnessing: \"The Useless Message\"\n";
  }
  else if (c == 'n' || c == 'N')
  {
    std::cout << "Goodbye, then...\n";
  }
  else
  {
    std::cout << "Sorry, I didn't get that.\n";
  }
}

switch

#include <iostream>

int main()
{
  std::cout << "Welcome to The Useless Command!\n"
  			<< "Do you want to see The Useless Message? [y/n]";
  char c;
  std::cin >> c;
  switch (c)
  {
  case 'y': [[fallthrough]];
  case 'Y':
    std::cout << "You are witnessing: \"The Useless Message\"\n";
    break;
  case 'n': [[fallthrough]];
  case 'N':
    std::cout << "Goodbye, then...\n";
    break;
  default:
    std::cout << "Sorry, I didn't get that.\n";
    break;
}

switch

switch

#include <iostream>

int main()
{
  std::cout << "Welcome to The Useless Command!\n"
  			<< "Do you want to see The Useless Message? [y/n]";
  string s;
  std::cin >> s;
  if (s == "y" || s == "Y" || s == "yes" || s = "Yes")
  {
    std::cout << "You are witnessing: \"The Useless Message\"\n";
  }
  else if (s == "n" || s == "N" || s == "no || s = "No)
  {
    std::cout << "Goodbye, then...\n";
  }
  else
  {
    std::cout << "Sorry, I didn't get that.\n";
  }
}

switch

#include <iostream>

int main()
{
  std::cout << "Welcome to The Useless Command!\n"
  			<< "Do you want to see The Useless Message? [y/n]";
  string s;
  std::cin >> s;
  if (s == "y" || s == "Y" || s == "yes" || s = "Yes")
  {
  	std::cout << "You are witnessing: \"The Useless Message\"\n"
  }
  else if (s == "n" || s == "N" || s == "no || s = "No)
  {
    std::cout << "Goodbye, then...\n";
  }
  else
  {
    std::cout << "Sorry, I didn't get that.\n";
  }
}

switch(s)

switch

char c;
switch(c) {...}

int n;
switch(n) {...}

enum class Fruit 
{
	Apple,
    Samsung, 
    ...
};

Fruit n;
switch(n)
{
case Fruit::Apple:
  apple_tree().harvest();
  break;
case Fruit::Samsung:
  ...
default:
  ...
}

unsigned long n;
switch(n) {...}

bool v;
switch(v) {...}

random things

Random Things

By Jan Bielak

Random Things

A presentation about many different C++ features. It is presented here: https://www.youtube.com/watch?v=xvxlPMNQuRM .

Jan Bielak

janbielak.com

random things

preconditions and postconditions

preconditions and postconditions

contracts

C++20

assertions

assertions

Integral types

Integral types

bitwise and logical operations

NOT

and

or

xor

lshift

rshift

bitwise

logical

alternative operator tokens

casts

ternary operator

ternary operator

Comma operator

Comma operator

e p

x r

p o

r g

e r

s a

s m

i m

o i

n n

G

type aliases

type aliases

enumerations

enumerations

random things

Random Things

More from Jan Bielak