Compiler Explorer

Source code

#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cassert>
#include <new>
#include <memory>
#if __cplusplus>=201103L
#    include <cstdint>
#    include <initializer_list>
#    include <type_traits>
#    include <utility>
#else
#    include <stdint.h>
#endif

//
 // Tracer
//

/**
 * A debugging class to check for constuctor/destructor balance and 
 *   proper copy and move construction and assignment operations of
 *   data structures and containers like array, list, etc...
 *
 * Tracer::Reset() -- static function to reset the top and active static Tracer values;
 * Tracer::Top() -- static ulonglong value to keep track of the top Tracer id;
 * Tracer::Active() -- static ulonglong value to keep track of the active Tracer 
 *   objects that have not been destroyed;
 * Tracer::value -- non-static int variable that represents a data Tracer holds.
 *
 */
class Tracer 
{
public:
	typedef int value_t;
	typedef unsigned long long id_t;
public:
	virtual ~Tracer();
	Tracer(const value_t& value = value_t());
	Tracer(const Tracer& tracer);
#   if __cplusplus>=201103L
	    Tracer(Tracer&& tracer);
#	endif
public:
	Tracer& operator=(const Tracer& tracer);
	Tracer& operator=(const value_t& value);
#   if __cplusplus>=201103L
	    Tracer& operator=(Tracer&& tracer);
#	endif
	bool operator==(const Tracer& tracer) const;
	bool operator!=(const Tracer& tracer) const;
	bool operator<(const Tracer& tracer) const;
	bool operator>(const Tracer& tracer) const;
	bool operator==(int value) const;
	bool operator!=(int value) const;
	bool operator<(int value) const;
	bool operator>(int value) const;
public:
	static void Reset();
	static const id_t Top();
	static const id_t Active();
public:
	const id_t id;
	value_t value;
private:
	bool destruct;
	static id_t S_TOP;
	static id_t S_ACTIVE;
};

// c++11+ macros
#if __cplusplus>=201103L
#   define CXX11 1
#   define CONSTEXPR11 constexpr
#   define NOEXCEPT11 noexcept
#   define IFCXX11(C) C
#   define IFCXX11ELSE(C, EC) C
#else
#   define CXX11 0
#   define CONSTEXPR11
#   define NOEXCEPT11
#   define IFCXX11(C)
#   define IFCXX11ELSE(C, EC) EC
#   define nullptr 0
#endif
// c++14+ macros
#if __cplusplus>=201402L
#   define IFCXX14(C) C
#   define IFCXX14ELSE(C, EC) C
#else
#   define IFCXX14(C)
#   define IFCXX14ELSE(C, EC) EC
#endif
// c++17+ macros
#if __cplusplus>=201703L
#   define CONSTEXPR17 constexpr
#   define IFCXX17(C) C
#   define IFCXX17ELSE(C, EC) C
#else
#   define CONSTEXPR17
#   define IFCXX17(C)
#   define IFCXX17ELSE(C, EC) EC
#endif

//
 // Array
//

