Question

有没有办法检查序列容器在内存中是否连续？类似的东西：

#include <iostream>
#include <vector>
#include <deque>
#include <array>

int main()
{
    std::cout << std::boolalpha;
    std::cout << is_contiguous<std::vector<int>>::value   << '\n'  // true
    std::cout << is_contiguous<std::deque<int>>::value    << '\n'; // false
    std::cout << is_contiguous<std::array<int, 3>>::value << '\n'; // true
}

澄清

这个问题是指类型特征，而不是特定类型实例的属性。

Answer 1

否，没有编译时间特性。

draft C++1z Standard将连续性定义为迭代器范围的运行时属性。注意，没有与此迭代器类别对应的编译时std::contiguous_iterator_tag。

24.2迭代器要求[iterator.requirements]

24.2.1一般[iterator.requirements.general]

5个迭代器，进一步满足要求，对于积分   值n和可解除引用的迭代器值a和(a + n), *(a + n)   相当于*(addressof(*a) + n)，称为连续   迭代器。 [注意：例如，类型“指向int的指针”是一个   连续的迭代器，但reverse_iterator<int *>不是。有效   具有可解除引用的[a,b)的迭代器范围a，相应的范围   由指针表示[addressof(*a),addressof(*a) + (b - a)); b   可能不会被解除引用。 - 结束说明]

在运行时测试此方法的一种方法是

#include <array>
#include <deque>
#include <list>
#include <iostream>
#include <iterator>
#include <map>
#include <memory>
#include <string>
#include <unordered_set>
#include <vector>

template<class I>
auto is_contiguous(I first, I last)
{ 
    auto test = true;
    auto const n = std::distance(first, last);
    for (auto i = 0; i < n && test; ++i) {
        test &= *(std::next(first, i)) == *(std::next(std::addressof(*first), i));
    }        
    return test;        
}

int main()
{
    auto l = std::list<int> { 1, 2, 3 };
    auto m = std::map<int, int>  { {1, 1}, {2,2}, {3,3} };
    auto u = std::unordered_multiset<int> { 1, 1, 1 };
    auto d = std::deque<int>(4000);
    int c[] = { 1, 2, 3 };
    auto a = std::array<int, 3> {{ 1, 2, 3 }};
    auto s = std::string {"Hello world!"};
    auto v = std::vector<int> { 1, 2, 3, };

    std::cout << std::boolalpha << is_contiguous(l.begin(), l.end()) << "\n";
    std::cout << std::boolalpha << is_contiguous(m.begin(), m.end()) << "\n";
    std::cout << std::boolalpha << is_contiguous(u.begin(), u.end()) << "\n";
    std::cout << std::boolalpha << is_contiguous(d.begin(), d.end()) << "\n";
    std::cout << std::boolalpha << is_contiguous(d.begin(), d.begin() + 1000) << "\n";
    std::cout << std::boolalpha << is_contiguous(std::begin(c), std::end(c)) << "\n";
    std::cout << std::boolalpha << is_contiguous(a.begin(), a.end()) << "\n";
    std::cout << std::boolalpha << is_contiguous(s.begin(), s.end()) << "\n";
    std::cout << std::boolalpha << is_contiguous(v.begin(), v.end()) << "\n";
    std::cout << std::boolalpha << is_contiguous(v.rbegin(), v.rend()) << "\n";
}

Live Example。这会打印false，list和map以及unordered_multimap的C阵列true和std::array，{{1} }和string。对于大型子范围，它会为vector和true中的小子范围打印deque。它还为包含反向迭代器的迭代器范围打印false。

更新：由@ T.C评论。最初的N3884提案确实有

false

这样迭代器类别上的tag-dispatching就不会中断。但是，这会破坏struct contiguous_iterator_tag : random_access_iterator_tag {};上的类模板特化的非惯用代码。因此，当前草案不包含新的迭代器类别标记。

Answer 2

没有。 C ++标准保证不存在漏报。（即，std::vector，std::string，std::array和基本数组被承诺连续存储。

但是，C ++标准不保证没有误报。

int main() {
   std::unique_ptr<Node> n1(new Node);
   std::unique_ptr<Node> n2(new Node);
   n1->next = n2; // n1 and n2 might be contiguous, but might not be
}

因此，您的类型特征在某些时候可能是错误的。如果在某些时候出错，那就不是类型特征;相反，它是一个实例特征。

检查序列容器是否在内存中是连续的

3 个答案: