uniptr_t – C++ Pointer Utility Class

uniptr_t stands for univerasl pointer. It’s a small C++ class wrapping any pointer type. It removes the need to cast any pointer to any other pointer type, or to cast a numerical to a pointer type and vice versa.

The purpose of this library is to make working with pointers a lot a lot easier, but you still must understand how memory and pointers work. Be careful: uniptr_t is not always the best to use when working with pointers or memory addresses.


  • Automatic pointer casting
  • Utility functions
  • All operators are overloaded
  • Platform independent
  • Works on C++14 and newer versions (I haven’t tested it on C++11 or older versions)
  • 1 file include
  • Doesn’t affect performance of your code at all


You can assign all uniptr_t objects to any pointer type or to a numerical.

// assign to a void pointer
void* a_void_pointer = nullptr;
uniptr_t p1 = a_void_pointer;

// assign to any other pointer
int* any_pointer_type = nullptr;
uniptr_t p2 = any_pointer_type;

// assign to nullptr
uniptr_t p3 = nullptr;

// assign to 0 without any casting
uniptr_t p4 = 0;

// assign to any other numerical without casting
uniptr_t p5 = 0x18401;

Of course you can also do this vice versa – automatically cast uniptr_t to any pointer or numerical:

uniptr_t p1 = 0xDEADBEEF;

// assign to a void pointer
void* a_void_pointer = p1;

// assign to any other pointer
int* any_pointer_type = p1;

// assign to any numerical
int numerical1 = p1;
uintptr_t numerical2 = p1;
// and even to floats or doubles!
float floating1 = p1;
double floating2 = p1;

All operators are overloaded and work with any pointer type or numerical:

int numerical1 = 10;
uintptr_t numerical2 = 20;
float floating1 = 10.f;
double floating2 = 49.0;
void* void_ptr = (void*)0x100;
int* any_ptr = (int*)0x81;

uniptr_t my_ptr = 0;
my_ptr += numerical1;
my_ptr = my_ptr - floating1;
my_ptr /= any_ptr;
// etc.

uniptr_t has some utility functions:

uniptr_t my_ptr = nullptr;

my_ptr.set<int>(10); // same as *(int*)my_ptr = 10;

int my_num = my_ptr.get<int>(); // same as int my_num = *(int*)my_ptr;

// if you want to make sure the pointer is casted properly, you can use .as() or .as_ptr()
uintptr_t numerical = my_ptr.as<uintptr_t>();
int* void_ptr = my_ptr.as_ptr<int>(); // here you only need to specify the type of the pointer without *

// get the size of void* (same as sizeof(void*))
size_t pointer_size = my_ptr.size(); // you can even do uniptr_t::size() since it's a static function

// .relative_addr() and .to_relative_addr() are hard to explain but
// as the name suggests, I use them to caluclate relative addresses
// that an assembly instruction might be holding

// and finally we have some windows specific functions
// .is_valid() checks if the memory address uniptr_t is pointing to is valid (checks if it's commited memory)
// .is_readable() checks if the memory address uniptr_t is pointing to is readable
// .is_writeable() checks if the memory address uniptr_t is pointing to is writeable
// .region_size() if the function succeeds, the return value is non-zero and holds the number of bytes in memory of the
// region uniptr_t is pointing to (in other words how big the region is)


View Github