Шпаргалка: 2018

пятница, 5 октября 2018 г.

Указатель на нестатическую функцию-член класса / non-static function member pointer

Отличий от обычного указателя на фунцию только два: как объявлять и как вызывать. Лучше всего пояснить на примере:

#include <iostream>
#include <string>

class MyClass
{
public:
    MyClass(int i) : m_i(i) {}
    void func() { std::cout << "m_i = " << m_i << "\n"; }

private:
    int m_i;
};

int main()
{
    MyClass obj1(1);
    MyClass obj2(2);
    void (MyClass::*fptr)() = &MyClass::func; // define and initialize function pointer
    obj1.func();
    ((&obj2)->*fptr)(); // use function pointer via an object pointer
}

Однако, с помощью более свежих версий C++ это можно упростить:

#include <iostream>
#include <string>

class MyClass
{
public:
    MyClass(int i) : m_i(i) {}
    void func() { std::cout << "m_i = " << m_i << "\n"; }

private:
    int m_i;
};

int main()
{
    MyClass obj1(1);
    MyClass obj2(2);
    auto fptr = &MyClass::func; // define and initialize function pointer
    obj1.func();
    ((&obj2)->*fptr)(); // use function pointer via an object pointer
}

Приятно, что можно забыть этот синтаксис указателя на функцию и отдать эту работу компилятору.

пятница, 20 апреля 2018 г.

Поиск функцией std::find_if по ассоциативному спику std::map / Searching by std::find_if on std::map

Иногда надо перебрать все элементы ассоциативного списка и можно это сделать традиционно, с помощью цикла for.
Но есть более изящное решение с использованием возможностей C++11. Допустим у нас есть ассоциативный список типа std::unordered_map<int, MyType>.
Вот как это можно сделать:

// very clear lambda statement
auto pred = [sVal](const std::pair<int, MyType>& x) { return x.second.val == sVal; }; 
const auto it = std::find_if(myMap.begin(), myMap.end(), pred);

Но есть один недостаток: надо явно указывать тип элемента контейнера, который мы перебираем, в лямбда-выражении. Но можно сделать так, чтобы компилятор сам определал это:

// does the same, but looks much smarter ^_^
auto pred = [sVal](const decltype(myMap.begin())::value_type& x) { return x.second.val == sVal; }; 
const auto it = std::find_if(myMap.begin(), myMap.end(), pred);

Получилось боле громоздко, но зато более универсально.

четверг, 5 апреля 2018 г.

Определить разрядность процессора во время компиляции / Detect CPU bit capacity during compiling

Если, например, у нас есть две версии функции: одна для 32-разрадных процессоров и вторая для 64-разрядных процессоров. И мы хотим использовать ту, которая подходит для нашей архитектуры процессора.
Первый путь это использовать директивы препроцессора (дефайны):

void do_some()
{
#if defined(_IS_64_BIT_CPU)
    do_some_64();
#endif

#if defined(_IS_32_BIT_CPU)
    do_some_32();
#endif
}

Иногда, когда мы не имеем таких директив, можно определить разрядность процесора по размеру указателя (у 64-битных процессоров он очевидно равен 8 байтам, и соотсвественно у 32-разрядных процессоров он равен 4 байтам):

void do_some()
{
if(sizeof(void*) == 8)
    do_some_64();

if(sizeof(void*) == 4)
    do_some_32();
}

Это работающее решение, но нам не нужна одна из веток, т.е. мы хотим ее исключить на этапе компиляции. Можно с помощью C++11 написать такой код:

template<typename T = void*>
std::enable_if_t<sizeof(T) == 8, void> do_some()
{
    do_some_64();
}

template<typename T = void*>
std::enable_if_t<sizeof(T) == 4, void> do_some()
{
    do_some_32();
}

Теперь на этапе компиляции будет включено только одно из определений функции - то, которое нам нужно.
Хотя, проще для чтения все же вариант с дефайнами, но второй вариант более универсален.

пятница, 5 октября 2018 г.