template <typename E>
class Array 
{
public:
    CONSTEXPR11 static const bool Is_Elem_Class = IFCXX11ELSE(std::is_class<E>::value, true);
    CONSTEXPR11 static const bool Is_Elem_Default_Constructible = IFCXX11ELSE(std::is_default_constructible<E>::value, true);
    CONSTEXPR11 static const bool Is_Elem_Destructible = IFCXX11ELSE(std::is_destructible<E>::value, true);
    CONSTEXPR11 static const bool Is_Elem_Copy_Constructible = IFCXX11ELSE(std::is_copy_constructible<E>::value, true);
    CONSTEXPR11 static const bool Is_Elem_Move_Constructible = IFCXX11ELSE(std::is_move_constructible<E>::value, false);
    CONSTEXPR11 static const bool Is_Elem_Copy_Assignable = IFCXX11ELSE(std::is_copy_assignable<E>::value, true);
    CONSTEXPR11 static const bool Is_Elem_Move_Assignable = IFCXX11ELSE(std::is_move_assignable<E>::value, false);

/**
     * Constructs an array of length <length_> and initialzies the elements 
     *   if <initialize> is set to true.
     *
     * If <length_> is zero or allocation failed then m_ptr and m_len will 
     *   be set to nullptr and zero. 
     *
     * Note: Setting <initialize> to false for class types will result in
     *   undefined behavior!
     */
    Array(size_t length_ = 0, bool initialize = true) NOEXCEPT11 : 
        m_len(length_), 
        m_ptr(m_len == 0 ? nullptr 
            : reinterpret_cast<E*>(std::malloc(sizeof(E) * m_len)))
    {
        if (m_ptr) {
            if(initialize) {
#   if CXX11==1
                if CONSTEXPR17 (Array<E>::Is_Elem_Class) {
                    if CONSTEXPR17 (Array<E>::Is_Elem_Default_Constructible) {
#   endif
                        for(size_t i=0; i<m_len; ++i)
                            new (m_ptr + i) E();
#   if CXX11==1
                    }
                    else { assert(Array<E>::Is_Elem_Default_Constructible && "Array cannot initialize non-default-constructible type"); }
                }
                else {
                    for(size_t i=0; i<m_len; ++i)
                        m_ptr[i] = E();
                }
#   endif
            }
#   if CXX11==1
            else { assert(!Array<E>::Is_Elem_Class && "Array must initialize object type"); }
#   endif
        } 
        else m_len = 0;
    }

# if CXX11==1
    Array(const std::initializer_list<E>& list) NOEXCEPT11 :
        m_len(list.size()),
        m_ptr(m_len == 0 ? nullptr 
            : reinterpret_cast<E*>(std::malloc(sizeof(E) * m_len)))
    {
        if (m_ptr) {
            if CONSTEXPR17 (Array<E>::Is_Elem_Class)
            {
                E* it = const_cast<E*>(list.begin());
                if(it) {
                    if CONSTEXPR17 (Array<E>::Is_Elem_Move_Constructible)
                        for(size_t i=0; i<m_len; ++i)
                            new (m_ptr + i) E(std::move(it[i]));
                    else
                        for(size_t i=0; i<m_len; ++i)
                            new (m_ptr + i) E(it[i]);
                }
                else {
                    if CONSTEXPR17 (Array<E>::Is_Elem_Default_Constructible)
                        for(size_t i=0; i<m_len; ++i)
                            new (m_ptr + i) E();
                    else {
                        assert(Array<E>::Is_Elem_Default_Constructible && "Array cannot initialize non-default-constructible type");
                    }
                }
            }
            else
            {
                const E* it = list.begin();
                if(it)
                    for(size_t i=0; i<m_len; ++i)
                        m_ptr[i] = it[i];
                else
                    for(size_t i=0; i<m_len; ++i)
                        m_ptr[i] = E{};
            }
        } 
        else m_len = 0;
    }

Array(Array<E>&& array) NOEXCEPT11 :
        m_len(array.m_len),
        m_ptr(array.m_ptr)
    {
        array.m_ptr = nullptr;
        array.m_len = 0;
    }
# endif

Array(const Array<E>& array) NOEXCEPT11 :
        m_len(array.m_len),
        m_ptr(m_len == 0 ? nullptr 
            : reinterpret_cast<E*>(std::malloc(sizeof(E) * m_len)))
    {
        if (m_ptr) {
            const E* it = array.m_ptr;
#   if CXX11==1
            if CONSTEXPR17 (Array<E>::Is_Elem_Class) {
                if CONSTEXPR17 (Array<E>::Is_Elem_Copy_Constructible)
#   endif
                    for(size_t i=0; i<m_len; ++i)
                        new (m_ptr + i) E(it[i]);
#   if CXX11==1
                else {
                    assert(Array<E>::Is_Elem_Copy_Constructible && "Array cannot copy to a non-copy-constructible type");
                }
            }
            else {
                for(size_t i=0; i<m_len; ++i)
                    m_ptr[i] = it[i];
            }
#   endif
        } 
        else m_len = 0;
    }
    
#if CXX11==1
    Array& operator=(const std::initializer_list<E>& list) NOEXCEPT11
    {
        this->~Array<E>();
        new (this) Array<E>(list);
        return *this;
    }

Array& operator=(Array<E>&& array) NOEXCEPT11
    {
        this->~Array<E>();
        new (this) Array<E>(std::move(array));
        return *this;
    }
#   endif
    
