Raw pointer lookup for sets of unique_ptrs

by

In C++14, std::set<Key>::find is a template function if Compare::is_transparent exists. The type you pass in does not need to be Key, just equivalent under your comparator.

So write a comparator:

template<class T>
struct pointer_comp {
  typedef std::true_type is_transparent;
  // helper does some magic in order to reduce the number of
  // pairs of types we need to know how to compare: it turns
  // everything into a pointer, and then uses `std::less<T*>`
  // to do the comparison:
  struct helper {
    T* ptr;
    helper():ptr(nullptr) {}
    helper(helper const&) = default;
    helper(T* p):ptr(p) {}
    template<class U, class...Ts>
    helper( std::shared_ptr<U,Ts...> const& sp ):ptr(sp.get()) {}
    template<class U, class...Ts>
    helper( std::unique_ptr<U, Ts...> const& up ):ptr(up.get()) {}
    // && optional: enforces rvalue use only
    bool operator<( helper o ) const {
      return std::less<T*>()( ptr, o.ptr );
    }
  };
  // without helper, we would need 2^n different overloads, where
  // n is the number of types we want to support (so, 8 with
  // raw pointers, unique pointers, and shared pointers).  That
  // seems silly:
  // && helps enforce rvalue use only
  bool operator()( helper const&& lhs, helper const&& rhs ) const {
    return lhs < rhs;
  }
};

then use it:

typedef std::set< std::unique_ptr<Foo>, pointer_comp<Foo> > owning_foo_set;

now, owning_foo_set::find will accept unique_ptr<Foo> or Foo* or shared_ptr<Foo> (or any derived class of Foo) and find the correct element.

Outside of C++14, you are forced to use the map to unique_ptr approach, or something equivalent, as the signature of find is overly restrictive. Or write your own set equivalent.

More Related Contents:

  1. Differences between std::make_unique and std::unique_ptr with new
  2. How to implement make_unique function in C++11? [duplicate]
  3. error::make_unique is not a member of ‘std’
  4. Why compiler gives the message "call of overloaded function is ambiguous" here in C++11?
  5. what is the concept of evaluation of expression z = (y = 30) + (y = 10) + (y = 20); [closed]
  6. Implementation C++14 make_integer_sequence
  7. Is std::unique_ptr required to know the full definition of T?
  8. Why can I not push_back a unique_ptr into a vector?
  9. Returning unique_ptr from functions
  10. How do I pass a unique_ptr argument to a constructor or a function?
  11. How do I use a custom deleter with a std::unique_ptr member?
  12. Is it a conforming compiler extension to treat non-constexpr standard library functions as constexpr?
  13. Is there any use for unique_ptr with array?
  14. How to capture a unique_ptr into a lambda expression?
  15. Is it safe to link C++17, C++14, and C++11 objects
  16. Why are lambda expressions not allowed in an unevaluated operands but allowed in the unevaluated portions of constant expressions?
  17. Default, value and zero initialization mess
  18. Capturing perfectly-forwarded variable in lambda
  19. Parallel Loops in C++
  20. So can unique_ptr be used safely in stl collections?
  21. How to extract the source filename without path and suffix at compile time?
  22. How to make std::make_unique a friend of my class
  23. How can I pass std::unique_ptr into a function
  24. Should I use shared_ptr or unique_ptr
  25. Classes with both template and non-template conversion operators in the condition of switch statement
  26. Why does constexpr static member (of type class) require a definition?
  27. Using std::make_unique with a custom deleter
  28. What’s the standard/official name for universal references?
  29. Is there a way to write make_unique() in VS2012?
  30. Reference invalidation after applying reverse_iterator on a custom made iterator

Leave a Comment