Нужно использовать shared_ptr?
У меня есть два класса: Lattice и ModelGUI. Я хочу передать функцию из решетки в графический интерфейс в качестве обратного вызова. Я реализовал решетку как unique_ptr. Некоторый код:
МодельGUI.h:
using CheckTypeClbk = std::function<Enums::AgentType(int)>;
ModelGUI(const Matrix* matrix_, CheckTypeClbk callback, float windowHeight_, float windowWidth_, float latticeWidth_);
основной.cpp:
std::unique_ptr<ILattice> lattice(new Lattice(5, qMap));
ModelGUI gui(lattice->getLattice(), std::bind(&ILattice::checkAgentType, lattice, std::placeholders::_1),
800, 1200, 800);
С этой реализацией я получил странные ошибки компиляции о шаблонах:
1>main.cpp
1>d:\program files (x86)\microsoft visual studio\2017\community\vc\tools\msvc\14.14.26428\include\xutility(390): error C2664: 'std::tuple<std::unique_ptr<ILattice,std::default_delete<_Ty>>,std::_Ph<1>>::tuple(std::tuple<std::unique_ptr<_Ty,std::default_delete<_Ty>>,std::_Ph<1>> &&)': cannot convert argument 1 from 'std::unique_ptr<ILattice,std::default_delete<_Ty>>' to 'std::allocator_arg_t'
1> with
1> [
1> _Ty=ILattice
1> ]
1>d:\program files (x86)\microsoft visual studio\2017\community\vc\tools\msvc\14.14.26428\include\xutility(389): note: No user-defined-conversion operator available that can perform this conversion, or the operator cannot be called
1>d:\program files (x86)\microsoft visual studio\2017\community\vc\tools\msvc\14.14.26428\include\functional(1902): note: see reference to function template instantiation 'std::_Compressed_pair<Enums::AgentType (__cdecl ILattice::* )(int),std::tuple<std::unique_ptr<ILattice,std::default_delete<_Ty>>,std::_Ph<1>>,false>::_Compressed_pair<Enums::AgentType(__cdecl ILattice::* )(int),_Cv_TiD&,const std::_Ph<1>&>(std::_One_then_variadic_args_t,_Other1 &&,_Cv_TiD &,const std::_Ph<1> &)' being compiled
1> with
1> [
1> _Ty=ILattice,
1> _Cv_TiD=std::unique_ptr<ILattice,std::default_delete<ILattice>>,
1> _Other1=Enums::AgentType (__cdecl ILattice::* )(int)
1> ]
1>d:\program files (x86)\microsoft visual studio\2017\community\vc\tools\msvc\14.14.26428\include\functional(1903): note: see reference to function template instantiation 'std::_Compressed_pair<Enums::AgentType (__cdecl ILattice::* )(int),std::tuple<std::unique_ptr<ILattice,std::default_delete<_Ty>>,std::_Ph<1>>,false>::_Compressed_pair<Enums::AgentType(__cdecl ILattice::* )(int),_Cv_TiD&,const std::_Ph<1>&>(std::_One_then_variadic_args_t,_Other1 &&,_Cv_TiD &,const std::_Ph<1> &)' being compiled
1> with
1> [
1> _Ty=ILattice,
1> _Cv_TiD=std::unique_ptr<ILattice,std::default_delete<ILattice>>,
1> _Other1=Enums::AgentType (__cdecl ILattice::* )(int)
1> ]
1>d:\program files (x86)\microsoft visual studio\2017\community\vc\tools\msvc\14.14.26428\include\functional(1902): note: while compiling class template member function 'std::_Binder<std::_Unforced,Enums::AgentType (__cdecl ILattice::* )(int),std::unique_ptr<ILattice,std::default_delete<_Ty>> &,const std::_Ph<1> &>::_Binder(_Fx &&,std::unique_ptr<_Ty,std::default_delete<_Ty>> &,const std::_Ph<1> &)'
1> with
1> [
1> _Ty=ILattice,
1> _Fx=Enums::AgentType (__cdecl ILattice::* )(int)
1> ]
1>d:\program files (x86)\microsoft visual studio\2017\community\vc\tools\msvc\14.14.26428\include\functional(1929): note: see reference to function template instantiation 'std::_Binder<std::_Unforced,Enums::AgentType (__cdecl ILattice::* )(int),std::unique_ptr<ILattice,std::default_delete<_Ty>> &,const std::_Ph<1> &>::_Binder(_Fx &&,std::unique_ptr<_Ty,std::default_delete<_Ty>> &,const std::_Ph<1> &)' being compiled
1> with
1> [
1> _Ty=ILattice,
1> _Fx=Enums::AgentType (__cdecl ILattice::* )(int)
1> ]
1>d:\predator-prey\predator-prey\main.cpp(16): note: see reference to class template instantiation 'std::_Binder<std::_Unforced,Enums::AgentType (__cdecl ILattice::* )(int),std::unique_ptr<ILattice,std::default_delete<_Ty>> &,const std::_Ph<1> &>' being compiled
1> with
1> [
1> _Ty=ILattice
1> ]
Но когда я использую shared_ptr вместо unique_ptr, все работает нормально. Хорошая практика? Я слышал, что нужно избегать использования shared_ptr, насколько это возможно, если только они не являются абсолютно необходимыми.
Что не так с std::bind?
std::bind обычно медленнее и громоздче, чем лямбда, и многие считают синтаксис лямбда более чистым.
Поскольку мне пришлось обработать это для комментария к ответу, вот как будет выглядеть эта упрощенная версия с лямбдой: ideone.com/ЭргтСи . Обратите внимание, что unique_ptrt передается по ссылке. Не позволяйте f2 пережить t.
Ответы 2
- Вы передаете
std::unique_ptrпо значению, и это всегда плохой идея, потому что у него нет конструктора копирования. - Почему ваш код даже не компилируется? Кажется, что передача std::unique_ptr связанной функции — это долгоживущий ошибка Visual Studio.
Это больше комментарий, чем ответ. На вопрос, поднятый во втором пункте, отвечает первый пункт.
Нет, эти две точки в основном ортогональны. Потому что этот код компилируется в gcc и clang, НО не работает именно в vs2012+.
std::bind принимает свои аргументы по значению. Это заставляет копировать. unique_ptr нельзя скопировать. Результат ошибки.Вам нужно shared_ptr?
Нет. По крайней мере, не для данного примера.
Если lattice и gui определены в разных областях с разной продолжительностью жизни и используются повсеместно, вауи-цови, мы можем говорить о shared_ptr.
Почему?
Давайте начнем с действительно простого примера, который показывает, почему unique_ptr вызывает горе.
#include <functional>
#include <iostream>
struct test
{
test() = default;
test(const test &)
{
std::cout << "copied" << std::endl;
}
void func(int i)
{
std::cout << i << std::endl;
}
};
int main()
{
test t;
std::function<void(int)> f1 = std::bind(&test::func, t, std::placeholders::_1);
f1(1);
}
test ничего не делает, кроме как сообщает нам, когда объект скопирован, и доказывает, что функция запущена. Выполнив его, мы увидим, что t копируется и выдается ожидаемый результат функции.
std::unique_ptr нельзя копировать, потому что это в значительной степени испортит всю часть уникальный описания вакансии. Мы видим, что если мы немного изменим main, чтобы использовать unique_ptr, и немного приблизимся к поставленному вопросу.
int main()
{
std::unique_ptr<test> tp = std::make_unique<test>();
std::function<void(int)> f1 = std::bind(&test::func, tp, std::placeholders::_1);
}
Как и ожидалось, это не компилируется. Мы можем сделать эту компиляцию, используя std::reference_wrapper
std::function<void(int)> f1 = std::bind(&test::func, std::reference_wrapper<std::unique_ptr<test>>(tp), std::placeholders::_1);
или укажите необработанный указатель на bind
std::function<void(int)> f1 = std::bind(&test::func, tp.get(), std::placeholders::_1); f1(1);
но для этого требуется, чтобы tp имел более широкий охват и гарантированно переживет f1. На самом деле это сводится к тому, зачем вообще использовать больше, чем test t;? Нужен ли нам здесь вообще указатель?
Но давайте пока остановимся на этом, потому что мы можем, по крайней мере, сделать это намного красивее, прежде чем мы отправимся на более зеленые пастбища. Вот то же самое с лямбда-выражением
std::function<void(int)> f1 = [&tp](int i) { tp->func(i); };
Обычно я не сторонник утверждения «Лямбда легче читается, чем bind», но этот случай — довольно убедительный аргумент.
Возвращаясь к основам, на самом деле это не так уж сильно отличается от
int main()
{
test t;
std::function<void(int)> f1 = [&t](int i) { t.func(i); };
f1(1);
}
и полностью устраняет указатель. Нет указателя, нет shared_ptr.
Если t можно запустить и забыть, единственным пользователем является обратный вызов, пусть лямбда носит с собой копию t и пусть оригинал умирает.
std::function<void(int)> scopedemo()
{
test t;
return [t](int i) mutable { t.func(i); }; //
}
int main()
{
auto f1 = scopedemo();
f1(1);
}
Обратите внимание на mutable. По умолчанию Lambda содержит константы и не может использоваться для вызова не-const методов или в качестве не-const параметра.
Дело в том, что
unique_ptrможет быть только один. Вы не можете скопировать их. Вы не можете передавать их без передачи права собственности. Вы должны решить, кто является законным владельцем указателя. Только еслиlatticeиguiимеют законную долю, вы должны использоватьshared_ptr. В этом случае похоже, чтоlatticeимеет более широкую область действия, чемgui, и может безопасно поддерживать право собственности, и вы можете предоставить необработанный указатель наgui. Примечание: вместоstd::bindрассмотрите возможность использования лямбда-выражения.