Функторы в С++. Начало знакомства

Опубликовано 08.09.2019 | Автор: admin

Функторы, что это такое?

Функторы (или функциональные объекты) — это любой объект, использование которого возможно подобно вызову функции.

В терминах С++ функции не являются объектами, поэтому они функторами не считаются. Вообще в программировании функции относят к частным случаям функторов, но не в языке С++. Хотя имена функций, не функции, а именно имена функций входят в категорию функциональных объектов. Такие вот существуют нюансы. Имя функции — это идентификатор, который умеет неявно приводиться к указателю; ситуация, как с именем массива. Поскольку указатели в терминах С++ объектами считаются, то и имя функции, приведённое к указателю, считается объектом, а поскольку оно объект, то можно говорить о функциональности объекта.

Посмотрим простейший пример использования функтора, когда в классе перегружается операция (), а потом объект класса используется подобно функции, вбирая в себя аргументы.

//Листинг #1     			Функтор как объект класса с перегруженной операцией ()     	mingw
#include <iostream>

using std::cout;

class Square{
public:
    int operator() (const int value) const{
        return value * value;   //возводим в квадрат
    }
};

int main(){
    Square sq;
    cout << sq(10) << '\n';     // 10 * 10 = 100
    cout << sq(20) << '\n';     // 20 * 20 = 400
}

//Листинг #1 Функтор как объект класса с перегруженной операцией () mingw

#include <iostream>

using std::cout;

class Square{

public:

int operator() (const int value) const{

return value * value; //возводим в квадрат

}

};

int main(){

Square sq;

cout << sq(10) << '\n'; // 10 * 10 = 100

cout << sq(20) << '\n'; // 20 * 20 = 400

}

Как вы можете видеть, внутри main использование объекта sq уподоблено механизму вызова функции. Операция (), в отличие от всех остальных, не ограничивается числом разрешённых параметров, что довольно удобно и отчего позволительно объекту полноценно имитировать функции.

На вопрос "когда функциональные объекты полезны?" можно сказать, что они полезны тогда, когда функции должны вести себя как объекты. В С++ функторы занимают важное место в стандартной библиотеке шаблонов (в STL). Например, в алгоритмы сортировки нужно подсовывать некоторый критерий для поиска, а роль этого критерия берёт на себя функтор:

//Литстинг #2.1     Функтор в алгоритме сортировки			mingw
#include <iostream>
#include <algorithm>

using namespace std;

bool compare(const int left, const int right){      //сама функция не функтор, потому что она в терминах С++ не объект
    return left < right;            //если left меньше right, вернётся true, иначе вернётся false
}


int main(){
    int arr[] = {1,2,3,4,5};

    sort(begin(arr), end(arr), compare);    //но имя функции "compare" — функтор, оно приводится к указателю, а указатель — объект
}

//Литстинг #2.1 Функтор в алгоритме сортировки mingw

#include <iostream>

#include <algorithm>

using namespace std;

bool compare(const int left, const int right){ //сама функция не функтор, потому что она в терминах С++ не объект

return left < right; //если left меньше right, вернётся true, иначе вернётся false

}

int main(){

int arr[] = {1,2,3,4,5};

sort(begin(arr), end(arr), compare); //но имя функции "compare" — функтор, оно приводится к указателю, а указатель — объект

}

//Литстинг #2.2     Функтор в алгоритме сортировки					mingw
#include <iostream>
#include <algorithm>


using namespace std;

class Less{          //сам класс не объект, он не функтор
    public:
        bool operator() (const int left, const int right){     //а для его будущего объекта перегружена (), объект будет функтором
            return left < right;
        }
};


int main(){
    int arr[] = {1,2,3,4,5};

    Less less;      //создаём объект, который благодаря перегруженным круглым скобкам — функциональный объект, т. е. функтор
    sort(begin(arr), end(arr), less);   //передаём функтор в алгоритм сортировки

}

//Литстинг #2.2 Функтор в алгоритме сортировки mingw

#include <iostream>

#include <algorithm>

using namespace std;

class Less{ //сам класс не объект, он не функтор

public:

bool operator() (const int left, const int right){ //а для его будущего объекта перегружена (), объект будет функтором

return left < right;

}

};

int main(){

int arr[] = {1,2,3,4,5};

Less less; //создаём объект, который благодаря перегруженным круглым скобкам — функциональный объект, т. е. функтор

sort(begin(arr), end(arr), less); //передаём функтор в алгоритм сортировки

}

Куда вы ни ткнёте в STL, весьма врероятно, что вам потребуются функторы. Хотя функции из STL имеют перегруженные операции для приёма объектов классов, так и для указателей на функции, использовать объекты классов удобнее, потому что чем меньше указателей, тем обычно лучше.

//Литстинг #2.3     Функтор в алгоритме сортировки				mingw
#include <iostream>
#include <algorithm>

using namespace std;

bool compare(const int left, const int right){      //сама функция не функтор, потому что она в терминах С++ не объект
    return left < right;            //если left меньше right, вернётся true, иначе вернётся false
}


