c ++ - 如何正确重载运算符以从 __generic_buffer 进行隐式类型转换<void*>到 __generic_buffer<const void*> ?

Question

To put it simple, i have the following code:

template<typename p>
requires(std::is_pointer<p>::value)
struct __generic_buffer 
{
    p baseptr;
    size_t size;

    // member functions go here
};

using buffer = __generic_buffer<void*>;
using const_buffer = __generic_buffer<const void*>;

and i want to be able to write something like that:

uint8_t arr[64];
buffer b {arr, 64};
const_buffer cb = b;

so basically i want buffer pointing to modifiable memory area to be freely castable to const_buffer pointing to constant memory area, but not the other way around, just how usual pointers behave. Also, i'd prefer this conversion to work with any other instantiation of __generic_buffer , eg __generic_buffer<int*> to __generic_buffer<const int*> .

Answer 1

First things first. Types with __ in them are reserved by the C++ standard for your compiler and the standard library. Use of them in programs makes your program ill-formed, no diagnostic required. (also, _T starting with an _ and then a capital letter).

This kind of bad habit comes from copying the coding style of std headers and the like. They are allowed to do that, and in fact must do that, because if they called something bob , someone could legally #define bob alice and break the header file.

---

There are two ways to do what you want.

One of them involves writing a converting constructor, the other a converting operator.

I'll show the operator way.

template<class P>
requires(std::is_pointer<P>::value)
struct generic_buffer 
{
  P baseptr;
  size_t size;

  template<class U>
  requires(std::is_same<std::remove_cv_t<std::remove_pointer_t<U>>, std::remove_pointer_t<P>>::value)
  operator generic_buffer<U>() const {
    return {baseptr, size};
  }
  // member functions go here
};

I might write a trait rather than do that requires inline, but basically we check if *U is the same type as *P after removing const and volatile from *U .

If so, we allow this conversion operator to exist.

Inside, we use implicit conversion to convert the pointer types.

Now, this isn't perfect , because we really want to check if removing either of const, volatile or both would make it match. You might want to write a type function that does that test.

The constructor way is just the above, but backwards. Declaring a constructor has some impact on the automatic constructors and the triviality of a type, while an operator like this doesn't, so to avoid having to digress into those issues I implemented it as an operator.