Hfrhyu

device_raw_ptr is a simple fancy pointer. It essentially wrap pointers to GPU memory. It's sole purpose is to separate out host pointers from device pointers, i.e. they should not be inter-convertible and must not be dereferenced. At the same time, they should be zero-cost (with respect to raw host pointers) and be maximally compatible with regular pointers.

Helper class:

template <class T>
struct equality_operators 
 /* 
 ** The deriving class must implement the following:
 ** friend bool operator==(const T&, const T&);
 */

 friend bool operator!=(const T& lhs, const T& rhs) return !static_cast<bool>(lhs == rhs); 
;

template <class T>
struct less_than_operators 
 /* 
 ** The deriving class must implement the following:
 ** friend bool operator<(const T&, const T&);
 */

 friend bool operator>(const T& lhs, const T& rhs) return rhs < lhs; 
 friend bool operator<=(const T& lhs, const T& rhs) return !static_cast<bool>(lhs > rhs); 
 friend bool operator>=(const T& lhs, const T& rhs) return !static_cast<bool>(lhs < rhs); 
;

template <class T>
struct relational_operators : equality_operators<T>, less_than_operators<T> ;

device_raw_ptr implementation:

template <class T>
 class device_raw_ptr : public relational_operators<T> 
 static_assert(std::is_standard_layout<T>::value, "T must satisfy StandardLayoutType");
 public:
 using element_type = std::remove_extent_t<T>;

 constexpr device_raw_ptr() noexcept = default;
 constexpr device_raw_ptr(std::nullptr_t) noexcept : ptr nullptr 
 constexpr device_raw_ptr(const device_raw_ptr& other) noexcept = default;
 explicit device_raw_ptr(element_type* ptr_) noexcept : ptr ptr_ 
 device_raw_ptr(device_raw_ptr&& other) noexcept : ptr other.ptr other.reset(); 

 device_raw_ptr& operator=(const device_raw_ptr& other) noexcept 
 swap(device_raw_ptr(other), *this); 
 return *this;
 

 device_raw_ptr& operator=(device_raw_ptr&& other) noexcept 
 swap(device_raw_ptr(other), *this);
 return *this;
 

 void reset() noexcept ptr = nullptr; 
 void reset(T* ptr_) noexcept ptr = ptr_; 

 element_type* get() noexcept return ptr; ;
 const element_type* get() const noexcept return ptr; 

 friend void swap(device_raw_ptr& lhs, device_raw_ptr& rhs) noexcept 
 using std::swap;
 std::swap(lhs.ptr, rhs.ptr);
 

 explicit operator bool() const noexcept return static_cast<bool>(ptr); 

 device_raw_ptr& operator++() noexcept 
 ++ptr;
 return *this;
 

 device_raw_ptr operator++(int) noexcept 
 device_raw_ptr tmp(*this);
 ptr++;
 return tmp;
 

 device_raw_ptr& operator+=(std::ptrdiff_t offset) noexcept 
 ptr += offset;
 return *this;
 

 device_raw_ptr& operator-=(std::ptrdiff_t offset) noexcept 
 ptr -= offset;
 return *this;
 

 friend device_raw_ptr& operator+(device_raw_ptr lhs, std::ptrdiff_t offset) noexcept 
 lhs += offset;
 return lhs;
 

 friend device_raw_ptr& operator-(device_raw_ptr lhs, std::ptrdiff_t offset) noexcept 
 lhs -= offset;
 return lhs;
 

 /* required by relational_operators base class */
 friend bool operator==(const device_raw_ptr& lhs, const device_raw_ptr& rhs) noexcept return lhs.ptr == rhs.ptr; 
 friend bool operator<(const device_raw_ptr& lhs, const device_raw_ptr& rhs) noexcept return lhs.ptr < rhs.ptr; 

 protected:
 T *ptr;
 ;

 template <class T, class U, class V>
 std::basic_ostream<U, V>& operator<<(std::basic_ostream<U, V>& os, const device_raw_ptr<T>& other) 
 os << other.get() << " (device)";
 return os;
 

I am also looking for suggestions on how to order different things inside a class.

Might it be better to initialize with nullptr instead of the default constructor. This breaks compatibility but I think it might be worth considering the compiler would mostly optimize the assignment if it's immediately overwritten.

1. device_raw_ptr is extremely cheap to copy, so remove all hints of move-semantics and use of swap().




2. Now you can remove the copy-constructor and copy-assignment, as there is no need to explicitly declare them. Especially making them user-defined must be avoided to keep them trivial.




3. Kudos on trying to use the approved two-step for swap(). Though you get a failing grade anyway because you bungled it by using a qualified call in the second part. Hopefully, C++20 will abolish that nonsense by introducing customization point objects.




4. Yes, you should pass your device_raw_ptr by value if you have the choice, as it is a tiny trivial type. Still, refrain from returning a reference to such a temporary.




5. There is no reason operator-(device_raw_ptr, std::ptrdiff_t) should not be constexpr. Aside from your implementation for some reason delegating to operator-=, which is not. Same for operator+ which uses operator+=.




6. Is there any reason you don't support subtracting a device_raw_ptr from another?




7. I'm really puzzled why you make the only data-member protected instead of private.

Helper classes

There is no need to use static_cast<bool> for your comparisons. The relational operators are already bool values. (If they are not, that is a problem with the definition of the operator for the type T.)

The standard <utility> header provides definitions for operator!= (from operator==) and operator>, operator<=, and operator>= (from operator<). There is no need for you to define those four operators if you have the other two (equality and less-than).

Why do you have the relational_operators struct at all? It shouldn't be necessary.

Implementation

The default constructor for device_raw_ptr leaves the ptr member uninitialized. Typically a class like this would initialize ptr to nullptr, and you wouldn't need the constructor that takes a std::nullptr_t object.

The copy assignment operator should just be ptr = other.ptr, since that is the only thing in your class. The way you have it is nonstandard behavior. You construct a temporary, then pass it as a non-const reference to swap. This is not supported as part of the language, although some compilers (MSVC) support it as an extension. You're constructing a temporary, doing a swap, then destroying the temporary (a noop in this case). Similarly, the move assignment operator can be simplified to not use the temporary (ptr = other.ptr; other.reset();, or use three statements with an assignment to a local to avoid problems if you move assign an object to itself).

operator bool does not need a static_cast. Perhaps an explicit ptr != nullptr check, although a pointer will implicitly convert to a bool.