int main(){
    int arr[] = {1,2,3,4,5};

    bool (*p)(int, int);
    p = compare;        //p — указатель на функцию, направлен на compare

    sort(begin(arr), end(arr), p);    //алгоритмы  умеют принимать и указатели на функции
                                      //указатели на функции — это функторы
}

//Литстинг #2.3 Функтор в алгоритме сортировки mingw

#include <iostream>

#include <algorithm>

using namespace std;

bool compare(const int left, const int right){ //сама функция не функтор, потому что она в терминах С++ не объект

return left < right; //если left меньше right, вернётся true, иначе вернётся false

}

int main(){

int arr[] = {1,2,3,4,5};

bool (*p)(int, int);

p = compare; //p — указатель на функцию, направлен на compare

sort(begin(arr), end(arr), p); //алгоритмы умеют принимать и указатели на функции

//указатели на функции — это функторы

}

Хотя любой указатель на функцию функтор, не любой функтор — указатель на функцию

Поскольку само понятие функтора включает в себя несколько разных сущностей, то понятие функтора чуть более широкое, чем если его ограничить одним из его составляющих. Иногда можно встретить мнение, что функторы заменяют указатели на функции, но это не так. Поскольку функтором может быть не только указатель на функцию, то иногда замена не выйдет. Один из таких примеров, это если некоторая функция в своих параметрах принимает указатель на функцию, а ей подсовывают объект класса:

//Литстинг #3     Функторы не всегда заменяют указатели на функции						mingw
#include <iostream>


using namespace std;

void foo(void (*)()){                     //функция принимает указатель на функцию с пустым списком параметров
    std:: cout << "foo\n";
}

void f1(){
    cout << "f1\n";
}

struct Functor{
   void operator() (){}
};

int main(){
    foo(f1);        //OK, имя f1 неявно привелось к указателю (функция f1 не задействована)

    void (*ptr)() = f1; //создали явный указатель на функцию и направали его на foo
    foo(ptr);           //передали созданный указатель функции, OK

    Functor functor;
    foo(functor);       //объект класса не умеет преобразовываться к указателю, НОУ!!! ошибка компиляции


}

//Литстинг #3 Функторы не всегда заменяют указатели на функции mingw

#include <iostream>

using namespace std;

void foo(void (*)()){ //функция принимает указатель на функцию с пустым списком параметров

std:: cout << "foo\n";

}

void f1(){

cout << "f1\n";

}

struct Functor{

void operator() (){}

};

int main(){

foo(f1); //OK, имя f1 неявно привелось к указателю (функция f1 не задействована)

void (*ptr)() = f1; //создали явный указатель на функцию и направали его на foo

foo(ptr); //передали созданный указатель функции, OK

Functor functor;

foo(functor); //объект класса не умеет преобразовываться к указателю, НОУ!!! ошибка компиляции

}

Более понятна ситуация с терминологией, когда используют расширенные названия: функтор-объект_класса или функтор-указатель_на_функцию, но обычно эти длиные названия просто сокращаются до функтор, и в контексте чаще всего понятно, о каком виде функторов идёт речь.

Одна из наиболее выгодных полезностей функциональных-объектов_классов — умение хранить внутреннее состояние. Ведь внутри класса можно описать много независимых переменных и/или объектов. Это позволяет делать подобие настраиваемой функции. Есть люди, которые так говорят, но как это использовать, мне, например, очень сложно представить.

Поскольку в С++ функторы наиболее широко используются в стандартной библиотеке шаблонов, то и примеры в этой статье основаны на использовании этой библиотеки. Во многих случаях функторы представляют собой предикаты:

Предикат — это функция, которая возвращает булево значение
Предикатный класс — это класс, перегруженная операция () которого возвращает булево значение

Когда мы используем алгоритм сортировки из стандартной библиотеки шаблонов, то нам нужно задавать какой-то критерий, в каком случае делать перестановку, а в каком не делать. В зависимости от текущей на момент ситуации (от расстановки элементов) нам требуется только два ответа: надо выполнять перестановку или нет, для этого мы используем функцию, благодаря которой происходит анализ ситуации и отдаётся признак необходимости перестановки — если ответ true, то надо, а если false, то не надо. Предикат — это просто утверждение, в нашем случае утверждение о нужности или игноре выполнени какого-то действия. Таким образом, в листинге #2.1 функция compare предикат, потому что возвращает признак надобности в виде булева значения, а в листинге #2.2. перегруженная операция () предикат, потому что возвращает признак надобности в виде булева значения. Т. е. любая функция, которая возвращает значение с типом bool или используется как функция, возвращающая значение с типом bool — предикат. Но учтите, что не каждый предикат функтор, и не каждый функтор — предикат. Уже об этом говорилось, но повторюсь, обычная функция не объект и не считается функтором, но вполне может быть предикатом.

В стандартной библиотеке шаблонов предопределено много функторов, и описывать их иногда не имеет смысла. Так, например, мы могли использовать уже написанный до нас функтор для алгоритма сортировки, а не писать свой в листингах #2

//Листинг  #4       Существует некоторое множество уже готовых функторов, описаны они в functional					mingw
#include <iostream>
#include <functional>
#include <algorithm>

using namespace std;

