任何类型数组的模板规范

Question

我正在尝试摆脱 void* + size 在同一容器中存储任意数组类型的方法。

目前看起来有点像这样：

#include <iostream>
#include <map>
#include <string>
#include <cstddef>

struct fat_pointer {
  void *data;
  size_t size;
  size_t count;

  fat_pointer() : data(nullptr), size(0), count(0)
  {
  }

  fat_pointer(void *data_, size_t size_, size_t count_) :
    data(data_), size(size_), count(count_)
  {
  }

  bool valid() const {
    return data != nullptr;
  }

  template <typename T>
  const T as() {
    return static_cast<T>(data);
  }
};

int main(int argc, char* argv[])
{
  // data can be anything, these two are just for example
  const double v1[] = {1.1, 2.2, 3.3, 4.4, 5.5};
  const int v2[] = {1, 2, 3, 4, 5};

  std::map<std::string, fat_pointer> data;

  data.insert(std::pair<std::string, fat_pointer>("V1", fat_pointer((void*)v1, sizeof(v1[0]), sizeof(v1) / sizeof(v1[0]))));
  data.insert(std::pair<std::string, fat_pointer>("V2", fat_pointer((void*)v2, sizeof(v2[0]), sizeof(v2) / sizeof(v2[0]))));

  auto values = data["V1"];

  if (values.valid()) {
    std::cout << values.as<double*>()[2] << std::endl;
  }

  return 0;
}

这种方法非常容易出错，不提供任何类型的验证，不允许对元素轻松计数或应用算法，所以我真的想摆脱它。

有没有办法告诉编译器该值将是一个任意类型的数组？或者有没有其他方法可以避免fat_pointer hack？

Answer 1

如果您事先知道数组的类型，则可以使用std::variant。您可以更改fat_pointer 结构以保存std::pair<T*, T*> 类型的变体，其中first 和second 成员将分别保存指向数组开头和结尾的指针。然后有一个模板化的构造函数来捕获数组的类型。

std::variant 会给你你想要的类型安全。另外，现在您存储了开始和结束指针，您可以将它们与标准算法一起使用。

如果您要以统一的方式处理所有数组，则不需要std::visit 中的单独访问者函数。你可以在std::pair<T*, T*> 中输入T 使用：

using T = std::decay_t<decltype(*arg.first)>;

然后使用T。

这是一个例子：

#include <iostream>
#include <iomanip>
#include <variant>
#include <vector>
#include <iterator>
#include <algorithm>

using PairVariant = std::variant<std::pair<const int*, const int*>, std::pair<const double*, const double*>>;

struct fat_pointer {
  PairVariant mPtrs;
  
  template<typename T>
  fat_pointer(T* begin, T* end): mPtrs{std::pair<T*, T*>(begin, end)} {}

};

int main()
{
    const double v1[] = {1.1, 2.2, 3.3, 4.4, 5.5};
    const int v2[] = {1, 2, 3, 4, 5};

    fat_pointer ptr1{v1, std::end(v1)};
    fat_pointer ptr2{v2, std::end(v2)};

    std::vector<fat_pointer> vec{ptr1, ptr2};

    for (auto& v: vec) {
        std::visit([] (auto&& arg) {
            using T = std::decay_t<decltype(*arg.first)>;  //type of T in std::pair<T*, T*>
            std::copy (arg.first, arg.second, std::ostream_iterator<T>(std::cout, " "));
        }, v.mPtrs);

        std::cout << std::endl;
    }
    
    return 0;
}

输出：

1.1 2.2 3.3 4.4 5.5 
1 2 3 4 5 

直播demo.

---

如果您事先不知道要存储的数组的类型，那么我认为您将不得不使用std::any。您可以存储指向数组及其大小的指针，并有一个模板成员函数来执行std::any_cast。但是，如果有许多不同类型的数组，您最终会在运行时针对这些类型进行测试，这可能会非常难看！

struct fat_pointer {
    std::any mPtr;
    std::size_t mSize;

    template<typename T>
    fat_pointer(T* begin, T* end): mPtr{begin}, mSize(end-begin) {}

    template<typename T>
    T AnyCast()
    {
        if (T* ptr = std::any_cast<T>(&mPtr)) {
            return *ptr;
        }
        return nullptr;
    }
};

这是example。