用const std:：vector包装现有内存？

Question

好的，我最近了解到（a）std:：vector根据定义/标准使用连续内存，因此（b）

void printem(size_t n, int* iary)
{ for (size_t i=0; i<n; ++i) std::cout << iary[i] << std::endl; }
void doublem(size_t n, int* iary)
{ for (size_t i=0; i<n; ++i) iary[i] *= 2; }

std::vector<int> v;
for (size_t i=0; i<100; ++i) v.push_back(i);
int* iptr = &(v[0]);
doublem(v.size(), iptr);
printem(v.size(), iptr);

好吧，这很酷，但我想换个方向。我有很多现有的代码，比如

double computeSomething(const std::vector<SomeClass>& v) { ... }

如果我有一个对象的C数组，我可以使用这样的代码：

SomeClass cary[100]; // 100*sizeof(SomeClass)
// populate this however
std::vector<SomeClass> v;
for (size_t i=0; i<100; ++i) v.push_back(cary[i]);
// now v is also using 100*sizeof(SomeClass)
double x = computeSomething(v);

我想这样做，（a）没有额外的空间，（b）没有额外的时间将所有数据的冗余副本插入向量。请注意，“只改变你愚蠢的计算方式，白痴”是不够的，因为有数千个这样的函数/方法展示了这种模式，而这些函数/方法不在我的控制之下，即使它们太多了，无法全部改变。

还要注意，因为我只对const std:：vector感兴趣

namespace std { template <typename T> class vector {
  vector() { ... }
  vector(size_t n) { ... }
  vector(size_t n, const T& t) { ... }
  const vector(size_t n, T*) { ... } // can this be done?
...

如果这是不可能的，那么从std:：vector派生的容器std:：const_vector怎么样？它（a）可以从指向c数组和大小的指针构造，并且（b）故意不实现非常量方法（push_back、resize等），因此即使typename为const_vector的对象实际上不是常量对象，只提供const方法的接口实际上是const（任何错误的修改尝试都会在编译时被捕获）？

更新：有点混乱表明，这“解决”了我在Windows上实现std:：vector时遇到的问题：

template <typename T>
class vector_tweaker : public std::vector<T> {
public:
  vector_tweaker(size_t n, T* t) {
    _saveMyfirst = _Myfirst;
    _saveMylast  = _Mylast;
    _saveMyend   = _Myend;
    _Myfirst = t;
    _Mylast  = t + n;
    _Myend   = t + n;
  }
  ~vector_tweaker() {
    _Myfirst = _saveMyfirst;
    _Mylast  = _saveMylast;
    _Myend   = _saveMyend; // and proceed to std::vector destructor
  }
private:
  T* _saveMyfirst;
  T* _saveMylast;
  T* _saveMyend;
};

但当然，这个解决方案是可怕的，因为（a）它不能提供保护，防止基类通过调整大小（）或push_back（）删除原始内存（除了一个谨慎的用户只构造constvector_tweaker()) -- 和（b）它是特定于std::向量的特定实现，并将不得不为其他人重新实现-如果确实其他平台只声明他们的std::向量成员数据是受保护的：就像微软做的那样（似乎是个坏主意）。

Answer 1

您可以尝试使用std::C11中引入的引用逻辑存储reference_wrapper

SomeClass cary[100];
// ...
std::vector<std::reference_wrapper<SomeClass>> cv;
cv.push_back(cary[i]);   // no object copying is done, reference wrapper is stored

或者不使用C11，您可以为bytes-char创建此类模板类的专门化。然后对于char*C-array中的构造函数，您可以使用：：memcpy：不幸的是，这将使用两倍的内存。

::memcpy(&v[0], c_arr, n);

比如：

template <typename T> class MyVector : public std::vector<T> {
};

template <> class MyVector<char> : public std::vector<char> {
    public:
    MyVector<char>(char* carr, size_t n) : std::vector<char>(n) {
        ::memcpy(&operator[](0), carr, n);
    }
};

我建议-尽可能将所有C数组替换为向量，然后不需要额外的复制。