c++ - 重铸空指针容器

Question

精简版

我可以reinterpret_cast一个std::vector<void*>*到 std::vector<double*>* ？

其他 STL 容器呢？

长版

我有一个函数可以将 void 指针的 vector 重铸为由模板参数指定的数据类型:

template <typename T>
std::vector<T*> recastPtrs(std::vector<void*> const& x) {
    std::vector<T*> y(x.size());
    std::transform(x.begin(), x.end(), y.begin(),
            [](void *a) { return static_cast<T*>(a); } );
    return y;
}

但我认为复制 vector 内容并不是真正必要的，因为我们实际上只是在重新解释所指向的内容。

经过一些修补，我想到了这个:

template <typename T>
std::vector<T*> recastPtrs(std::vector<void*>&& x) {
    auto xPtr = reinterpret_cast<std::vector<T*>*>(&x);
    return std::vector<T*>(std::move(*xPtr));
}

所以我的问题是:

• 像这样重新解释_cast 整个 vector 是否安全？
• 如果它是不同类型的容器(如 std::list 或 std::map )怎么办？明确地说，我的意思是转换 std::list<void*>至 std::list<T*> ，而不是在 STL 容器类型之间进行转换。
• 我仍在努力思考 move 语义。我做得对吗？

还有一个后续问题:生成 const 的最佳方法是什么？没有代码重复的版本？即定义

std::vector<T const*> recastPtrs(std::vector<void const*> const&);
std::vector<T const*> recastPtrs(std::vector<void const*>&&);

MWE

#include <vector>
#include <algorithm>
#include <iostream>

template <typename T>
std::vector<T*> recastPtrs(std::vector<void*> const& x) {
    std::vector<T*> y(x.size());
    std::transform(x.begin(), x.end(), y.begin(),
            [](void *a) { return static_cast<T*>(a); } );
    return y;
}

template <typename T>
std::vector<T*> recastPtrs(std::vector<void*>&& x) {
    auto xPtr = reinterpret_cast<std::vector<T*>*>(&x);
    return std::vector<T*>(std::move(*xPtr));
}

template <typename T>
void printVectorAddr(std::vector<T> const& vec) {
    std::cout<<"  vector object at "<<&vec<<", data()="<<vec.data()<<std::endl;
}

int main(void) {
    std::cout<<"Original void pointers"<<std::endl;
    std::vector<void*> voidPtrs(100);
    printVectorAddr(voidPtrs);

    std::cout<<"Elementwise static_cast"<<std::endl;
    auto dblPtrs = recastPtrs<double>(voidPtrs);
    printVectorAddr(dblPtrs);

    std::cout<<"reintepret_cast entire vector, then move ctor"<<std::endl;
    auto dblPtrs2 = recastPtrs<double>(std::move(voidPtrs));
    printVectorAddr(dblPtrs2);
}

示例输出:

Original void pointers
  vector object at 0x7ffe230b1cb0, data()=0x21de030
Elementwise static_cast
  vector object at 0x7ffe230b1cd0, data()=0x21de360
reintepret_cast entire vector, then move ctor
  vector object at 0x7ffe230b1cf0, data()=0x21de030

请注意 reinterpret_cast版本重用底层数据结构。

以前提出的似乎不相关的问题

这些是我尝试搜索时出现的问题:

reinterpret_cast vector of class A to vector of class B

reinterpret_cast vector of derived class to vector of base class

reinterpret_cast-ing vector of one type to a vector of another type which is of the same type

引用严格的别名规则，对这些问题的回答是一致的“否”。但我认为这不适用于我的情况，因为被重铸的 vector 是一个右值，所以没有混叠的机会。

为什么我要这样做

我正在与一个 MATLAB 库交互，它给我的数据指针为 void*以及指示数据类型的变量。我有一个函数可以验证输入并将这些指针收集到一个 vector 中:

void parseInputs(int argc, mxArray* inputs[], std::vector<void*> &dataPtrs, mxClassID &numericType);

我无法将这部分模板化，因为直到运行时才知道类型。另一方面，我有数字例程来对已知数据类型的 vector 进行操作:

template <typename T>
void processData(std::vector<T*> const& dataPtrs);

所以我只是想把一个连接到另一个:

void processData(std::vector<void*>&& voidPtrs, mxClassID numericType) {
    switch (numericType) {
        case mxDOUBLE_CLASS:
            processData(recastPtrs<double>(std::move(voidPtrs)));
            break;
        case mxSINGLE_CLASS:
            processData(recastPtrs<float>(std::move(voidPtrs)));
            break;
        default:
            assert(0 && "Unsupported datatype");
            break;
    }
}

Answer 1

鉴于您从 C 库(类似于 malloc)收到 void * 的评论，看来我们可以将问题的范围缩小很多。

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

对于这种情况，您可以很容易地创建自己的包装器，使您可以像 vector 一样访问数据——定义一个 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())应该是相当明显的，但我并没有真正努力将所有内容都包含在这里，因为剩下的大部分内容比教育更重复、更乏味。

这足以以大多数典型的类似 vector 的方式使用 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';
    }
}

请注意，这根本不会尝试处理复制/move 构造，也不会处理破坏。至少按照我的表述，array_view 是一些现有数据的非拥有 View 。在适当的时候销毁数据取决于您(或者至少是 array_view 之外的东西)。因为我们没有破坏数据，所以我们可以毫无问题地使用编译器生成的复制和 move 构造函数。我们不会通过指针的浅拷贝获得双重删除，因为当 array_view 被销毁时我们不会执行任何删除。