Showing posts with label стандартная библиотека. Show all posts
Showing posts with label стандартная библиотека. Show all posts

Tuesday, November 26, 2019

Обратные вызовы и лямбда выражения в си++

Отец плюсов говорит - “Не совершенствуйте язык, а совершенствуйте его применение”. Давайте так и поступим. Нам пригодилось бы передавать функцию в другую функцию в качестве параметра, т.е. как переменную. Еще много чего, но давайте потерпим. Оказывается, так можно. Как и любая переменная, функция имеет свой тип, т.е. область в памяти, определенного размера, достаточного для хранения информации о том, как выглядит наша функция (что возвращает и какие параметры принимает). Имея указатель на эту область, мы можем выполнить наши ранее описанные задачи. Изменить значению такого указателя, можно просто присвоив ему имя функции, которая нам подходит. А выполнить функцию через указатель можно с помощью добавления к имени указателя круглых скобок.

Для примера функция void foo() имеет тип void(*)(), чтобы объявить и проинициализировать указатель такого типа, нужно написать void (*fPtr)() = nullptr, где fPtr и есть имя указателя. Далее можно отследить по коду. Погодите, мы углубились в язык, но совсем забыли про применение. Где же можно применить такие чудо-возможности? Например, для хранения коллекции разных действий (функций), или, например, для получения обратного вызова. Обратный вызов – это вызов функции, которая в свою очередь должна вызвать функцию, полученную в качестве параметра. Часто это может быть полезно, например, запуская метод click() для кнопки, и передавая ему действие, которое должно быть выполнено при нажатии на кнопку.

Еще одно полезное применение можно получить, для передачи в коллекцию действия, которое мы хотим выполнить над каждым элементом коллекции. В стандартной библиотеке есть множество вспомогательных алгоритмов, например, сортировка, которая уже реализует метод сравнения элементов для стандартных типов. Но что делать с пользовательскими типами? Мы сами можем создать метод сортировки и передать его в качестве функции. Но у такого решения есть один недостаток, функция имеет свое пространство имен, что требует передачу в нее других параметров, это часто не удобно, т.к. к примеру метод сортировки, ждет только определенные параметры, которые зафиксированы в типе (функции) параметра и если мы туда передадим еще что-то, то сломаем логику. Решить эту проблему призваны лямбда-выражения, они же лямбда-функции, они же замыкания. Это специальный синтаксис, позволяющий захватить внешние для самой лямбды переменные и использовать их внутри себя, оставляя привычным (для принимающей стороны) передачу параметров. С технической стороны, лямбды требуют отдельного рассмотрения, т.к. они имеют очень специфический синтаксис. Особенно в контексте работы со стандартной библиотекой. Как вариант, мы можем писать лямбду на месте самого параметра, принимающего функцию, что часто очень наглядно выражает логику программы. На текущий момент мы говорим о них, как о еще одной возможности передавать действие в качестве параметра (смотрите пример кода) и пока на этом остановимся.
 
#include <iostream>
#include <vector>

class Button {
public:
    explicit Button(void (*_fn)()) : fn{_fn} {    }

    void click() {
        fn();
    }

    void setFn(void (*_fn)()) {
        fn = _fn;
    }

private:
    void (*fn)() = nullptr;
};

static void foo1() {
    std::cout << "foo1 called!" << std::endl;
}

static void foo2() {
    std::cout << "foo2 called!" << std::endl;
}

void foo3(void (*_l)()) {
    _l();
}

int main() {

    typedef void(*CB)();
    //std::vector<void (*)()> calls = {foo1, foo2};
    std::vector<CB> calls = {foo1, foo2};

    for (auto i : calls) {
        i();
    }
    //Output:
    //>>foo1 called!
    //>>foo2 called!

    auto b1 = Button(foo1);
    auto b2 = Button(foo2);

    std::vector<Button> btns = {b1, b2};

    for (auto b : btns) {
        b.click();
    }
    //Output:
    //>>foo1 called!
    //>>foo2 called!

    btns[0].setFn(foo2);
    btns[1].setFn(foo1);

    for (auto b : btns) {
        b.click();
    }
    //Output:
    //>>foo2 called!
    //>>foo1 called!

    foo3(foo2);
    //Output:
    //>>foo2 called!

    foo3([]() -> void {
        std::cout << "lambda called!";
    });
    //Output:
    //>>lambda called!

    return 0;
}

Перегуд В.

Friday, November 22, 2019

Многомерные массивы в си++

Мы знаем, что по причине обратной совместимости с си, массивы в си++ представлены двумя вариантами, базовым и из стандартной библиотеки. Базовый вариант имеет известные недостатки, поэтому сегодня мы поговорим о варианте из стандартной библиотеки в контексте многомерных массивов. В частности, мы рассмотрим создание и работу с двумерным массивом с использованием классов std::array и std::vector.
 
#include <iostream>
#include <iomanip>
#include <vector>
#include <array>

Двумерный массив удобно представлять в виде массива строк, в котором каждая строка также является массивом элементов array[row][col]. Если представить такой массив графически, то получим таблицу, со строками по горизонтали и столбцами по вертикали. Обход элементов, можно осуществить с помощью вложенного цикла.

