假设我有一个堆栈,其中包含int
的共享指针,如下所示:
#include <stack>
#include <memory>
using namespace std;
int main()
{
stack<shared_ptr<int>> s1;
stack<shared_ptr<int>> s2;
shared_ptr<int> v1 = make_shared<int>(1);
shared_ptr<int> v2 = make_shared<int>(1);
s1.push(v1);
s2.push(v2);
bool areEqual = s1 == s2; // This is false
}
如何使堆栈比较shared_ptr
指向的实际值而不是指针本身?
std::stack
有一个受保护的成员c
,它是底层容器类型的一个实例。您可以创建一个访问该变量的堆栈包装器,然后比较底层容器的内容,如下所示:
#include <iostream>
#include <stack>
#include <memory>
#include <algorithm>
using namespace std;
template<class stack_type>
struct stack_wrapper : stack_type
{
auto begin() const
{
return stack_type::c.begin();
}
auto end() const
{
return stack_type::c.end();
}
};
template<class stack_type>
const stack_wrapper<stack_type> &wrap(const stack_type &stack)
{
return static_cast<const stack_wrapper<stack_type> &>(stack);
}
int main() {
stack<shared_ptr<int>> s1;
stack<shared_ptr<int>> s2;
shared_ptr<int> v1 = make_shared<int>(1);
shared_ptr<int> v2 = make_shared<int>(1);
s1.push(v1);
s2.push(v2);
const auto &s1wrapper = wrap(s1);
const auto &s2wrapper = wrap(s2);
const auto is_equal = std::equal(s1wrapper.begin(),
s1wrapper.end(),
s2wrapper.begin(),
s2wrapper.end(),
[](auto &first, auto &second) {
return first && second && *first == *second;
});
std::cout << is_equal << std::endl;
}
我喜欢@RealFresh's answer。它精确地展示了如何“封装”受保护的可访问性。但是,将基类子对象引用强制转换为派生类子对象引用,然后将其视为一个可能会导致未定义的行为。
然而,提取c
成员的想法是合理的。我们可以通过一个简单的实用程序来实现它而没有UB的风险:
template<class S>
constexpr decltype(auto) stack_c(S&& s) {
using base = std::decay_t<S>;
struct extractor : base {
using base::c;
};
constexpr auto c_ptr = &extractor::c;
return std::forward<S>(s).*c_ptr;
}
由于表达式&extractor::c
works,我们实际上获得了指向base
(std::stack
专业化)成员的指针,名为c
。 extractor
的目的是通过使用声明公开访问该名称。
然后我们转发对它的引用,保留值类别和所有。在@ RealFresh使用std::equal
的建议中,这是一个替代品:
bool areEqual = std::equal(
stack_c(s1).begin(), stack_c(s1).end(),
stack_c(s2).begin(), stack_c(s2).end(),
[](auto const& p1, auto const& p2) {
return first && second && (p1 == p2 || *p1 == *p2);
}
);