    Array& operator=(const Array<E>& array) NOEXCEPT11
    {
        this->~Array<E>();
        new (this) Array<E>(array);
        return *this;
    }

~Array() NOEXCEPT11
    {
        this->clear(); 
    }

void clear() NOEXCEPT11 
    {
        if (m_ptr) {
#   if CXX11==1
            if CONSTEXPR17 (Array<E>::Is_Elem_Class && Array<E>::Is_Elem_Destructible)
#   endif
                for(size_t i=0; i<m_len; ++i)
                    m_ptr[i].~E();
            std::free(m_ptr);
            m_ptr = nullptr;
            m_len = 0;
        }
    }

bool resize(size_t new_length, bool initialize = true) NOEXCEPT11
    {
        if(m_len == new_length) return true;
        else if(!m_ptr) { // if empty
            if(new_length == 0) return true;
            m_ptr = reinterpret_cast<E*>(std::malloc(sizeof(E) * new_length));
        }
        else {
            if(new_length == 0) {
                this->clear();
                return true;
            }
            else {
                if(new_length < m_len) // destruct the excess
#   if CXX11==1
                    if CONSTEXPR17 (Array<E>::Is_Elem_Class && Array<E>::Is_Elem_Destructible)
#   endif
                        for(size_t i=new_length; i<m_len; ++i)
                            m_ptr[i].~E();
                m_ptr = reinterpret_cast<E*>(std::realloc(m_ptr, sizeof(E) * new_length));
            }
        }
        if(m_ptr) {
            if(initialize) {
#   if CXX11==1
                if CONSTEXPR17 (Array<E>::Is_Elem_Class) {
                    if CONSTEXPR17 (Array<E>::Is_Elem_Default_Constructible)
#   endif
                        for(size_t i=m_len; i<new_length; ++i)
                            new (m_ptr + i) E();
#   if CXX11==1
                    else {
                        assert(Array<E>::Is_Elem_Default_Constructible && "Array cannot initialize non-default-constructible type");
                    }
                }
                else {
                    for(size_t i=m_len; i<new_length; ++i)
                        m_ptr[i] = E();
                }
#   endif
            }
#   if CXX11==1
            else {
                assert(!(Array<E>::Is_Elem_Class && Array<E>::Is_Elem_Default_Constructible) && "Array must initialize object type");
            }
#   endif
            m_len = new_length;
        }
        else {
            m_ptr = nullptr;
            m_len = 0;
            return false;
        }
        return m_len == new_length;
    }

bool            isEmpty() const NOEXCEPT11   { return m_ptr == nullptr; }
    const size_t&   length() const NOEXCEPT11    { return m_len; }
    E*              begin() NOEXCEPT11           { return !m_ptr ? nullptr : m_ptr; }
    E*              rbegin() NOEXCEPT11          { return !m_ptr ? nullptr : (m_ptr + m_len - 1); }
    E*              end() NOEXCEPT11             { return !m_ptr ? nullptr : (m_ptr + m_len); }
    E*              rend() NOEXCEPT11            { return !m_ptr ? nullptr : (m_ptr - 1); }
    const E*        cbegin() const NOEXCEPT11    { return !m_ptr ? nullptr : m_ptr; }
    const E*        crbegin() const NOEXCEPT11   { return !m_ptr ? nullptr : (m_ptr + m_len - 1); }
    const E*        cend() const NOEXCEPT11      { return !m_ptr ? nullptr : (m_ptr + m_len); }
    const E*        crend() const NOEXCEPT11     { return !m_ptr ? nullptr : (m_ptr - 1); }
    E*              ptr() NOEXCEPT11             { return m_ptr; }
    const E*        cptr() const NOEXCEPT11      { return m_ptr; }

E&          operator[](size_t index) NOEXCEPT11          { return m_ptr[index]; }
    const E&    operator[](size_t index) const NOEXCEPT11    { return m_ptr[index]; }
    bool        operator!() const NOEXCEPT11                 { return m_ptr == nullptr; }
    IFCXX11(explicit operator bool() const NOEXCEPT11        { return m_ptr != nullptr; })

private:
    size_t m_len;
    E *m_ptr;
};

// namespace std {

// template<class T>
// void swap( T& a, T& b ) NOEXCEPT11
// {
// # if __cplusplus>=201103L
//     T t = std::move(a);
//     a = std::move(b);
//     b = std::move(t);
// # else
//     T t = a;
//     a = b;
//     b = t;
// # endif
// }

// } // namespace std

//
 // Assert macros
//

#define Assert(E) ((E) ? (int)0 : fprintf(stdout, "FAIL: %s:%d\n", __FILE__, __LINE__))
#define AssertVal(E, V, Fmt) ((E) == V ? (int)0 : fprintf(stdout, "FAIL: (%s) != %" Fmt " -> %" Fmt " : %s:%d\n", #E, (V), (E), __FILE__, __LINE__))

//
 // main =====================================================================
//

int main()
{
    printf("C++ Standard %ld\n", __cplusplus);
    puts("--- empty Array ----------------");
    {
        Array<int> arr;
        Assert(arr.length() == 0);
        Assert(!arr.ptr());
        Assert(!arr.cptr());
        IFCXX11(Assert(!arr));
    }
    
    puts("--- Array of ints ----------------");
    {
        Array<int> arr(4);
        Assert(arr.ptr());
        AssertVal(arr.length(), 4LU, "zu");
        for(int i=0; i<int(arr.length()); ++i)
            arr[i] = (i+1);
        // random access iteration
        for(int i=0; i<int(arr.length()); ++i)
        { AssertVal(arr[i], (i+1), "d"); }
        // forward iteration
        int i=0;
        for(int *it = arr.begin(); it && it != arr.end(); ++i, ++it)
        { AssertVal(*it, (i+1), "d"); }
        // reverse iteration
        i = arr.length();
        for(int *it = arr.rbegin(); it && it != arr.rend(); --i, --it)
        { AssertVal(*it, i, "d"); }
        arr.clear();
        Assert(!arr.ptr());
        AssertVal(arr.length(), 0LU, "zu");
    }

puts("--- Array of Tracer objects ----------------");
    {
        Tracer::Reset();
        Array<Tracer> arr(4);
        AssertVal(Tracer::Top(), 4LLU, "llu");
        AssertVal(Tracer::Active(), 4LLU, "llu");
        Assert(arr.ptr());
        Assert(arr.cptr());
        AssertVal(arr.length(), 4LU, "zu");
        for(int i=0; i<int(arr.length()); ++i)
            arr[i] = (i+1); // invokes Tracer::operator=(const int&)
        // random access iteration
        for(int i=0; i<int(arr.length()); ++i)
        { AssertVal(arr[i].value, (i+1), "d"); }
        // forward iteration
        int i=0;
        for(Tracer *it = arr.begin(); it && it != arr.end(); ++i, ++it)
        { AssertVal(it->value, (i+1), "d"); }
        // reverse iteration
        i = arr.length();
        for(Tracer *it = arr.rbegin(); it && it != arr.rend(); --i, --it)
        { AssertVal(it->value, i, "d"); }
        arr.clear();
        AssertVal(Tracer::Top(), 4LLU, "llu");
        AssertVal(Tracer::Active(), 0LLU, "llu");
        Assert(!arr.ptr());
        AssertVal(arr.length(), 0LU, "zu");
    }
    AssertVal(Tracer::Top(), 4LLU, "llu");
    AssertVal(Tracer::Active(), 0LLU, "llu");

puts("--- Array copy construction ----------------");
    {
        Tracer::Reset();
        Array<Tracer> arr(4);
        for(int i=0; i<int(arr.length()); ++i)
            arr[i] = (i+1); // invokes Tracer::operator=(const int&)
        
        AssertVal(Tracer::Top(), 4LLU, "llu");
        AssertVal(Tracer::Active(), 4LLU, "llu");
        {
            Array<Tracer> arr2(arr);
            AssertVal(arr.length(), 4LU, "zu");
            AssertVal(arr2.length(), 4LU, "zu");
            Assert(arr2.ptr());
            Assert(arr.ptr());
            AssertVal(Tracer::Top(), 8LLU, "llu");
            AssertVal(Tracer::Active(), 8LLU, "llu");
            // random access iteration
            for(int i=0; i<int(arr2.length()); ++i)
            {
                AssertVal(arr2[i].value, (i+1), "d");
                AssertVal(arr2[i].value, arr[i].value, "d");
            }
            arr2.clear();
            AssertVal(Tracer::Top(), 8LLU, "llu");
            AssertVal(Tracer::Active(), 4LLU, "llu");
        }
        AssertVal(Tracer::Top(), 8LLU, "llu");
        AssertVal(Tracer::Active(), 4LLU, "llu");
        arr.clear();
        AssertVal(Tracer::Top(), 8LLU, "llu");
        AssertVal(Tracer::Active(), 0LLU, "llu");
        Assert(!arr.ptr());
        AssertVal(arr.length(), 0LU, "zu");
    }
    AssertVal(Tracer::Top(), 8LLU, "llu");
    AssertVal(Tracer::Active(), 0LLU, "llu");

puts("--- Array copy assignment op ----------------");
    {
        Tracer::Reset();
        Array<Tracer> arr(4);
        for(int i=0; i<int(arr.length()); ++i)
            arr[i] = (i+1); // invokes Tracer::operator=(const int&)
        
        AssertVal(Tracer::Top(), 4LLU, "llu");
        AssertVal(Tracer::Active(), 4LLU, "llu");
        {
            Array<Tracer> arr2(3);
			for(int i=0; i<int(arr2.length()); ++i)
				arr2[i] = (i+1);
            AssertVal(arr2.length(), 3LU, "zu");
			arr2 = arr;
            AssertVal(arr.length(), 4LU, "zu");
            AssertVal(arr2.length(), 4LU, "zu");
            Assert(arr2.ptr());
            Assert(arr.ptr());
            AssertVal(Tracer::Top(), 11LLU, "llu");
            AssertVal(Tracer::Active(), 8LLU, "llu");
            // random access iteration
            for(int i=0; i<int(arr2.length()); ++i)
            {
                AssertVal(arr2[i].value, (i+1), "d");
                AssertVal(arr2[i].value, arr[i].value, "d");
            }
        }
        AssertVal(Tracer::Top(), 11LLU, "llu");
        AssertVal(Tracer::Active(), 4LLU, "llu");
        arr.clear();
        AssertVal(Tracer::Top(), 11LLU, "llu");
        AssertVal(Tracer::Active(), 0LLU, "llu");
        Assert(!arr.ptr());
        AssertVal(arr.length(), 0LU, "zu");
    }
    AssertVal(Tracer::Top(), 11LLU, "llu");
    AssertVal(Tracer::Active(), 0LLU, "llu");

#if __cplusplus>=201103L
    puts("--- Array move construction ----------------");
    {
        Tracer::Reset();
        Array<Tracer> arr(4);
        for(int i=0; i<int(arr.length()); ++i)
            arr[i] = (i+1); // invokes Tracer::operator=(const int&)
        
        AssertVal(Tracer::Top(), 4LLU, "llu");
        AssertVal(Tracer::Active(), 4LLU, "llu");
        {
            Array<Tracer> arr2(std::move(arr));
            AssertVal(arr.length(), 0LU, "zu");
            AssertVal(arr2.length(), 4LU, "zu");
            Assert(arr2.ptr());
            Assert(!arr.ptr());
            AssertVal(Tracer::Top(), 4LLU, "llu");
            AssertVal(Tracer::Active(), 4LLU, "llu");
            // random access iteration
            for(int i=0; i<int(arr2.length()); ++i)
            { AssertVal(arr2[i].value, (i+1), "d"); }
        }
        AssertVal(Tracer::Top(), 4LLU, "llu");
        AssertVal(Tracer::Active(), 0LLU, "llu");
        Assert(!arr.ptr());
        AssertVal(arr.length(), 0LU, "zu");
    }
    AssertVal(Tracer::Top(), 4LLU, "llu");
    AssertVal(Tracer::Active(), 0LLU, "llu");

puts("--- Array move assignment op ----------------");
    {
        Tracer::Reset();
        Array<Tracer> arr(4);
        for(int i=0; i<int(arr.length()); ++i)
            arr[i] = (i+1); // invokes Tracer::operator=(const int&)
        
        AssertVal(Tracer::Top(), 4LLU, "llu");
        AssertVal(Tracer::Active(), 4LLU, "llu");
        {
            Array<Tracer> arr2(3);
			for(int i=0; i<int(arr2.length()); ++i)
				arr2[i] = (i+1);
            AssertVal(arr2.length(), 3LU, "zu");
			arr2 = std::move(arr);
            AssertVal(arr.length(), 0LU, "zu");
            AssertVal(arr2.length(), 4LU, "zu");
            Assert(arr2.ptr());
            Assert(!arr.ptr());
            AssertVal(Tracer::Top(), 7LLU, "llu");
            AssertVal(Tracer::Active(), 4LLU, "llu");
            // random access iteration
            for(int i=0; i<int(arr2.length()); ++i)
            { AssertVal(arr2[i].value, (i+1), "d"); }
        }
        AssertVal(Tracer::Top(), 7LLU, "llu");
        AssertVal(Tracer::Active(), 0LLU, "llu");
        Assert(!arr.ptr());
        AssertVal(arr.length(), 0LU, "zu");
    }
    AssertVal(Tracer::Top(), 7LLU, "llu");
    AssertVal(Tracer::Active(), 0LLU, "llu");

puts("--- Array from intializer list of ints ----------------");
    {
        Array<int> arr { 1, 2, 3, 4 };
        Assert(arr.ptr());
        Assert(arr);
        AssertVal(arr.length(), 4LU, "zu");
        // random access iteration
        for(int i=0; i<int(arr.length()); ++i)
        { AssertVal(arr[i], (i+1), "d"); }
        // forward iteration
        for(int i=0, *it = arr.begin(); it != arr.end(); ++i, ++it)
        { AssertVal(*it, (i+1), "d"); }
        // reverse iteration
        for(int i=arr.length(), *it = arr.rbegin(); it != arr.rend(); --i, --it)
        { AssertVal(*it, i, "d"); }
        // *arr.end() = 8; // undefined behavior/error
        // *arr.rend() = 8; // undefined behavior/error
    }
    
    puts("--- Array from intializer list of Tracer objects ------");
    Tracer::Reset();
    {
        Array<Tracer> array { Tracer(1), Tracer(2), Tracer(3), Tracer(4) };
        AssertVal(Tracer::Top(), 4LLU, "llu");
        AssertVal(Tracer::Active(), 4LLU, "llu");
    }
    AssertVal(Tracer::Top(), 4LLU, "llu");
    AssertVal(Tracer::Active(), 0LLU, "llu");

puts("--- Array from intializer list of Tracer objects op= ------");
    Tracer::Reset();
    {
        Array<Tracer> array { Tracer(1), Tracer(2) };
        AssertVal(array.length(), 2LU, "zu");
        AssertVal(Tracer::Top(), 2LLU, "llu");
        AssertVal(Tracer::Active(), 2LLU, "llu");
        array = { Tracer(1), Tracer(2), Tracer(3), Tracer(4) };
        AssertVal(array.length(), 4LU, "zu");
        AssertVal(Tracer::Top(), 6LLU, "llu");
        AssertVal(Tracer::Active(), 4LLU, "llu");
    }
    AssertVal(Tracer::Top(), 6LLU, "llu");
    AssertVal(Tracer::Active(), 0LLU, "llu");
# endif
    
    puts("--- resize Array of ints ----------------");
    {
        puts("  --- resize from 0 to non-zero -------------");
        {
            Array<int> arr;
            Assert(arr.isEmpty());
            AssertVal(arr.length(), 0LU, "zu");
            Assert(arr.resize(4));
            Assert(!arr.isEmpty());
            AssertVal(arr.length(), 4LU, "zu");
            for(int i=0; i<int(arr.length()); ++i)
                arr[i] = (i+1);
            for(int i=0; i<int(arr.length()); ++i)
            { AssertVal(arr[i], (i+1), "d"); }
        }

puts("  --- resize from non-zero to 0 -------------");
        {
            Array<int> arr(4);
            Assert(!arr.isEmpty());
            AssertVal(arr.length(), 4LU, "zu");
            for(int i=0; i<int(arr.length()); ++i)
                arr[i] = (i+1);
            for(int i=0; i<int(arr.length()); ++i)
            { AssertVal(arr[i], (i+1), "d"); }
            Assert(arr.resize(0));
            Assert(arr.isEmpty());
            AssertVal(arr.length(), 0LU, "zu");
        }
        
        puts("  --- resize from non-zero to greater -----------");
        {
            Array<int> arr(4);
            Assert(!arr.isEmpty());
            AssertVal(arr.length(), 4LU, "zu");
            for(int i=0; i<int(arr.length()); ++i)
                arr[i] = (i+1);
            for(int i=0; i<int(arr.length()); ++i)
            { AssertVal(arr[i], (i+1), "d"); }
            Assert(arr.resize(7));
            Assert(!arr.isEmpty());
            AssertVal(arr.length(), 7LU, "zu");
            
            for(int i=0; i<4; ++i)
            { AssertVal(arr[i], (i+1), "d"); }

for(int i=4; i<int(arr.length()); ++i)
            { AssertVal(arr[i], 0, "d"); }
        }
        
        puts("  --- resize from non-zero to lesser -----------");
        {
            Array<int> arr(7);
            Assert(!arr.isEmpty());
            AssertVal(arr.length(), 7LU, "zu");
            for(int i=0; i<int(arr.length()); ++i)
                arr[i] = (i+1);
            for(int i=0; i<int(arr.length()); ++i)
            { AssertVal(arr[i], (i+1), "d"); }
            Assert(arr.resize(4));
            Assert(!arr.isEmpty());
            AssertVal(arr.length(), 4LU, "zu");
            
            for(int i=0; i<int(arr.length()); ++i)
            { AssertVal(arr[i], (i+1), "d"); }
        }
        
        puts("  --- resize from non-zero with the same size -----------");
        {
            Array<int> arr(7);
            Assert(!arr.isEmpty());
            AssertVal(arr.length(), 7LU, "zu");
            for(int i=0; i<int(arr.length()); ++i)
                arr[i] = (i+1);
            for(int i=0; i<int(arr.length()); ++i)
            { AssertVal(arr[i], (i+1), "d"); }
            Assert(arr.resize(7));
            Assert(!arr.isEmpty());
            AssertVal(arr.length(), 7LU, "zu");
            
            for(int i=0; i<int(arr.length()); ++i)
            { AssertVal(arr[i], (i+1), "d"); }
        }
    }

puts("--- resize Array of Tracer objects ----------------");
    {
        puts("  --- resize from 0 to non-zero -------------");
        {
            Tracer::Reset();
            Array<Tracer> arr;
            AssertVal(Tracer::Top(), 0LLU, "llu");
            AssertVal(Tracer::Active(), 0LLU, "llu");
            Assert(arr.isEmpty());
            AssertVal(arr.length(), 0LU, "zu");
            Assert(arr.resize(4));
            AssertVal(Tracer::Top(), 4LLU, "llu");
            AssertVal(Tracer::Active(), 4LLU, "llu");
            Assert(!arr.isEmpty());
            AssertVal(arr.length(), 4LU, "zu");
            for(int i=0; i<int(arr.length()); ++i)
                arr[i] = (i+1);
            for(int i=0; i<int(arr.length()); ++i)
            { AssertVal(arr[i].value, (i+1), "d"); }
        }
        AssertVal(Tracer::Top(), 4LLU, "llu");
        AssertVal(Tracer::Active(), 0LLU, "llu");

puts("  --- resize from non-zero to 0 -------------");
        {
            Tracer::Reset();
            Array<Tracer> arr(4);
            AssertVal(Tracer::Top(), 4LLU, "llu");
            AssertVal(Tracer::Active(), 4LLU, "llu");
            Assert(!arr.isEmpty());
            AssertVal(arr.length(), 4LU, "zu");
            for(int i=0; i<int(arr.length()); ++i)
                arr[i] = (i+1);
            for(int i=0; i<int(arr.length()); ++i)
            { AssertVal(arr[i].value, (i+1), "d"); }
            Assert(arr.resize(0));
            AssertVal(Tracer::Top(), 4LLU, "llu");
            AssertVal(Tracer::Active(), 0LLU, "llu");
            Assert(arr.isEmpty());
            AssertVal(arr.length(), 0LU, "zu");
        }
        AssertVal(Tracer::Top(), 4LLU, "llu");
        AssertVal(Tracer::Active(), 0LLU, "llu");
        
        puts("  --- resize from non-zero to greater -----------");
        {
            Tracer::Reset();
            Array<Tracer> arr(4);
            AssertVal(Tracer::Top(), 4LLU, "llu");
            AssertVal(Tracer::Active(), 4LLU, "llu");
            Assert(!arr.isEmpty());
            AssertVal(arr.length(), 4LU, "zu");
            for(int i=0; i<int(arr.length()); ++i)
                arr[i] = (i+1);
            for(int i=0; i<int(arr.length()); ++i)
            { AssertVal(arr[i].value, (i+1), "d"); }
            Assert(arr.resize(7));
            AssertVal(Tracer::Top(), 7LLU, "llu");
            AssertVal(Tracer::Active(), 7LLU, "llu");
            Assert(!arr.isEmpty());
            AssertVal(arr.length(), 7LU, "zu");
            
            for(int i=0; i<4; ++i)
            { AssertVal(arr[i].value, (i+1), "d"); }

for(int i=4; i<int(arr.length()); ++i)
            { AssertVal(arr[i].value, 0, "d"); }
        }
        AssertVal(Tracer::Top(), 7LLU, "llu");
        AssertVal(Tracer::Active(), 0LLU, "llu");
        
        puts("  --- resize from non-zero to lesser -----------");
        {
            Tracer::Reset();
            Array<Tracer> arr(7);
            AssertVal(Tracer::Top(), 7LLU, "llu");
            AssertVal(Tracer::Active(), 7LLU, "llu");
            Assert(!arr.isEmpty());
            AssertVal(arr.length(), 7LU, "zu");
            for(int i=0; i<int(arr.length()); ++i)
                arr[i] = (i+1);
            for(int i=0; i<int(arr.length()); ++i)
            { AssertVal(arr[i].value, (i+1), "d"); }
            Assert(arr.resize(4));
            AssertVal(Tracer::Top(), 7LLU, "llu");
            AssertVal(Tracer::Active(), 4LLU, "llu");
            Assert(!arr.isEmpty());
            AssertVal(arr.length(), 4LU, "zu");
            
            for(int i=0; i<int(arr.length()); ++i)
            { AssertVal(arr[i].value, (i+1), "d"); }
        }
        AssertVal(Tracer::Top(), 7LLU, "llu");
        AssertVal(Tracer::Active(), 0LLU, "llu");
        
        puts("  --- resize from non-zero with the same size -----------");
        {
            Tracer::Reset();
            Array<Tracer> arr(7);
            AssertVal(Tracer::Top(), 7LLU, "llu");
            AssertVal(Tracer::Active(), 7LLU, "llu");
            Assert(!arr.isEmpty());
            AssertVal(arr.length(), 7LU, "zu");
            for(int i=0; i<int(arr.length()); ++i)
                arr[i] = (i+1);
            for(int i=0; i<int(arr.length()); ++i)
            { AssertVal(arr[i].value, (i+1), "d"); }
            Assert(arr.resize(7));
            AssertVal(Tracer::Top(), 7LLU, "llu");
            AssertVal(Tracer::Active(), 7LLU, "llu");
            Assert(!arr.isEmpty());
            AssertVal(arr.length(), 7LU, "zu");
            
            for(int i=0; i<int(arr.length()); ++i)
            { AssertVal(arr[i].value, (i+1), "d"); }
        }
        AssertVal(Tracer::Top(), 7LLU, "llu");
        AssertVal(Tracer::Active(), 0LLU, "llu");
    }
}

