Template specification of any kind of array - c++

Question

I'm trying to get rid of void* + size approach to storing arbitrary array types in the same container.
At the moment it looks somewhat like this:
#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;
}
This approach is super error-prone, does not provide any kind of validation, does not allow to easily count or apply algorithms on the elements, so I really want to get rid of it.
Is there some way to tell the compiler that the value will be an array of an arbitrary type? OR is there any other way I can try to avoid the fat_pointer hack?

Answer 1

If you know the types of your arrays up front, you could use std::variant. You can change your fat_pointer struct to hold a variant of type std::pair<T*, T*> where the first and second members of your pair will hold pointers to the start and one past the end of the array respectively. Then have a templated constructor to capture the type of the array.
std::variant will give you the type safety you want. Plus, now that you're storing the begin and end pointers, you can use them with standard algorithms.
If you're going to treat all the arrays is a uniform way, you don't need separate visitor functions in std::visit. You can get type T in std::pair<T*, T*> using:
using T = std::decay_t<decltype(*arg.first)>;
and then use T.
Here's a example:
#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;
}
Output:
1.1 2.2 3.3 4.4 5.5
1 2 3 4 5
Live demo.
If you don't know the type of the arrays you're going to store in advance, then I think you will have to use std::any. You can store a pointer to the array and its size, and have a template member function to do a std::any_cast. But if there are arrays of many different types, you will end up testing against those types at runtime and that can be pretty ugly!
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;
}
};
Here's an example.