Wrapper to work with global variables and arbitrary pointers (e.g from another process)

Pointer.h

#pragma once
#include <stdint.h>
#include <type_traits>

// use this for the [] operator (since we can't overload .) to work on globals without using the -> pointer operator
// example: BYVAL(gMyVar).foo
#define BYVAL(ptr) (*(&(ptr)))

template <typename T>
class Pointer
{
private:
	T *ptr;
public:
	using Tderef = typename std::remove_pointer<T>::type;

	Pointer(uintptr_t address) : ptr((T *)address){}

	// seamlessy dereference the pointer if we're assigning
	operator T() {
		return *ptr;
	}


	template <typename Tderef, typename = typename std::enable_if<!std::is_function<Tderef>::value>::type>
	// dereference Pointer<char *>
	Tderef operator*() {
		return (Tderef)(*ptr);
	}

	Pointer<Tderef> operator[](int i) {
		T base = *ptr;
		uintptr_t next = ((uintptr_t)base) + (i * sizeof(Tderef));
		return Pointer<Tderef>(next);
	}

	T operator->() {
		return *ptr;
	}

	T* operator&() {
		return ptr;
	}

	T operator=(T value) {
		*ptr = value;
		return *ptr;
	}

	T operator+=(T value) {
		*ptr += value;
		return *ptr;
	}
};