//access
template <typename T>
void printArray(T _array) {
    std::cout << "-------------------------------" << std::endl;
    int i = 1;
    for (const auto &row_in_arr : _array) {
        std::cout << "row" << i++ << ": ";
        for (const auto &col_in_row : row_in_arr) {
            std::cout << "[ " << std::setw(2) << std::setfill('0') << col_in_row << " ]";
        }
        std::cout << std::endl;
    }
}

Класс array служит для организации данных в группу элементов фиксированной длины, имеет метод возвращающий размер группы size(), а также метод доступа к элементу по индексу, проверяющий выход за границы массива at(index).
 
int main() {
    //array of arrays
    auto myArr1 = std::array<std::array<int, 5>, 5>();
   
    printArray(myArr1);
    //-------------------------------
    //row1: [ 00 ][ 00 ][ 00 ][ 00 ][ 00 ]
    //row2: [ 00 ][ 00 ][ 00 ][ 00 ][ 00 ]
    //row3: [ 00 ][ 00 ][ 00 ][ 00 ][ 00 ]
    //row4: [ 00 ][ 00 ][ 00 ][ 00 ][ 00 ]
    //row5: [ 00 ][ 00 ][ 00 ][ 00 ][ 00 ]

    //filling
    int x = 1;
    for (auto &row_in_arr : myArr1) {
        for (auto &col_in_row : row_in_arr) {
            col_in_row = x++;
        }
    }
   
    printArray(myArr1);
    //-------------------------------
    //row1: [ 01 ][ 02 ][ 03 ][ 04 ][ 05 ]
    //row2: [ 06 ][ 07 ][ 08 ][ 09 ][ 10 ]
    //row3: [ 11 ][ 12 ][ 13 ][ 14 ][ 15 ]
    //row4: [ 16 ][ 17 ][ 18 ][ 19 ][ 20 ]
    //row5: [ 21 ][ 22 ][ 23 ][ 24 ][ 25 ]
   
    //size
    std::cout << "size: " << myArr1.size() * myArr1.at(0).size() << std::endl;
    //size: 25
   
    //indexes
    std::cout << "row:1 col:1 " << "[ " << myArr1[0][0] << " ]" << std::endl;
    std::cout << "row:5 col:5 " << "[ " << myArr1[4][4] << " ]" << std::endl;
    //row:1 col:1 [ 1 ]
    //row:5 col:5 [ 25 ]
   
    //range
    try {
        std::cout << "row:6 col:6 " << ">>> " << myArr1.at(5).at(5) << std::endl;
    } catch (std::out_of_range &e) {
        std::cout << "out_of_range!!!" << std::endl;
    }
    //row:6 col:6 >>> out_of_range!!!

Класс vector дополняет вышесказанное возможностью изменять размер массива, например при помощи метода добавления нового элемента в конец массива push_back(obj). Так как при использовании этого метода происходит копирование, можно использовать метод emplace_back(obj), конструирующий новый объект.
 
    //vector of vectors
    auto myArr2 = std::vector<std::vector<int>>(5, std::vector<int>(5, 0));
   
    printArray(myArr2);
    //-------------------------------
    //row1: [ 00 ][ 00 ][ 00 ][ 00 ][ 00 ]
    //row2: [ 00 ][ 00 ][ 00 ][ 00 ][ 00 ]
    //row3: [ 00 ][ 00 ][ 00 ][ 00 ][ 00 ]
    //row4: [ 00 ][ 00 ][ 00 ][ 00 ][ 00 ]
    //row5: [ 00 ][ 00 ][ 00 ][ 00 ][ 00 ]

    //add row
    myArr2.push_back(std::vector<int>(4,1));
    //construct row
    //myArr2.emplace_back(4,1);
   
    //add element
    myArr2.at(5).push_back(10);
   
    printArray(myArr2);
    //-------------------------------
    //row1: [ 00 ][ 00 ][ 00 ][ 00 ][ 00 ]
    //row2: [ 00 ][ 00 ][ 00 ][ 00 ][ 00 ]
    //row3: [ 00 ][ 00 ][ 00 ][ 00 ][ 00 ]
    //row4: [ 00 ][ 00 ][ 00 ][ 00 ][ 00 ]
    //row5: [ 00 ][ 00 ][ 00 ][ 00 ][ 00 ]
    //row6: [ 01 ][ 01 ][ 01 ][ 01 ][ 10 ]

    //access
    std::cout << "row:1 col:1 " << "[ " << myArr2[0][0] << " ]" << std::endl;
    std::cout << "row:6 col:5 " << "[ " << myArr2.at(5).at(4) << " ]" << std::endl;
    //row:1 col:1 [ 0 ]
    //row:6 col:5 [ 10 ]

    return 0;
}

Нужно помнить, что индексы элементов в массиве начинаются с 0 (ноль).
 
Чем же отличаются std::array и std::vector? Тем, что массив хранит свои элементы в стеке, а вектор в куче. Поэтому массив быстрее, т.к. не тратит время на аллокацию и деаллокацию.

Перегуд В.