// =====================================================================

//
 // Tracer
//

Tracer::~Tracer()
{
	if (destruct)
		--Tracer::S_ACTIVE;
}

Tracer::Tracer(const value_t& p_value) :
	id(++Tracer::S_TOP),
	value(p_value),
	destruct(true)
{
	++Tracer::S_ACTIVE;
}

Tracer::Tracer(const Tracer& tracer) :
	id(++Tracer::S_TOP),
	value(tracer.value),
	destruct(true)
{
	++Tracer::S_ACTIVE;
}

#if __cplusplus>=201103L
Tracer::Tracer(Tracer&& tracer) :
	id(tracer.id),
	value(tracer.value),
	destruct(true)
{
	tracer.value = 0;
	tracer.destruct = false;
}
#endif

Tracer& Tracer::operator=(const Tracer& tracer)
{
	Tracer::value = tracer.value;
	return *this;
}

Tracer& Tracer::operator=(const value_t& p_value)
{
	Tracer::value = p_value;
	return *this;
}

#if __cplusplus>=201103L
Tracer& Tracer::operator=(Tracer&& tracer)
{
	this->~Tracer();
	const_cast<id_t&>(Tracer::id) = tracer.id;
	Tracer::value = tracer.value;
	Tracer::destruct = true;
	tracer.value = 0;
	tracer.destruct = false;
	return *this;
}
#endif

bool Tracer::operator==(const Tracer& tracer) const
{
	return Tracer::value == tracer.value;
}

bool Tracer::operator!=(const Tracer& tracer) const
{
	return Tracer::value != tracer.value;
}

bool Tracer::operator<(const Tracer& tracer) const
{
	return Tracer::value < tracer.value;
}

bool Tracer::operator>(const Tracer& tracer) const
{
	return Tracer::value > tracer.value;
}

bool Tracer::operator==(int value) const
{
	return Tracer::value == value;
}

bool Tracer::operator!=(int value) const
{
	return Tracer::value != value;
}

bool Tracer::operator<(int value) const
{
	return Tracer::value < value;
}

bool Tracer::operator>(int value) const
{
	return Tracer::value > value;
}

void Tracer::Reset()
{
	Tracer::S_TOP = 0;
	Tracer::S_ACTIVE = 0;
}

const Tracer::id_t Tracer::Top()
{
	return Tracer::S_TOP;
}
const Tracer::id_t Tracer::Active()
{
	return Tracer::S_ACTIVE;
}

Tracer::id_t Tracer::S_TOP = 0;
Tracer::id_t Tracer::S_ACTIVE = 0;