C++17

January 16, 2022

C++20: semaphores

There are two types of semaphores:

std::binary_semaphore
std::counting_semaphore

Semaphore alllows multiple access to shared resources. Unlike std::mutex, semaphore can be locked in one thread, and unlocked in another.

std::binary_semaphore

std::binary_semaphore is just alias for std::counting_semaphore.

using binary_semaphore = std::counting_semaphore<1>;

std::counting_semaphore

Semaphore has in implementation counter, which defines, how many threads can enter to locked section.

For example:

std::counting_semaphore<3> sem{ 0 };

In this case, maximum counter values can be 3. And counter is initialized to 0.

acquire() – decrements value, and if counter is already 0, will block until counter is larger than 0.

release() – increments counter

For example:

#include <iostream>

#include <thread>

#include <semaphore>

std::counting_semaphore<1> sem{ 0 };

void thread_func1()

{

sem.acquire();

std::cout << "analyze data()" << std::endl;

}

void thread_func2()

{

std::cout << "getting data()" << std::endl;

sem.release();

}

int main()

{

std::jthread thread1{ thread_func1 };

std::jthread thread2{ thread_func2 };

}

In this case, first we need to wait for data in first thread.

December 13, 2021

In C++20 there is new thread type std::jthread, which means joined thread. Previous std::thread if destructor will be called without join() function, in this case will be called std::terminate(). But in std::jthread in destructor is called join() function.

std::jthread object is located in <thread> header.

void _internal_thread()
{

}

int main()
{
	std::jthread _thread{ _internal_thread };
	// no exception here
}

std::stop_token

Also in std::jthread there is possibility to stop thread when it’s needed. Thread function can have parameter std::stop_token which can be checked in while loop inside thread.

For example:

#include <iostream>
#include <thread>

using namespace std::chrono_literals;

void _internal_thread(std::stop_token stop)
{
	while (!stop.stop_requested())
	{
		std::cout << "work..." << std::endl;
		std::this_thread::sleep_for(0.5s);
	}
}

int main()
{
	std::jthread _thread{ _internal_thread };
	std::this_thread::sleep_for(2s);
}

In case when we need to pass additional parameters to thread function, std::stop_token need to be first parameter.

void _internal_thread(std::stop_token stop, int x) // ok
{
	while (!stop.stop_requested())
	{
		std::cout << "work..." << std::endl;
		std::this_thread::sleep_for(0.5s);
	}
}

// error
void _internal_thread(int x, std::stop_token stop)
{
	while (!stop.stop_requested())
	{
		std::cout << "work..." << std::endl;
		std::this_thread::sleep_for(0.5s);
	}
}

If needed we can get std::stop_source and call request_stop() when it needed.

std::jthread _thread{ _internal_thread, 10 };

bool result = _thread.get_stop_source().request_stop();

std::stop_callback

Also there is new std::stop_callback object, which can execute in case when request_stop() is called.

For example:

#include <iostream>
#include <thread>

using namespace std::chrono_literals;

void _internal_thread(std::stop_token stop, int x)
{
	while (!stop.stop_requested())
	{
		std::cout << "work..." << std::endl;
		std::this_thread::sleep_for(0.5s);
	}
}

int main()
{
  std::jthread _thread{ _internal_thread, 10 };

  std::stop_callback 
  _stop{_thread.get_stop_token(), []() {
     std::cout << "show stop" << std::endl;
  }};

  _thread.get_stop_source().request_stop();

  std::this_thread::sleep_for(2s);
}

December 20, 2018

C++17: global changes

Exception specification as part of the type system

A prvalue of type “pointer to noexcept function” can be converted to a prvalue of type “pointer to function”. The result is a pointer to the function. A prvalue of type “pointer to member of type noexcept function” can be converted to a prvalue of type “pointer to member of type function”. The result points to the member function.

Example:

void (*p)() throw(int);
void (**pp)() noexcept = &p; // error: cannot convert to pointer to noexcept function
struct S { typedef void (*p)(); operator p(); };
void (*q)() noexcept = S(); // error: cannot convert to pointer to noexcept function

void (*p)() throw(int);

void (**pp)() noexcept = &p; // error: cannot convert to pointer to noexcept function

struct S { typedef void (*p)(); operator p(); };

void (*q)() noexcept = S(); // error: cannot convert to pointer to noexcept function

Continue reading “C++17: global changes”

December 20, 2018

C++17: Guaranted copy elision

From C++17 compilers are required to omit copy/move construction resulting in zero-copy pass-by-value semantics. Objects will be created directly in storage where they would copy/move.

In return statement when operand is prvalue:

T f() {
  return T();
}

f(); // only one call to default constructor of T

T f() {

return T();

}

f(); // only one call to default constructor of T

In the initialization of a variable, when initialization expression is a prvalue of the same type:

T x = T(T(f())); // only one call to default constructor of T, to initialize x

1	T x = T(T(f())); // only one call to default constructor of T, to initialize x

C++17 core language specification of prvalues and temporaries is fundamentally different from that of the earlier C++ revisions: there is no longer a temporary to copy/move from. Another way to describe C++17 mechanics is “unmaterialized value passing”: prvalues are returned and used without ever materializing a temporary.

Continue reading “C++17: Guaranted copy elision”

December 16, 2018

C++17: Deprecated features

Deprecate redeclaration of static constexpr class members

When inline variables are presented in C++17, static constexpr redeclaration is not needed.

struct A
{
  static constexpr int n = 5; // definition (declaration in C++ 2014)
};
 
const int A::n; // redundant declaration (definition in C++ 2014)

struct A

