Is explicitly calling constructors and destructors safe, according to the C++ standard?

Question

Some developers call constructors and destructors explicitly for some workarounds. I know, it is not a good practice, but it seems it is done to realize some scenarios.

For example, in this article, Beautiful Native Libraries, the author uses this technique.

In the code below, at the end, it can be seen that the constructor is called explicitly:

#include <limits>

template <class T>
struct proxy_allocator {
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;
    typedef T *pointer;
    typedef const T *const_pointer;
    typedef T& reference;
    typedef const T &const_reference;
    typedef T value_type;

    template <class U>
    struct rebind {
        typedef proxy_allocator<U> other;
    };

    proxy_allocator() throw() {}
    proxy_allocator(const proxy_allocator &) throw() {}
    template <class U>
    proxy_allocator(const proxy_allocator<U> &) throw() {}
    ~proxy_allocator() throw() {}

    pointer address(reference x) const { return &x; }
    const_pointer address(const_reference x) const { return &x; }

    pointer allocate(size_type s, void const * = 0) {
        return s ? reinterpret_cast<pointer>(yl_malloc(s * sizeof(T))) : 0;
    }

    void deallocate(pointer p, size_type) {
        yl_free(p);
    }

    size_type max_size() const throw() {
        return std::numeric_limits<size_t>::max() / sizeof(T);
    }

    void construct(pointer p, const T& val) {
        new (reinterpret_cast<void *>(p)) T(val);
    }

    void destroy(pointer p) {
        p->~T();
    }

    bool operator==(const proxy_allocator<T> &other) const {
        return true;
    }

    bool operator!=(const proxy_allocator<T> &other) const {
        return false;
    }
};

For some scenarios like this, it can be necessary to call constructors and destructors explicitly, but what does the standard say: is it undefined behavior, is it unspecified behavior, is it implementation defined behavior, or is it well defined?

Answer 1

Yes it is supported and well defined, it is safe.

new (reinterpret_cast<void *>(p)) T(val);

Is called the placement new syntax and is used to construct an object at a specific memory location, the default behaviour; such as required in the allocator posted. If the placement new is overloaded for the specific type T, then it would be called instead of the global placement new.

The only way to destruct such a constructed object is to explicitly call the destructor p->~T();.

The use of the placement new and explicit destruction does require/allow that the code implemented controls the lifetime of the object - the compiler offers little assistance in this case; thus is it important that the objects are constructed in well aligned and sufficiently allocated locations. Their use is often found in allocators, such as in the OP, and the std::allocator.