Hacking a SecureString based on std::basic_string for C++

Well, by now I've found some things to correct too:

1. Make everything you can noexcept, so everything (including templates and you yourself) can easier reason about exception-safety and knows which shortcuts are safe: SecureZeroMemory, secure_allocator::secure_allocator<U>, secure_allocator::deallocate, operator==, operator!=

2. Mark all constructors for secure_allocator constexpr to make it a literal type. While at it, do the same for operator== and operator!=.

3. Add secure_allocator::propagate_on_container_move_assignment mirroring std::allocator to have the same noexcept-guarantees.
   See: Can I force a default special member function to be noexcept?

4. Make all member-functions of secure_allocator static, because none actually needs an instance.

5. Do not use a new-expression in allocate nor a delete-expression in deallocate, in order to avoid constructing respective destroying the (de-)allocated elements there. Delegate to std::allocator<T> instead.

6. Mark SecureZeroMemory inline to avoid problems with the ODR.

The modified sources after applying all the above can be seen live on coliru.

#include <algorithm>
#include <memory>
#include <string>

namespace my_secure {
    inline void SecureZeroMemory(void* p, std::size_t n) noexcept {
        std::fill_n(static_cast<volatile char*>(p), n, 0);
    }

    // Minimal allocator zeroing on deallocation
    template <typename T> struct allocator {
        using value_type = T;
        using propagate_on_container_move_assignment =
            typename std::allocator_traits<std::allocator<T>>
            ::propagate_on_container_move_assignment;

        constexpr allocator() = default;
        constexpr allocator(const allocator&) = default;
        template <class U> constexpr allocator(const allocator<U>&) noexcept {}

        static T* allocate(std::size_t n) { return std::allocator<T>{}.allocate(n); }
        static void deallocate(T* p, std::size_t n) noexcept {
            SecureZeroMemory(p, n * sizeof *p);
            std::allocator<T>{}.deallocate(p, n);
        }
    };

    template <typename T, typename U>
    constexpr bool operator== (const allocator<T>&, const allocator<U>&) noexcept {
        return true;
    }
    template <typename T, typename U>
    constexpr bool operator!= (const allocator<T>&, const allocator<U>&) noexcept {
        return false;
    }

    using secure_string = std::basic_string<char, std::char_traits<char>,
        allocator<char>>;
}

namespace std {
    // Zero the strings own memory on destruction
    template<> my_secure::secure_string::~basic_string() {
        using X = basic_string<char, char_traits<char>,
            ::my_secure::allocator<unsigned char>>;
        ((X*)this)->~X();
        ::my_secure::SecureZeroMemory(this, sizeof *this);
    }
}

1. Turns out this point is invalid. Your SecureZeroMemory is called twice in case of regular allocation. First time, by destructor of your string: ((X*)this)->~X();. Second time, explicitly: my_secure::SecureZeroMemory(this, sizeof *this); As you can guess, this leaves you with undefined behavior.
2. Older (and more common) versions of gcc and clang (4.9 and 3.6, for example) will not compile your code, since older versions of libstdc++ and libc++ don't use std::allocator_traits. You have to explicitly define implementations of optional allocator requirements if you want portability.