{

static constexpr int n = 5; // definition (declaration in C++ 2014)

};

const int A::n; // redundant declaration (definition in C++ 2014)

Deprecate C library headers

List of C libraries which are deprecated from C++17:

<ccomplex> – simply deleting the requirement for a <ccomplex> header is simpler, and may be better, than making it optional. Of course an implementation would not need to change in order to conform to the new state of affairs, but programs that use <ccomplex> instead of <complex> would cease to be strictly conforming.

<ctgmath> – simply includes header <ccomplex> and <cmath>

<cstdalign> – mentioned as pointless in C++

<cstdbool> – mentioned as pointless in C++

Continue reading “C++17: Deprecated features”

December 15, 2018

C++17: std::invoke & std::apply

std::invoke

std::invoke is used for calling function objects, like lambdas, methods, functions without knowing about type this function.

For example , before we needed to use pointer to function, pointer to method:

int qwe(int x)
{
  return x + 1;
}
class A {
public:
  void aaa(int x) {
    std::cout << x << std::endl;
  }
};

int main()
{
  int(*func)(int) = &qwe;
  void(A::*qwe)(int) = &A::aaa;
  func(2);
  A a;
  (a.*qwe)(2);
  return 0;
}

int qwe(int x)

{

return x + 1;

}

class A {

public:

void aaa(int x) {

std::cout << x << std::endl;

}

};

int main()

{

int(*func)(int) = &qwe;

void(A::*qwe)(int) = &A::aaa;

func(2);

A a;

(a.*qwe)(2);

return 0;

}

Continue reading “C++17: std::invoke & std::apply”

November 25, 2018February 11, 2019

C++17: std::shared_mutex, interface_sizes, void_t, std::bool_constant, logical operation metafunctions

Class shared_mutex

On some platforms shared_mutex is more effecient then shared_timed_mutex.

In C++17 was added shared_mutex.

Example of usage:

class MyCounter
{
public:
    int get() {
        std::shared_lock lock_(mutex_);
        return counter_;
    }
    void increment() {
        std::unique_lock lock_(mutex_);
        counter_++;
    }
    void reset() {
        std::unique_lock lock_(mutex_);
        counter_ = 0;
    }
private:
    std::shared_mutex mutex_;
    int counter_{ 0 };
};


int main()
{   
    MyCounter counter;
    std::mutex cout_mutex;
 
    auto lambda = [&counter, &cout_mutex]() {
        std::lock_guard lock_(cout_mutex);
        for (auto i = 0; i < 3; i++) {
            counter.increment();
            std::cout << counter.get() << std::endl;
        }
    };
 
    std::thread thread1(lambda);
    std::thread thread2(lambda);
 
    thread1.join();
    thread2.join();
 
    return 0;
}

class MyCounter

{

public:

int get() {

std::shared_lock lock_(mutex_);

return counter_;

}

void increment() {

std::unique_lock lock_(mutex_);

counter_++;

}

void reset() {

std::unique_lock lock_(mutex_);

counter_ = 0;

}

private:

std::shared_mutex mutex_;

int counter_{ 0 };

};

int main()

{

MyCounter counter;

std::mutex cout_mutex;

auto lambda = [&counter, &cout_mutex]() {

std::lock_guard lock_(cout_mutex);

for (auto i = 0; i < 3; i++) {

counter.increment();

std::cout << counter.get() << std::endl;

}

};

std::thread thread1(lambda);

std::thread thread2(lambda);

thread1.join();

thread2.join();

return 0;

}

Continue reading “C++17: std::shared_mutex, interface_sizes, void_t, std::bool_constant, logical operation metafunctions”

November 18, 2018

C++17: Modifications to existing features (Part 2)

Construction for values of fixed enums

Before C++17, variable of fixed enumeration was initialized like this:

enum class E: unsigned char{};
 
E e{E(5)};

enum class E: unsigned char{};

E e{E(5)};

if we will try to initialize like this:

E e{ 5 };

E e{ 5 };

we will have error: cannot convert ‘int’ to ‘E’ in initialization.

In C++17 it’s allowed to build.

Continue reading “C++17: Modifications to existing features (Part 2)”

November 18, 2018November 18, 2018

C++17: Modifications to existing features (Part 1)

Single-argument static_assert

In C++17 static_assert message was changed to optional, and it’s possible create static_assert without message.

For example:

template<typename T>
class A {
    static_assert(std::is_default_constructible_v<T>);
};
 
class X {
public:
    X(int) {}
};
 
int main()
{   
   A<X> a; // ERROR: static_assert failed
   return 0;
}

template<typename T>

class A {

static_assert(std::is_default_constructible_v<T>);

};

class X {

public:

X(int) {}

};

int main()

{

A<X> a; // ERROR: static_assert failed

return 0;

}

Continue reading “C++17: Modifications to existing features (Part 1)”

September 12, 2018

C++17: Core language features (part 2)

Inline variables

For now, it’s possible to specify variables as inline.

For example:

class B {
public:
  inline static const int x{ 10 };
};

class B {

public:

inline static const int x{ 10 };

};

it allows keep it only in a header, without adding to cpp static variable.

constexpr variables have implicit inline.

Continue reading “C++17: Core language features (part 2)”

Posts

C++20: semaphores

C++20: std::jthread

C++17: global changes

C++17: Guaranted copy elision

C++17: Deprecated features

C++17: std::invoke & std::apply

C++17: std::shared_mutex, interface_sizes, void_t, std::bool_constant, logical operation metafunctions

C++17: Modifications to existing features (Part 2)

C++17: Modifications to existing features (Part 1)

C++17: Core language features (part 2)