假设我有一些类层次结构，它有几个virtual函数返回容器引用：
#include <vector>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
class Interface {
public:
virtual const std::vector<int>& getArray() const = 0;
virtual const std::set<int>& getSet() const = 0;
virtual const std::map<int, int>& getMap() const = 0;
};
class SubclassA : public Interface {
public:
const std::vector<int>& getArray() const override { return _vector; }
const std::set<int>& getSet() const override { return _set; }
const std::map<int, int>& getMap() const override { return _map; }
private:
std::vector<int> _vector;
std::set<int> _set;
std::map<int, int> _map;
};
目前，只能在vector类的任何子类中实际返回set，map或Interface。但是，对于vector部分，我可以使用例如gsl::array_view来缓解此限制：
class Interface {
public:
virtual gsl::array_view<const int> getArray() const = 0;
virtual const std::set<int>& getSet() const = 0;
virtual const std::map<int, int>& getMap() const = 0;
};
class SubclassA : public Interface {
public:
gsl::array_view<const int> getArray() const override { return _vector; }
const std::set<int>& getSet() const override { return _set; }
const std::map<int, int>& getMap() const override { return _map; }
private:
std::vector<int> _vector;
std::set<int> _set;
std::map<int, int> _map;
};
class SubclassB : public Interface {
public:
gsl::array_view<const int> getArray() const override { return _array; }
// const std::set<int>& getSet() const override { return _set; }
// const std::map<int, int>& getMap() const { return _map; }
private:
std::array<int, 3> _array;
std::unordered_set<int> _set;
std::unordered_map<int, int> _map;
};
所以问题是，array_view是否可以替代其他容器类型？基本上我想拥有的是一个轻量级对象，我可以从一个函数返回，该函数将作为一个容器的不可变视图而不指定特定的容器类型。将std::set推送到像array_view这样的东西，但支持的操作较少（例如，没有随机访问），我甚至会有意义。 map显然是一个不同的野兽，需要不同的view支持关联查找，但即使是map，我认为有能力说array_view<const std::pair<const int, int>> 。我要求太多了吗？或者也许有合理的方法来实现这个？或者甚至可能存在这种“观点”的现有实现？
PS：继承不是先决条件 - 我只是认为这是解决问题的最简单方法。
答案 0 :(得分：4)
如果您只是在寻找类型清除范围，可以查看boost::any_range：
using IntRange = boost::any_range<
int,
boost::forward_traversal_tag,
int,
std::ptrdiff_t>;
int sum(IntRange const& range) {
return std::accumulate(range.begin(), range.end(), 0);
}
int main()
{
std::cout << sum(std::vector<int>{1, 2, 3}) << std::endl; // OK, 6
std::cout << sum(std::set<int>{4, 5, 6}) << std::endl; // OK, 15
}
即使你试图滥用它：
sum(std::map<int, int>{})
错误信息并不可怕：
/usr/local/include/boost/range/detail/any_iterator_wrapper.hpp:40:60: error: invalid static_cast from type 'std::pair<const int, int>' to type 'int&'
return static_cast<Reference>(const_cast<T&>(x));
^
您可以为您的用例创建别名：
template <typename T>
using FwdImmutableRangeT = boost::any_range<T,
boost::forward_traversal_tag,
const T&, std::ptrdiff_t>;
返回那些：
class Interface {
public:
virtual FwdImmutableRange<int> getArray() const = 0;
virtual FwdImmutableRange<const int> getSet() const = 0;
virtual FwdImmutableRange<std::pair<const int, int>> getMap() const = 0;
};
答案 1 :(得分：1)
我不知道一个，但对于给定的一组接口的一般视图并不难写。您可以通过手动vtable使用类型擦除来保持分配免费。
存储pvoid和指向函数表的指针。每个函数都会擦除一个操作的类型依赖性。
如果操作具有签名R(Args...)，则表中的擦除函数指针具有签名R(void*, Args...)。我使用无状态lambdas将它们写在一个vtable工厂中，该工厂构造一个静态本地vtable并返回一个指向const vtable的指针。
面向用户的类公开操作，将它们转发到vtable。它有一个模板ctor，它将pvoid存储到传递的值中，并从工厂获取特定于类型的vtable。
您必须小心处理视图类的复制/移动：模板ctor SFINAE应该防止接受视图类实例。
令人讨厌的部分是你要么必须为关联容器的工作方式定义新的语义，要么你还需要键入擦除它们的迭代器。在视图中，因为迭代器被认为是有价值的。这是vector的一大优势，因为可以使用T*代替！
现在我想起来了，boost有类型擦除迭代器，可能还有关联容器的视图。
如果我们只是想要＆＃34;它在那里＆＃34;功能（和＃34;它是什么＆＃34;对于地图），你不需要迭代，这很容易：
namespace details {
template<class K>
using exists = bool(*)(void*, K const&);
template<class K, class V>
using get = V(*)(void*, K const&);
template<class T>
struct setlike_vtable {
exists<T> pexists = 0;
template<class S>
static void ctor( setlike_vtable* table ) {
table->pexists = [](void* p, T const& k)->bool {
S*ps = static_cast<S*>(p);
return ps->find(k) != ps->end();
};
}
template<class S>
static setlike_vtable const* make() {
static const setlike_vtable retval = []{
setlike_vtable retval;
ctor<S>(&retval);
return retval;
}();
return &retval;
}
};
template<class K, class V>
struct maplike_vtable : setlike_vtable<K> {
get<K,V> pget = 0;
template<class S>
static void ctor( maplike_vtable* table ) {
setlike_vtable<K>::template ctor<S>(table);
table->pget = [](void* p, K const& k)->V {
S*ps = static_cast<S*>(p);
return ps->find(k)->second;
};
}
template<class S>
static maplike_vtable const* make() {
static const maplike_vtable retval = []{
maplike_vtable retval;
ctor<S>(&retval);
return retval;
}();
return &retval;
}
};
}
template<class T>
struct set_view {
details::setlike_vtable<T> const* vtable = 0;
void* pvoid = 0;
template<class U,
std::enable_if_t<!std::is_same<std::decay_t<U>, set_view>{}, int> =0
>
set_view(U&& u):
vtable( details::setlike_vtable<T>::template make<std::decay_t<U>>() ),
pvoid( const_cast<void*>( static_cast<void const*>( std::addressof(u) ) ) )
{}
set_view(set_view const&)=default;
set_view() = default;
~set_view() = default;
set_view& operator=(set_view const&)=delete;
explicit operator bool() const { return vtable; }
bool exists( T const&t ) const {
return vtable->pexists( pvoid, t );
}
};
template<class K, class V>
struct map_view {
details::maplike_vtable<K, V> const* vtable = 0;
void* pvoid = 0;
template<class U,
std::enable_if_t<!std::is_same<std::decay_t<U>, map_view>{}, int> =0
>
map_view(U&& u):
vtable( details::maplike_vtable<K,V>::template make<std::decay_t<U>>() ),
pvoid( const_cast<void*>( static_cast<void const*>( std::addressof(u) ) ) )
{}
map_view(map_view const&)=default;
map_view() = default;
~map_view() = default;
map_view& operator=(map_view const&)=delete;
explicit operator bool() const { return vtable; }
bool exists( K const&k ) const {
return vtable->pexists( pvoid, k );
}
V get( K const& k ) const {
return vtable->pget( pvoid, k );
}
};
请注意，如果您不希望map_view< Key, Value const& >按值返回，则通常需要get。
通过访问进行迭代非常简单，但要求传入的访问者进行类型删除（简称为std::function）。通过迭代器进行迭代需要类型擦除迭代器，并且类型擦除迭代器必须具有值语义。那时，你最好窃取boost的实施。
现在提出的协同程序提供了另一种解决问题的方法;使用类型擦除的视图使用协同程序来实现枚举而不是访问。
我敢打赌，上述观点略快于boost::any_range，因为设计工作量较少。您可以通过将vtable移动到视图正文中的内联来移除它，从而消除缓存未命中;对于较大类型的擦除，这可能导致运行时内存膨胀，但上述类型擦除视图在vtable中存储1-2个指针。指向1-2指针的指针似乎很愚蠢。