void print(const int i){        //для вывода на экран функторов в functional нет, 
    cout << i << ' ';           //используем свою функцию
}

int main(){
  int arr[] = {1,2,3,4,5};

  sort(begin(arr), end(arr), greater<int>());   //функтор сравнения, if (x > y) - перестановка
  for_each(begin(arr), end(arr), print );       //используем имя своей функции в качестве функтора

    cout << '\n';

  sort(begin(arr), end(arr), less<int>());      //функтор сравнения, if (x < y) - перестановка
  for_each(begin(arr), end(arr), print );
}

//Листинг #4 Существует некоторое множество уже готовых функторов, описаны они в functional mingw

#include <iostream>

#include <functional>

#include <algorithm>

using namespace std;

void print(const int i){ //для вывода на экран функторов в functional нет,

cout << i << ' '; //используем свою функцию

}

int main(){

int arr[] = {1,2,3,4,5};

sort(begin(arr), end(arr), greater<int>()); //функтор сравнения, if (x > y) - перестановка

for_each(begin(arr), end(arr), print ); //используем имя своей функции в качестве функтора

cout << '\n';

sort(begin(arr), end(arr), less<int>()); //функтор сравнения, if (x < y) - перестановка

for_each(begin(arr), end(arr), print );

}

В functional описаны функторы для сравнения, для арифметических операций, для логических операций и некоторые другие.

Хотя и существуют уже готовые функторы некоторых видов, их не всегда можно правильно использовать, и в таких случаях имеет смысл писать свои.

В С++11 были добавлены так называемые лямбда-функции. Это обёртки над функциональными объектами классов. Синтаксис их может казаться необычным, но они помогают сокращать количество строк кода. Поскольку лямбда-функции идентичны функторам-объектам_классов, то они такие же функторы, только имеют своеобразный синтаксис.

//Пример пустой лямбда-функции

int main(){
	[](){};		
}

//Пример пустой лямбда-функции

int main(){

[](){};

}

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

//Листинг #5		Использование функтора 		лямбда-функция				mingw
#include <iostream>
#include <algorithm>

using namespace std;

int main() {

    int arr[10] = {1,2,3,4,5,6,7,8,10};

    for_each(begin(arr), end(arr), [](const int i){  cout << i << ' '; });

}

//Листинг #5 Использование функтора лямбда-функция mingw

#include <iostream>

#include <algorithm>

using namespace std;

int main() {

int arr[10] = {1,2,3,4,5,6,7,8,10};

for_each(begin(arr), end(arr), [](const int i){ cout << i << ' '; });

}

Позже вы научитесь их использовать, а пока, если не знаете, что это за зверь такой, не надо торопиться и лезть их учить. Вам достаточно знать того, что лямбда-функции — это функтор, такой же как функтор-объект_класса, только со своим собственным синтаксисом. А поскольку она объект, её можно присваивать в объекты и передавать в аргументах функциям и классам.

Итак, делаем некоторые выводы:

Функторы — это в С++ прежде всего классы с перегруженной операцией (), а потом любые объекты, которые умеют вести себя как функции: это указатели на функции, лямбда-функции и имена функций, но сами функции и ссылки на функции функторами не являются, потому что они в терминах С++ не объекты.

Функторы полезны там, где функции должны вести себя как объекты.

Функторы имеют очень важное значение при использовании стандартной библиотеки шаблонов (STL), а следовательно могут так же широко использоваться в других библиотеках.

В стандартной библиотеке шаблонов (STL) есть некоторое множество предопределённых функторов, и их нужно использовать в предпочтение своим самописным.

Функторы имеют свойсто быть пересылаемыми и присваиваемыми, поскольку они объекты; обычные функции таким свойством не обладают.

Функции, возвращающие булевы значения, называются предикатами. Функторы могут быть и очень часто являются предикатами.

При написании функторов нужно стараться делать их небольшими объектами и не стоит использовать виртуальные функции внутри них. В тех случаях, когда функторами-объектами_классов заменяются указатели на функции, оптимизаторы компиляторов умеют хорошо улучшать конечный код.

Конечно, тут есть ещё о чём написать, но это начало знакомства с функторами, и, надеюсь, то сказанное, что осветилось в этой теме, помогло вам или поспособствует пониманию и использованию их.

Рубрика: Без рубрики

рома:

12.02.2020 в 9:46 пп

haha

Ответить

Владимир:

18.06.2021 в 10:04 пп

«Функторы имеют свойсто быть пересылаемыми и присваиваемыми, поскольку они объекты; обычные функции таким свойством не обладают.»
Это почему указатели на функции не могут быть пересылаемыми и присваемыми?

admin:

18.06.2021 в 11:05 пп

А при чём тут указатели на функции, если в цитируемом речь идёт о функциях?

Ответить

Последние комментарии

Александр к записи Хороший стиль программирования
Аноним к записи Список тем сайта
Аноним к записи Список тем сайта

Функторы в С++. Начало знакомства

3 комментария на «“Функторы в С++. Начало знакомства”»

Добавить комментарий Отменить ответ

Поиск

Последние темы

Случайная книга в электронном формате

Последние комментарии

Мета