Я думаю о том, чтобы перенести свой код на использование лямбда-выражений в стиле С++ 11 вместо того, чтобы везде использовать bind. Но я не уверен, хорошая это идея или нет.
Использует ли, например. boost::lambda (или boost::phoenix) имеют какое-либо практическое преимущество перед лямбда-выражениями в стиле С++ 11?
Стоит ли переходить на лямбды? Должен ли я перенести свой код или нет?
Основным преимуществом будут полиморфные функторы. В настоящее время лямбда-выражения C++11 являются мономорфными, т. е. они принимают только один тип аргумента, тогда как bind() позволяет создавать функторы, которые принимают любой тип аргумента, если связанный функтор может вызываться с ним.
#include <functional>
struct X{
template<class T, class U>
void operator()(T, U) const{}
};
int main(){
X x;
auto l_with_5 = [x](int v){ return x(v, 5); };
auto b_with_5 = std::bind(x, std::placeholders::_1, 5);
l(4);
b("hi"); // can't do that with C++11 lambdas
}
Да, лямбда-выражения Boost полиморфны, лямбда-выражения C++11 — нет. Это означает, что, например, вы не можете сделать это с лямбда-выражениями C++11:
template<class T>
void f(T g)
{
int x = 123;
const char* y = "hello";
g(x); // call with an integer
g(y); // call with a string
}
int main() {
f(std::cout << _1);
}
Если ваши лямбда-выражения отличаются друг от друга каким-либо образом, они будут генерировать разный код, и компилятор, скорее всего, не сможет объединить идентичные части. (Встраивание делает это намного сложнее.)
На первый взгляд это не кажется чем-то большим, пока вы не заметите:
Когда вы используете их внутри шаблонных функций, таких как std::sort, компилятор генерирует новый код для каждого другая лямбда.
Это может непропорционально увеличить размер кода.
bind, однако, обычно более устойчив к таким изменениям (хотя и не застрахован от них).
Чтобы проиллюстрировать, что я имею в виду...
if (false) на if (true) и посмотрите, как изменился размер выходного двоичного файла.stable_sort в каждой части.Обратите внимание, что в первый раз лямбда-выражения C++11 немного меньше; после этого их размер увеличивается после каждого использования (около 3,3 КБ кода для каждой сортировки с VC++, аналогично GCC), тогда как двоичные файлы на основе boost::lambda практически не меняют свой размер (для меня он остается прежним, когда включены все четыре с точностью до полукилобайта).
#include <algorithm>
#include <string>
#include <vector>
#include <boost/lambda/bind.hpp>
#include <boost/lambda/lambda.hpp> // can also use boost::phoenix
using namespace boost::lambda;
struct Foo { std::string w, x, y, z; };
int main()
{
std::vector<Foo> v1;
std::vector<size_t> v2;
for (size_t j = 0; j < 5; j++) { v1.push_back(Foo()); }
for (size_t j = 0; j < v1.size(); j++) { v2.push_back(j); }
if (true)
{
std::stable_sort(v2.begin(), v2.end(), bind(&Foo::w, var(v1)[_1]) < bind(&Foo::w, var(v1)[_2]));
std::stable_sort(v2.begin(), v2.end(), bind(&Foo::x, var(v1)[_1]) < bind(&Foo::x, var(v1)[_2]));
std::stable_sort(v2.begin(), v2.end(), bind(&Foo::y, var(v1)[_1]) < bind(&Foo::y, var(v1)[_2]));
std::stable_sort(v2.begin(), v2.end(), bind(&Foo::z, var(v1)[_1]) < bind(&Foo::z, var(v1)[_2]));
}
else
{
std::stable_sort(v2.begin(), v2.end(), [&](size_t i, size_t j) { return v1[i].w < v1[j].w; });
std::stable_sort(v2.begin(), v2.end(), [&](size_t i, size_t j) { return v1[i].x < v1[j].x; });
std::stable_sort(v2.begin(), v2.end(), [&](size_t i, size_t j) { return v1[i].y < v1[j].y; });
std::stable_sort(v2.begin(), v2.end(), [&](size_t i, size_t j) { return v1[i].z < v1[j].z; });
}
}
Обратите внимание, что это обмен размера на скорость; если вы находитесь в очень очень тесном цикле, он может включать дополнительную переменную (поскольку теперь он использует указатели на члены).
Однако это ничего не имеет ничего общего с накладными расходами std::function (которые являются виртуальным вызовом), и даже это во многих случаях не поддается измерению, так что это не должно вызывать беспокойства.
dumpbin /symbols--.
- person David Rodríguez - dribeas; 22.08.2012
int main() { std::vector<std::function<void(int)>> v; v.push_back([](int i){std::cout<<i<<"\n";}); /*repeated 5 times*/ for (auto it=v.begin();it!=v.end();++it){(*it)(5);}} Все в одной единице перевода. С 5 лямбдами: 79360 байт в .exe, с 10 лямбдами: 105472
- person David Rodríguez - dribeas; 22.08.2012
std::bind может быть спутано с boost::lambda::bind. Попробуйте указать их явно.
- person user541686; 22.08.2012
stable_sort для полей x, y и z вы просто вызовете stable_sort для w четыре раза, вы должны увидеть, что размер файла уменьшится с 26,5 КБ до 16,5 КБ (или аналогичное уменьшение) . Это довольно важный признак того, что компилятор или компоновщик что-то объединяет (но какие именно части? Я не знаю).
- person user541686; 22.08.2012
boost::phoenix немного делает его больше для меня, но, вероятно, не стоит об этом беспокоиться.
- person user541686; 22.08.2012
std::ostream::operator<<(int), разница в размерах заметна.
- person David Rodríguez - dribeas; 22.08.2012
std::function не требует виртуальной диспетчеризации, а эффективность может быть аналогична эффективности вызова дополнительной функции.
- person David Rodríguez - dribeas; 22.08.2012
std::function не требует виртуальной диспетчеризации? Как вы думаете, как это вызывает лямбды?
- person user541686; 22.08.2012
exec (выберите свое имя для виртуальной функции здесь), является одним вариантом, но не единственным. Другой вариант — создать вместо базового шаблона шаблон function. Этот шаблон принимает функтор в качестве аргумента и выполняет над ним operator(), добавляя один дополнительный вызов невиртуальной функции. Затем объект std::function может хранить указатель на функцию (в этом описании отсутствуют некоторые детали, но вы можете их заполнить).
- person David Rodríguez - dribeas; 22.08.2012
bind. Но я разместил этот вопрос (и ответ), чтобы указать, что даже если вы находитесь в ситуации, когда они как читаемы, так и пригодны для использования (т.е. даже если вы не нужен полиморфизм, и даже если удобочитаемость не является проблемой), все же есть причины выбратьbind. - person user541686 schedule 22.08.2012