Geek Answers Handbook

Bind make_shared with a variation template

I am trying to write the following factory class, but I cannot find the correct syntax:

template<class T, typename... TArgs>
class Factory {
 public:
  Factory(TArgs... args) {
    creator_ = std::bind(&std::make_shared<T, TArgs...>, args...);
    //      ^^^ some error around here
  }
  std::shared_ptr<T> Create() const {
    return creator_();
  }
 private:
  std::function<std::shared_ptr<T>()> creator_;
};

This is how I use factory:

class Foo {
 public:
  Foo(bool value) {}
};
class Bar {
 public:
   Bar(const std::string& value) {}
};
Factory<Foo, bool> f1(true);
Factory<Bar, std::string> f2("string");

These are the errors I get when declaring f1and f2:

error: no match for 'operator=' (operand types are 'std::function<std::shared_ptr<Foo>()>' and 'std::_Bind_helper<false, std::shared_ptr<Foo> (*)(bool&&), bool&>::type {aka std::_Bind<std::shared_ptr<Foo> (*(bool))(bool&&)>}')
   creator_ = std::bind(&std::make_shared<T, TArgs...>, args...);
            ^

error: no match for 'operator=' (operand types are 'std::function<std::shared_ptr<Bar>()>' and 'std::_Bind_helper<false, std::shared_ptr<Bar> (*)(std::basic_string<char>&&), std::basic_string<char, std::char_traits<char>, std::allocator<char> >&>::type {aka std::_Bind<std::shared_ptr<Bar> (*(std::basic_string<char>))(std::basic_string<char>&&)>}')
   creator_ = std::bind(&std::make_shared<T, TArgs...>, args...);
            ^

What is the correct syntax that I should use with std::bind?

+4
source share
2 answers

std::make_shared declared as follows:

template< class T, class... Args >
shared_ptr<T> make_shared( Args&&... args );

This std::make_shared<T, TArgs...>will result in a function accepting rvalue references that will not be bound to args.... A simple solution for this is to force it to accept lvalue links by folding the link:

creator_ = std::bind(&std::make_shared<T,TArgs&...>, args...);
//                                            ^

An alternative is to use lambda instead, which is more readable:

creator_ = [=](){return std::make_shared<T>(args...);};
+6

, ++ 14, , .

template<class T>
struct Factory {
  template<class...Args>
  Factory(Args&&... args):
    creator_(
      make_creator(
        std::index_sequence_for<Args...>{},
        std::make_tuple( std::forward<Args>(args)...
      )
    )
  {}
  std::shared_ptr<T> operator()() const {
    return creator_();
  }
private:
  using signature = std::shared_ptr<T>();
  using creator = std::function<signature>;
  creator creator_;
  // helper, to make a lambda with a tuple to unpack:
  template<class Tup, size_t...Is>
  static creator make_creator(std::index_sequence<Is...>, Tup&& tup) {
    return [tup = std::forward<Tup>(tup)]{
      return std::make_shared<T>( std::get<Is>(tup)... );
    };
  }
};

.

-, , T :

Factory<Foo> f1(true);
Factory<Bar> f2("string");

-, f1.Create() f1(). factory , factory - - .

:

template<class T>
using Factory = std::function<std::shared_ptr<T>()>;

namespace details {
  template<class T, class Tup, size_t...Is>
  Factory<T> make_factory(std::index_sequence<Is...>, Tup&& tup) {
    return [tup = std::forward<Tup>(tup)]{
      return std::make_shared<T>( std::get<Is>(tup)... );
    };
  }
}
template<class T, class...Args>
Factory<T> make_factory(Args&&...args) {
  return details::make_factory<T>(
    std::index_sequence_for<Args...>{},
    std::make_tuple( std::forward<Args>(args)... )
  );
}

Factory - Factory<T> std::function, shared_ptr<T>.

.

details::make_factory .

namespace details {
  template<class F, class Tup, size_t...Is>
  auto invoke( F&& f, Tup&& tup, std::index_sequence<Is...> )
  -> std::result_of_t<F( std::tuple_element_t<Is, std::decay_t<Tup>>... )>
  {
    return std::forward<F>(f)( std::get<Is>(std::forward<Tup>(tup))... );
  }
}
template<class F, class Tup, size_t...Is>
auto invoke( F&& f, Tup&& tup )
{
  using count = std::tuple_size< std::decay_t<Tup> >;
  using indexes = std::make_index_sequence< count{} >;

  return details::invoke(
    std::forward<F>(f),
    std::forward<Tup>(tup),
    indexes{}
  );
}
template<class T>
auto shared_maker() {
  return [](auto&&...args){
    return std::make_shared<T>( decltype(args)(args)... );
  };
}

template<class T, class...Args>
Factory<T> make_factory(Args&&...args) {
  return [tup=std::make_tuple(std::forward<Args>(args)...)]{
    return invoke(
      shared_maker<T>(),
      tup
    );
  };
}

, " " invoke .

template<class T>
const auto shared_maker = [](auto&&...args){
  return std::make_shared<T>(decltype(args)(args)...);
};

, gcc 5.2.0 .

+4

More articles:


All Articles