向量中的空矢量递归类型
我有一个类型，可以定义为矢量的矢量矢量...的整数类型的矢量。 例：
std::vector<std::vector<std::vector<std::vector< std::vector<signed char> > > > > _data;
我正在寻找一种优雅的方式来确定更深层次的非空向量的数量。 我可以使用4封装循环来做那个例子
for (it0 = data.cbegin() ; it0 != _data.cend() ; ++it0)
for (it1 = *it0.cbegin() ; it1 != *it0.cend() ; ++it1)
for (it2 = *it1.cbegin() ; it2 != *it1.cend() ; ++it2)
for (it3 = *it2.cbegin() ; it3 != *it2.cend() ; ++it3)
nonEmpty += (unsigned int) (*it3.empty());
但是，如何创建一个模板（支持矢量，列表或任何类型的共享同一个API的容器）来为任何深度（超过4个级别）执行此操作？ 我认为递归是正确的方法，但不知道如何使用Template ...
所有的帮助和建议都会受到欢迎，因为我确信有多种解决方案。
下面是一个C ++ 98解决方案，它只使用基本的模板特化：
template<typename T> struct VectorCounter {
/* no count method: this is an error */
};
template<typename U> struct VectorCounter<vector<U> > {
static int count(const vector<U> &v) {
return (int)v.empty();
}
};
template<typename V> struct VectorCounter<vector<vector<V> > > {
static int count(const vector<vector<V> > &v) {
int ret = 0;
for(typename vector<vector<V> >::const_iterator it=v.cbegin(); it!=v.cend(); ++it) {
ret += VectorCounter<vector<V> >::count(*it);
}
return ret;
}
};
template<typename T> int count_nonempty_vectors(const T &v) {
return VectorCounter<T>::count(v);
}
测试以下（此测试代码使用auto作为扩展，因为我很懒）：
#include <iostream>
#include <vector>
using std::vector;
typedef vector<vector<vector<vector<vector<signed char> > > > > data_t;
int count_fixed(const data_t &data) {
int nonEmpty = 0;
for (auto it0 = data.cbegin() ; it0 != data.cend() ; ++it0)
for (auto it1 = it0->cbegin() ; it1 != it0->cend() ; ++it1)
for (auto it2 = it1->cbegin() ; it2 != it1->cend() ; ++it2)
for (auto it3 = it2->cbegin() ; it3 != it2->cend() ; ++it3)
nonEmpty += (unsigned int)(it3->empty());
return nonEmpty;
}
data_t build_data() {
data_t data(5);
int sz = 0;
for (auto it0 = data.begin() ; it0 != data.end() ; ++it0) {
it0->resize(4);
for (auto it1 = it0->begin() ; it1 != it0->end() ; ++it1) {
it1->resize(3);
for (auto it2 = it1->begin() ; it2 != it1->end() ; ++it2) {
it2->resize(2);
it2->at(0).resize(1);
it2->at(1).resize(0);
}
}
}
return data;
};
int main() {
std::cout << count_fixed(build_data()) << std::endl;
std::cout << count_nonempty_vectors(build_data()) << std::endl;
return 0;
}
都打印出“60”。
也许是这样的？ （它使用std::enable_if所以它是一个C ++ 11的答案，但也许你可以使用boost一个）。
template <typename T, typename U>
typename std::enable_if<std::is_same<typename U::value_type,T>::value,std::size_t>::type
non_empties(const U& r)
{
return !r.empty();
}
template <typename T, typename U>
typename std::enable_if<!std::is_same<typename U::value_type,T>::value,std::size_t>::type
non_empties(const U& r)
{
std::size_t res = 0;
for(auto& it : r)
{
res += non_empties<T>(it);
}
return res;
}
用法：
auto non_empty_terminal = non_empties<signed char>(_data);
您必须将“停止”类型作为模板参数，因此可能并不理想。
在这里生活
您可以执行模式匹配来计算深度
template <typename Base>
struct NestedVectors //non vector match
{
static const size_t depth=0;
static size_t count_empty(const Base& b)
{
throw std::string("cant be here");
}
};
template <class Rv>
struct NestedVectors<std::vector<Rv> >
{
static const size_t depth=1 + NestedVectors<Rv>::depth ;
static size_t count_empty(const std::vector<Rv>& vec)
{
size_t r=0;
if(NestedVectors<Rv>::depth == 0)
{
if(vec.empty())
return 1;
}
else
{
for(size_t i =0; i < vec.size() ; ++i)
{
r+=NestedVectors<Rv>::count_empty(vec[i]);
}
}
return r;
}
};
int main()
{
typedef std::vector<
std::vector<
std::vector<
std::vector<
std::vector<
signed char
> > > > > data_t;
data_t t;
std::cout << NestedVectors<data_t>::depth << " " << NestedVectors<data_t>::count_empty(t);
}