如何传递容器、ptr 和对象不可修改的unique_ptrs容器?

"问题"是std::unique_ptr::operator*被定义为返回一个非常量引用：

std::add_lvalue_reference<T>::type operator*() const

由于它是一个内部类，你可以使用普通指针并显式管理生命周期，允许你做一些类似的事情。

span<my_type_t const> encompassing_type::get_container() const
{
return span( m_container );
}

Justin 建议使用类似span<const my_type_t>的东西来实现指向向量的常量指针视图。例如，您可以使用 Boost.Range 执行此操作并返回一系列 const 指针：

#include <boost/range.hpp>
#include <boost/range/adaptor/transformed.hpp>
using namespace boost::adaptors;
class X {
public:
void nonConst() {}
void constF() const {}
};
class A{
std::vector<std::unique_ptr<X>> v;
public:
A() : v(10) {}
auto get_container() {
return v | transformed( [](std::unique_ptr<X> const& x) -> X const* {return x.get();});
}
};
int main()  {
A a;
auto const& v = a.get_container();
a.get_container()[0]->constF();
a.get_container()[0]->nonConst();
return 0;
}

对于优化编译器，这应该是相当有效的。

您也可以从std::vector<std::unique_ptr<my_type_t>>切换到boost::ptr_vector<my_type_t>.它还假定指针存储的元素的所有权，但它返回一个const_referenceinoperator[] const，以便无法修改对象。

#include <boost/ptr_container/ptr_vector.hpp>
class X {
public:
void nonConst() {}
};
class A{
boost::ptr_vector<X> v;
public:
boost::ptr_vector<X> const& get_container() const {
return v;
}
};
int main()  {
A a;
auto const& v = a.get_container();
a.get_container()[0].nonConst();
return 0;
}

这将保护在get_container()返回常量引用时不修改修饰符：

prog.cc：26：1：错误："this"参数到成员函数"nonConst"有 键入 'const boost：:p tr_container_detail：：reversible_ptr_container>>， boost：：heap_clone_allocator>：：Ty_'(又名"const X")，但函数是 未标记 const a.get_container()[0].nonConst();^~~~~~~~~~~~~~~~~~~~ prog.cc：9：9： 注意： 'nonConst' 在这里声明 void nonConst() {} ^ 生成 1 个错误。

我不想包含boost，span不起作用，因为正如@Jens指出的那样，unique_ptr不会传播cv限定符。 此外，即使我确实包含了 boost，我也无法获得矢量中每个项目的实际对象引用，我需要允许我将对象的相对位置与容器中的其他对象进行比较。

所以我选择在std::unique_ptr上编写一个包装器，这将传播 cv 限定符。

以下是我的enable_if.h文件的摘录，我使用它来比较运算符来限制我必须编写它们的次数：

namespace detail
{
// Reason to use an enum class rather than just an int is so as to ensure
// there will not be any clashes resulting in an ambiguous overload.
enum class enabler
{
enabled
};
}
#define ENABLE_IF(...) std::enable_if_t<__VA_ARGS__, detail::enabler> = detail::enabler::enabled
#define ENABLE_IF_DEFINITION(...) std::enable_if_t<__VA_ARGS__, detail::enabler>

这是我对 c++20std::remove_cvref_t的实现：

template <typename T>
using remove_cvref_t = std::remove_cv_t<std::remove_reference_t<T>>;

这是包装的唯一ptr：

