/* Me, trying to get more familiar with writing api's. I might as well upload it here, otherwise it'll just sit there on my hard drive anyway. Today, tagged pointers. Alot of architectures these days align their pointers to 4 ( 32-bit ) or 8 ( 64-bit ) byte boundaries. Some operating systems even align to 16 or 32 byte boundaries, though I'm not sure how to detect these things programmatically yet. A pointer that is 4 byte aligned can look like: -- where ? can be a 0 or a 1 - ? ? ? ? ? ? 0 0 or 8 byte aligned: - ? ? ? ? ? 0 0 0 The last 2 or 3 bits respectively are never used so, why not use that unused space to cram a 'bit' more data into it. For example a pointer could point to 0xD8 or 1 1 0 1 1 0 0 0 Now, we also want to store the number 3, the tag, as well, the pointer becomes 0xDB or 1 1 0 1 1 0 1 1 Or we could store 3 booleans If we want to access the original data pointed to, we mask out the tag part tag_pointer: 1 1 0 1 1 0 1 1 mask: 1 1 1 1 1 0 0 0 result: 1 1 0 1 1 0 0 0 Same method to retrieve the tag, but with the inverse of the mask (~mask). More info: en.wikipedia.org/wiki/Tagged_pointer */ #include // for std::uintptr_t #include // for std::swap #include // for std::is_void #include namespace Dennis_9E { template struct default_delete { constexpr default_delete() noexcept = default; void operator()( T* ptr ) const { static_assert(!std::is_void::value, "can't delete pointer to incomplete type"); static_assert( sizeof( T ) > 0, "can't delete pointer to incomplete type" ); delete ptr; } }; template struct default_delete { constexpr default_delete() noexcept = default; void operator()( T* ptr ) const { static_assert( sizeof( T ) > 0, "can't delete pointer to incomplete type" ); delete[] ptr; } }; /** * Implements the base functionality for the tagged pointer */ template class Tagged_Pointer_Base { private: #if INTPTR_MAX == INT64_MAX // 3 available bits on a 64-bit system constexpr static std::uintptr_t tagMask = 0x07; #elif INTPTR_MAX == INT32_MAX // 2 available bits on a 32-bit system constexpr static std::uintptr_t tagMask = 0x03; #else // No support for other systems constexpr static std::uintptr_t tagMask = 0x00; #endif // bitmask to easily read the pointer constexpr static std::uintptr_t pointerMask = ~tagMask; public: using value_type = T; using pointer = T*; using const_pointer = const T*; using reference = T&; using const_reference = const T&; public: /** * @brief sets the tag of the pointer * * @param tag The integer to tag the pointer with * * @note Invalid bits of the tag are automatically ignored */ constexpr void setTag( char tag ) noexcept; /** * @return the tag part of the pointer */ constexpr char tag() const noexcept; /** * @brief checks whether the pointer points to nullptr or not * * @return true if the internal points is nullptr, false otherwise */ constexpr bool isNull() const noexcept; /** * @see isNull */ constexpr bool operator!() const noexcept; /** * @brief allows the class to be explicitly converted to a bool ( e.g. works in if, but not in cout ) * * @return true if the internal pointer points to an object, false otherwise * @see !isNull */ constexpr explicit operator bool() const noexcept; /** * @return the maximum possible tag value available */ constexpr static int maxTag() noexcept; /** * @return a non-const reference to the pointed-to object */ constexpr T& operator*() noexcept; /** * @return a const reference to the pointed-to object */ constexpr const T& operator*() const noexcept; /** * @return a non-const pointer to the pointed-to object */ constexpr T* operator->() noexcept; /** * @return a const pointer to the pointed-to object */ constexpr const T* operator->() const noexcept; /** * @return a non-const pointer to the pointed-to object */ constexpr T* get() noexcept; /** * @return a const pointer to the pointed-to object */ constexpr const T* get() const noexcept; /** * @brief releases the pointer using the specified deleter */ constexpr void release() noexcept; /** * @brief Sets the pointer to a new value * * @param ptr The new pointer that is to be managed, defaults to nullptr * * @note this also resets the tag */ constexpr void reset( T* ptr = nullptr ); /** * @see reset( T* ) * * @param tag The tag to attach to the pointer * @param ptr The new pointer that is to be managed */ constexpr void reset( char tag, T* ptr ); public: template friend void swap( Tagged_Pointer_Base& o1, Tagged_Pointer_Base& o2 ) noexcept; ~Tagged_Pointer_Base(); protected: // Disallows construction of the base class without inheriting constexpr explicit Tagged_Pointer_Base() noexcept; constexpr explicit Tagged_Pointer_Base( pointer ptr ); constexpr explicit Tagged_Pointer_Base( char tag, pointer ptr ); constexpr Tagged_Pointer_Base( Tagged_Pointer_Base&& other ) noexcept; protected: constexpr void _m_setTag( char tag ) noexcept; constexpr static char _s_getTag( const pointer ptr ) noexcept; constexpr static pointer _s_removeTag( const pointer ptr ) noexcept; constexpr pointer _m_getPtr(); constexpr const_pointer _m_getPtr() const; private: pointer m_Ptr; //< Can't use unique_ptr because we have to manipulate the pointer's value ourselves }; template void swap( Tagged_Pointer_Base& o1, Tagged_Pointer_Base& o2 ) noexcept { using std::swap; swap( o1.m_Ptr, o2.m_Ptr ); } template constexpr Tagged_Pointer_Base::Tagged_Pointer_Base() noexcept : Tagged_Pointer_Base( nullptr ) { } template constexpr Tagged_Pointer_Base::Tagged_Pointer_Base( pointer ptr ) : Tagged_Pointer_Base( 0, ptr ) { } template constexpr Tagged_Pointer_Base::Tagged_Pointer_Base( char tag, pointer ptr ) : m_Ptr( ptr ) { assert( _s_getTag( m_Ptr ) == 0 ); _m_setTag( tag ); } template constexpr Tagged_Pointer_Base::Tagged_Pointer_Base( Tagged_Pointer_Base&& other ) noexcept : Tagged_Pointer_Base() { swap( *this, other ); } template Tagged_Pointer_Base::~Tagged_Pointer_Base() { Deleter()( _s_removeTag( m_Ptr ) ); } template constexpr bool Tagged_Pointer_Base::isNull() const noexcept { return _s_removeTag( m_Ptr ) == nullptr; } template constexpr void Tagged_Pointer_Base::_m_setTag( char tag ) noexcept { std::uintptr_t taggedPointer = reinterpret_cast( m_Ptr ); taggedPointer &= pointerMask; taggedPointer |= ( tag & tagMask ); m_Ptr = reinterpret_cast( taggedPointer ); } template constexpr char Tagged_Pointer_Base::_s_getTag( const pointer ptr ) noexcept { return reinterpret_cast( ptr ) & tagMask; } template constexpr auto Tagged_Pointer_Base::_s_removeTag( const pointer ptr ) noexcept -> pointer { return reinterpret_cast( reinterpret_cast( ptr ) & pointerMask ); } template constexpr auto Tagged_Pointer_Base::_m_getPtr() -> pointer { return _s_removeTag( m_Ptr ); } template constexpr auto Tagged_Pointer_Base::_m_getPtr() const -> const_pointer { return _s_removeTag( m_Ptr ); } template constexpr T& Tagged_Pointer_Base::operator*() noexcept { return *_s_removeTag( m_Ptr ); } template constexpr const T& Tagged_Pointer_Base::operator*() const noexcept { return *_s_removeTag( m_Ptr ); } template constexpr T* Tagged_Pointer_Base::operator->() noexcept { return get(); } template constexpr const T* Tagged_Pointer_Base::operator->() const noexcept { return get(); } template constexpr T* Tagged_Pointer_Base::get() noexcept { return _s_removeTag( m_Ptr ); } template constexpr const T* Tagged_Pointer_Base::get() const noexcept { return _s_removeTag( m_Ptr ); } template constexpr void Tagged_Pointer_Base::setTag( char tag ) noexcept { _m_setTag( tag ); } template constexpr char Tagged_Pointer_Base::tag() const noexcept { return _s_getTag( m_Ptr ); } template constexpr bool Tagged_Pointer_Base::operator!() const noexcept { return !isNull(); } template constexpr Tagged_Pointer_Base::operator bool() const noexcept { return !*this; } template constexpr int Tagged_Pointer_Base::maxTag() noexcept { return static_cast( tagMask ); } template constexpr void Tagged_Pointer_Base::release() noexcept { reset(); } template constexpr void Tagged_Pointer_Base::reset( T* ptr ) { pointer oldPointer = _s_removeTag( m_Ptr ); using std::swap; swap( m_Ptr, ptr ); if( oldPointer ) { Deleter()( oldPointer ); } } template constexpr void Tagged_Pointer_Base::reset( char tag, T* ptr ) { reset( ptr ); _m_setTag( tag ); } template> class Tagged_Pointer : public Tagged_Pointer_Base { public: using value_type = typename Tagged_Pointer_Base::value_type; using pointer = typename Tagged_Pointer_Base::pointer; using const_pointer = typename Tagged_Pointer_Base::const_pointer; using reference = typename Tagged_Pointer_Base::reference; using const_reference = typename Tagged_Pointer_Base::const_reference; public: constexpr explicit Tagged_Pointer() noexcept; constexpr explicit Tagged_Pointer( pointer ptr ); constexpr explicit Tagged_Pointer( char tag, pointer ptr ); constexpr Tagged_Pointer( Tagged_Pointer&& other ) noexcept; template friend void swap( Tagged_Pointer& o1, Tagged_Pointer& o2 ) noexcept; }; template void swap( Tagged_Pointer& o1, Tagged_Pointer& o2 ) noexcept { using std::swap; swap( static_cast&>( o1 ), static_cast&>( o2 ) ); } template constexpr Tagged_Pointer::Tagged_Pointer() noexcept : Tagged_Pointer_Base( nullptr ) { } template constexpr Tagged_Pointer::Tagged_Pointer( pointer ptr ) : Tagged_Pointer_Base( 0, ptr ) { } template constexpr Tagged_Pointer::Tagged_Pointer( char tag, pointer ptr ) : Tagged_Pointer_Base( tag, ptr ) { } template constexpr Tagged_Pointer::Tagged_Pointer( Tagged_Pointer&& other ) noexcept { swap( *this, other ); } /** * Specialized class for arrays, defines the operator[] */ template class Tagged_Pointer : public Tagged_Pointer_Base { public: using value_type = typename Tagged_Pointer_Base::value_type; using size_type = std::size_t; using pointer = typename Tagged_Pointer_Base::pointer; using const_pointer = typename Tagged_Pointer_Base::const_pointer; using reference = typename Tagged_Pointer_Base::reference; using const_reference = typename Tagged_Pointer_Base::const_reference; public: constexpr explicit Tagged_Pointer() noexcept; constexpr explicit Tagged_Pointer( pointer ptr ); constexpr explicit Tagged_Pointer( char tag, pointer ptr ); constexpr Tagged_Pointer( Tagged_Pointer&& other ) noexcept; /** * @param N Offset into the pointer * * @return a non-const reference to a value pointed-to by the pointer, offset by N */ constexpr reference operator[]( size_type N ); /** * @param N Offset into the pointer * * @return a const reference to a value pointed-to by the pointer, offset by N */ constexpr const_reference operator[]( size_type N ) const; template friend void swap( Tagged_Pointer& o1, Tagged_Pointer& o2 ) noexcept; }; template void swap( Tagged_Pointer& o1, Tagged_Pointer& o2 ) noexcept { using std::swap; swap( static_cast&>( o1 ), static_cast&>( o2 ) ); } template constexpr Tagged_Pointer::Tagged_Pointer() noexcept : Tagged_Pointer_Base( nullptr ) {} template constexpr Tagged_Pointer::Tagged_Pointer( pointer ptr ) : Tagged_Pointer_Base( 0, ptr ) {} template constexpr Tagged_Pointer::Tagged_Pointer( char tag, pointer ptr ) : Tagged_Pointer_Base( tag, ptr ) {} template constexpr Tagged_Pointer::Tagged_Pointer( Tagged_Pointer&& other ) noexcept : Tagged_Pointer_Base( other ) {} template constexpr auto Tagged_Pointer::operator[]( size_type N ) -> reference { return Tagged_Pointer_Base::_m_getPtr()[N]; } template constexpr auto Tagged_Pointer::operator[]( size_type N ) const -> const_reference { return Tagged_Pointer_Base::_m_getPtr()[N]; } template::value>* = nullptr> constexpr Tagged_Pointer make_tagged_pointer( Args&&... args ) { return Tagged_Pointer( new T( std::forward( args )... ) ); } template::value>* = nullptr> constexpr Tagged_Pointer make_tagged_pointer( typename Tagged_Pointer::size_type size ) { return Tagged_Pointer( new typename std::remove_extent::type[size]() ); } template::value>* = nullptr> constexpr Tagged_Pointer make_tagged_pointer_tag( char tag, Args&&... args ) { return Tagged_Pointer( tag, new T( std::forward( args )... ) ); } template::value>* = nullptr> constexpr Tagged_Pointer make_tagged_pointer_tag( char tag, typename Tagged_Pointer::size_type size ) { return Tagged_Pointer( tag, new typename std::remove_extent::type[size]() ); } } // I could just hardcode the example as a string but this is more fun, but then again, I wouldn't be able to get the ptr.tag() output #include #include int main() { using Dennis_9E::Tagged_Pointer;// using Dennis_9E::make_tagged_pointer_tag;// // std::fstream file( __FILE__ ); if( !file )// {// std::cerr << "Failed to open file: " << __FILE__ << '\n';// return 1;// }// // Works similar to std::unique_ptr Tagged_Pointer ptr( make_tagged_pointer_tag( 3 ) ); bool wait = false;// bool remove_spaces = true;// while( std::getline( file, *ptr ) ) { if( wait )// {// if( *ptr == "int main()" )// {// wait = false;// remove_spaces = false;// std::cout << "\n----------------\nSmall example:\n\n";// }// else// {// continue;// }// }// // if( remove_spaces )// {// auto index = ptr->find_first_not_of( " \t" ); *ptr = ptr->substr( std::min( ptr->size(), index ) ); }// // if( *ptr == "/*" )// continue;// // if( *ptr == "*/" )// {// wait = true;// continue;// }// // if( !( ptr->size() >= 2 &&( (*ptr)[ptr->size()-2] == '/' && (*ptr)[ptr->size()-1] == '/' ) ) ) // std::cout << *ptr << '\n'; } std::cout << "\nTag: " << (int)ptr.tag() << '\n'; // Still 8 bytes ( or 4 on a 32 bit system ) std::cout << "Size: " << sizeof( ptr ) << '\n'; }

Tagged pointer