Is it possible to create a template that generates a fully const implicitly convertible struct from another struct?

user_29442 0
Viewed 70

I have a problem where I need to bundle an ID with a reference/pointer to a value in C++, e.g.:

struct ProductWithID {
    int id;
    Product* product;
}

Sometimes I want to use this with a mutable Product* so the above will work, but other times I want to pass this to functions when I originally have a const Product*. But now, because I bundled the Product* into a struct, a function that previously looked like:

void HandleProduct(int id) {
    const Product* product = GetProductByID(id); // API returns const Product*
    MyFunction(id, product);
}

void MyFunction(int id, const Product* product);

...can not just be written as:

void HandleProduct(int id) {
    const Product* product = GetProductByID(id);
    MyFunction(ProductWithID{id, product}); // Error: Cannot cast const Product* to Product*
}

void MyFunction(const ProductWithID product);

...since const ProductWithID only has a Product *const not a const Product*. I could create a completely new type called ConstProductWithID and have custom constructors, including implicit cast from ProductWithID, but this feels like boilerplate.

So it would be nice if I could use template magic to simulate the language having a deep_const attribute, like the following:

template <typename T>
struct deep_const {
    // ... template magic goes here ...
}

void MyFunction(deep_const<ProductWithID> product);

What deep_const would do is enumerate all the members of T and declare them fully const. Not just const in terms of pointer, but make whatever the pointers point to const as well. And then also add an implicit constructor, and maybe even aggregate initialization so it's looks, feels and smells like a regular C++ struct. Is this possible? Other suggestions welcome.

c++
1 Answers

Okay, so I solved this by utilizing the nice property that a std:tuple with type T at position N is implicitly convertible to another tuple with type const T at position N:

template<typename T>
class Keyed : public std::tuple<int, T*> {
 public:
  using std::tuple<int, T*>::tuple;

  int id() const {
    return std::get<0>(*this);
  }

  T* value() const {
    return std::get<1>(*this);
  }
};

This gives me a struct-like type with named parameters (using accessors) and I can convert from non-const to const implicitly, e.g.:

Keyed<Product> product;
Keyed<const Product> product2 = product; // Not an error!
user_294420
Related