template <typename T, typename D = std::default_delete<T>>
class unique_ptr_propagate_cv;
namespace detail
{
template <typename T, typename D>
std::unique_ptr<T, D> const& get_underlying_unique_ptr(unique_ptr_propagate_cv<T, D> const& object)
{
return object.ptr;
}
}
template <typename T, typename D>
class unique_ptr_propagate_cv
{
template <typename T_, typename D_>
friend std::unique_ptr<T_, D_> const& detail::get_underlying_unique_ptr<T_, D_>(unique_ptr_propagate_cv<T_, D_> const&);
using base = std::unique_ptr<T, D>;
base ptr;
public:
template <typename...Ts>
unique_ptr_propagate_cv(Ts&&...args) noexcept : ptr(std::forward<Ts>(args)...) {}
using element_type           = typename base::element_type;
using deleter_type           = typename base::deleter_type;
using pointer                = element_type                *;
using pointer_const          = element_type const          *;
using pointer_volatile       = element_type       volatile *;
using pointer_const_volatile = element_type const volatile *;
using reference                = element_type                &;
using reference_const          = element_type const          &;
using reference_volatile       = element_type       volatile &;
using reference_const_volatile = element_type const volatile &;
pointer                get()                noexcept { return ptr.get(); }
pointer_const          get() const          noexcept { return ptr.get(); }
pointer_volatile       get()       volatile noexcept { return ptr.get(); }
pointer_const_volatile get() const volatile noexcept { return ptr.get(); }
pointer                operator->()                noexcept { return ptr.get(); }
pointer_const          operator->() const          noexcept { return ptr.get(); }
pointer_volatile       operator->()       volatile noexcept { return ptr.get(); }
pointer_const_volatile operator->() const volatile noexcept { return ptr.get(); }
reference                operator[](size_t index)                noexcept { return ptr.operator[](index); }
reference_const          operator[](size_t index) const          noexcept { return ptr.operator[](index); }
reference_volatile       operator[](size_t index)       volatile noexcept { return ptr.operator[](index); }
reference_const_volatile operator[](size_t index) const volatile noexcept { return ptr.operator[](index); }
reference                operator*()                noexcept { return ptr.operator*(); }
reference_const          operator*() const          noexcept { return ptr.operator*(); }
reference_volatile       operator*()       volatile noexcept { return ptr.operator*(); }
reference_const_volatile operator*() const volatile noexcept { return ptr.operator*(); }
template <typename T_>
unique_ptr_propagate_cv& operator=(T_&& rhs)
{
return static_cast<unique_ptr_propagate_cv&>(ptr.operator=(std::forward<T_>(rhs)));
}
decltype(auto) get_deleter()            const noexcept { return ptr.get_deleter(); }
operator bool()          const noexcept { return ptr.operator bool(); }
decltype(auto) reset(pointer ptr = pointer()) noexcept {        get_base_nonconst().reset(ptr); }
decltype(auto) release()                      noexcept { return get_base_nonconst().release();  }
};
template <typename T>
struct is_unique_ptr_propagate_cv : std::false_type {};
template <typename T, typename D>
struct is_unique_ptr_propagate_cv<unique_ptr_propagate_cv<T, D>> : std::true_type {};
namespace detail
{
inline nullptr_t const& get_underlying_unique_ptr(nullptr_t const& object)
{
return object;
}
template <typename T, typename D>
std::unique_ptr<T, D> const& get_underlying_unique_ptr(std::unique_ptr<T, D> const& object)
{
return object;
}
}
template <typename L, typename R
, ENABLE_IF(
is_unique_ptr_propagate_cv<remove_cvref_t<L>>::value
|| is_unique_ptr_propagate_cv<remove_cvref_t<R>>::value
)
>
bool operator==(L&& lhs, R&& rhs) noexcept
{
return detail::get_underlying_unique_ptr(std::forward<L>(lhs))
== detail::get_underlying_unique_ptr(std::forward<R>(rhs));
}
template <typename L, typename R
, ENABLE_IF(
is_unique_ptr_propagate_cv<remove_cvref_t<L>>::value
|| is_unique_ptr_propagate_cv<remove_cvref_t<R>>::value
)
>
auto operator!=(L&& lhs, R&& rhs) noexcept
{
return detail::get_underlying_unique_ptr(std::forward<L>(lhs))
!= detail::get_underlying_unique_ptr(std::forward<R>(rhs));
}
template <typename L, typename R
, ENABLE_IF(
is_unique_ptr_propagate_cv<remove_cvref_t<L>>::value
|| is_unique_ptr_propagate_cv<remove_cvref_t<R>>::value
)
>
bool operator<=(L&& lhs, R&& rhs) noexcept
{
return detail::get_underlying_unique_ptr(std::forward<L>(lhs))
<= detail::get_underlying_unique_ptr(std::forward<R>(rhs));
}
template <typename L, typename R
, ENABLE_IF(
is_unique_ptr_propagate_cv<remove_cvref_t<L>>::value
|| is_unique_ptr_propagate_cv<remove_cvref_t<R>>::value
)
>
bool operator>=(L&& lhs, R&& rhs) noexcept
{
return detail::get_underlying_unique_ptr(std::forward<L>(lhs))
>= detail::get_underlying_unique_ptr(std::forward<R>(rhs));
}
template <typename L, typename R
, ENABLE_IF(
is_unique_ptr_propagate_cv<remove_cvref_t<L>>::value
|| is_unique_ptr_propagate_cv<remove_cvref_t<R>>::value
)
>
bool operator<(L&& lhs, R&& rhs) noexcept
{
return detail::get_underlying_unique_ptr(std::forward<L>(lhs))
< detail::get_underlying_unique_ptr(std::forward<R>(rhs));
}
template <typename L, typename R
, ENABLE_IF(
is_unique_ptr_propagate_cv<remove_cvref_t<L>>::value
|| is_unique_ptr_propagate_cv<remove_cvref_t<R>>::value
)
>
bool operator >(L&& lhs, R&& rhs) noexcept
{
return detail::get_underlying_unique_ptr(std::forward<L>(lhs))
> detail::get_underlying_unique_ptr(std::forward<R>(rhs));
}

感谢您的帮助，并提醒我这只是一个传播问题。