考虑到您从C库(类似malloc)接收void *的注释，我们似乎可以将问题缩小很多。

特别是，我想你真的在处理一个更像array_view而不是vector的东西。也就是说，您想要的东西可以让您干净地访问一些数据。您可能会更改该集合中的单个项，但永远不会更改整个集合(例如，您不会尝试执行可能需要扩展内存分配的push_back)。

对于这种情况，您可以很容易地创建一个自己的包装器，为您提供对数据的矢量式访问——定义一个iterator类型，具有begin()和end()(如果您愿意，还有其他类型，如rbegin()/rend()、cbegin()/cend()和crbegin()/crend())，以及一个执行范围检查索引的at()，等等

因此，一个相当的最小版本可能看起来像这样：

#pragma once
#include <cstddef>
#include <stdexcept>
#include <cstdlib>
#include <iterator>
template <class T> // note: no allocator, since we don't do allocation
class array_view {
T *data;
std::size_t size_;
public:
array_view(void *data, std::size_t size_) : data(reinterpret_cast<T *>(data)), size_(size_) {}
T &operator[](std::size_t index) { return data[index]; }
T &at(std::size_t index) { 
if (index > size_) throw std::out_of_range("Index out of range");
return data[index];
}

std::size_t size() const { return size_; }
typedef T *iterator;
typedef T const &const_iterator;
typedef T value_type;
typedef T &reference;
iterator begin() { return data; }
iterator end() { return data + size_; }
const_iterator cbegin() { return data; }
const_iterator cend() { return data + size_; }
class reverse_iterator {
T *it;
public:
reverse_iterator(T *it) : it(it) {}
using iterator_category = std::random_access_iterator_tag;
using difference_type = std::ptrdiff_t;
using value_type = T;
using pointer = T *;
using reference = T &;
reverse_iterator &operator++() { 
--it;
return *this;
}
reverse_iterator &operator--() {
++it;
return *this;
}
reverse_iterator operator+(size_t size) const { 
return reverse_iterator(it - size);
}
reverse_iterator operator-(size_t size) const { 
return reverse_iterator(it + size);
}
difference_type operator-(reverse_iterator const &r) const { 
return it - r.it;
}
bool operator==(reverse_iterator const &r) const { return it == r.it; }
bool operator!=(reverse_iterator const &r) const { return it != r.it; }
bool operator<(reverse_iterator const &r) const { return std::less<T*>(r.it, it); }
bool operator>(reverse_iterator const &r) const { return std::less<T*>(it, r.it); }
T &operator *() { return *(it-1); }
};
reverse_iterator rbegin() { return data + size_; }
reverse_iterator rend() { return data; }    
};

我已经尽力展示了如何添加大部分缺失的功能(例如，crbegin()/crend())，但我并没有真正努力地将所有内容都包括在这里，因为剩下的大部分内容比教育内容更重复、更乏味。

这足以在大多数典型的类似矢量的方式中使用array_view。例如：

#include "array_view"
#include <iostream>
#include <iterator>
int main() { 
void *raw = malloc(16 * sizeof(int));
array_view<int> data(raw, 16);
std::cout << "Range based:n";
for (auto & i : data)
i = rand();
for (auto const &i : data)
std::cout << i << 'n';
std::cout << "niterator-based, reverse:n";
auto end = data.rend();
for (auto d = data.rbegin(); d != end; ++d)
std::cout << *d << 'n';
std::cout << "Forward, counted:n"; 
for (int i=0; i<data.size(); i++) {
data[i] += 10;
std::cout << data[i] << 'n';
}
}

请注意，这根本不涉及复制/移动构造，也不涉及销毁。至少正如我所表述的，array_view是对一些现有数据的非拥有视图。在适当的时候销毁数据取决于您(或者至少是array_view之外的东西)。由于我们没有破坏数据，我们可以毫无问题地使用编译器生成的复制和移动构造函数。我们不会因为对指针进行浅层复制而得到双重删除，因为当array_view被销毁时，我们不会进行任何删除。

不，在标准C++中不能做任何类似的事情。

严格的别名规则规定，要访问T类型的对象，必须使用T类型的表达式；除了一个很短的例外列表。

经由void *表达式访问double *不是这样的例外；更不用说每个的向量了。如果您通过右值访问T类型的对象，也不是例外。